src/osdep/osdep.c

   1 /* Features which vary with the OS */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <errno.h>
   8 #ifdef HAVE_IO_H
   9 #include <io.h> /* For win32 && set_bin(). */
  10 #endif
  11 #include <signal.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #ifdef HAVE_SYS_IOCTL_H
  16 #include <sys/ioctl.h>
  17 #endif
  18 #ifdef HAVE_SYS_SIGNAL_H
  19 #include <sys/signal.h>
  20 #endif
  21 #include <sys/types.h>
  22 #ifdef HAVE_SYS_SOCKET_H
  23 #include <sys/socket.h> /* Need to be after sys/types.h */
  24 #endif
  25 #ifdef HAVE_FCNTL_H
  26 #include <fcntl.h> /* OS/2 needs this after sys/types.h */
  27 #endif
  28
  29 /* We need to have it here. Stupid BSD. */
  30 #ifdef HAVE_NETINET_IN_H
  31 #include <netinet/in.h>
  32 #endif
  33 #ifdef HAVE_ARPA_INET_H
  34 #include <arpa/inet.h>
  35 #endif
  36
  37 /* This is for some exotic TOS mangling when handling passive FTP sockets. */
  38 #ifdef HAVE_NETINET_IN_SYSTM_H
  39 #include <netinet/in_systm.h>
  40 #else
  41 #ifdef HAVE_NETINET_IN_SYSTEM_H
  42 #include <netinet/in_system.h>
  43 #endif
  44 #endif
  45 #ifdef HAVE_NETINET_IP_H
  46 #include <netinet/ip.h>
  47 #endif
  48
  49 #ifdef HAVE_TERMIOS_H
  50 #include <termios.h>
  51 #endif
  52
  53 #ifdef HAVE_UNISTD_H
  54 #include <unistd.h>
  55 #endif
  56
  57 #ifdef HAVE_LOCALE_H
  58 /* For the sake of SunOS, keep this away from files including
  59  * intl/gettext/libintl.h because <locale.h> includes system <libintl.h> which
  60  * either includes system gettext header or contains gettext function
  61  * declarations. */
  62 #include <locale.h>
  63 #endif
  64
  65 #ifdef HAVE_X11
  66 #include <X11/Xlib.h>
  67 #include <X11/Xutil.h>
  68 #endif
  69
  70
  71 #include "elinks.h"
  72
  73 #include "main/select.h"
  74 #include "osdep/osdep.h"
  75 #include "osdep/signals.h"
  76 #include "terminal/terminal.h"
  77 #include "util/conv.h"
  78 #include "util/memory.h"
  79 #include "util/string.h"
  80
  81
  82 /* Set a file descriptor to non-blocking mode. It returns a non-zero value
  83  * on error. */
  84 int
  85 set_nonblocking_fd(int fd)
  86 {
  87 #if defined(O_NONBLOCK) || defined(O_NDELAY)
  88         int flags = fcntl(fd, F_GETFL, 0);
  89
  90         if (flags < 0) return -1;
  91 #if defined(O_NONBLOCK)
  92         return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
  93 #else
  94         return fcntl(fd, F_SETFL, flags | O_NDELAY);
  95 #endif
  96
  97 #elif defined(FIONBIO)
  98         int flag = 1;
  99
 100         return ioctl(fd, FIONBIO, &flag);
 101 #else
 102         return 0;
 103 #endif
 104 }
 105
 106 /* Set a file descriptor to blocking mode. It returns a non-zero value on
 107  * error. */
 108 int
 109 set_blocking_fd(int fd)
 110 {
 111 #if defined(O_NONBLOCK) || defined(O_NDELAY)
 112         int flags = fcntl(fd, F_GETFL, 0);
 113
 114         if (flags < 0) return -1;
 115 #if defined(O_NONBLOCK)
 116         return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
 117 #else
 118         return fcntl(fd, F_SETFL, flags & ~O_NDELAY);
 119 #endif
 120
 121 #elif defined(FIONBIO)
 122         int flag = 0;
 123
 124         return ioctl(fd, FIONBIO, &flag);
 125 #else
 126         return 0;
 127 #endif
 128 }
 129
 130 void
 131 set_ip_tos_throughput(int socket)
 132 {
 133 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
 134         int on = IPTOS_THROUGHPUT;
 135
 136         setsockopt(socket, IPPROTO_IP, IP_TOS, (char *) &on, sizeof(on));
 137 #endif
 138 }
 139
 140 int
 141 get_e(unsigned char *env)
 142 {
 143         char *v = getenv(env);
 144
 145         return (v ? atoi(v) : 0);
 146 }
 147
 148 unsigned char *
 149 get_cwd(void)
 150 {
 151         int bufsize = 128;
 152         unsigned char *buf;
 153
 154         while (1) {
 155                 buf = mem_alloc(bufsize);
 156                 if (!buf) return NULL;
 157                 if (getcwd(buf, bufsize)) return buf;
 158                 mem_free(buf);
 159
 160                 if (errno == EINTR) continue;
 161                 if (errno != ERANGE) return NULL;
 162                 bufsize += 128;
 163         }
 164
 165         return NULL;
 166 }
 167
 168 void
 169 set_cwd(unsigned char *path)
 170 {
 171         if (path) while (chdir(path) && errno == EINTR);
 172 }
 173
 174 unsigned char *
 175 get_shell(void)
 176 {
 177         unsigned char *shell = GETSHELL;
 178
 179         if (!shell || !*shell)
 180                 shell = DEFAULT_SHELL;
 181
 182         return shell;
 183 }
 184
 185
 186 /* Terminal size */
 187
 188 #if !defined(CONFIG_OS_OS2) && !defined(CONFIG_OS_WIN32)
 189
 190 static void
 191 sigwinch(void *s)
 192 {
 193         ((void (*)(void)) s)();
 194 }
 195
 196 void
 197 handle_terminal_resize(int fd, void (*fn)(void))
 198 {
 199         install_signal_handler(SIGWINCH, sigwinch, fn, 0);
 200 }
 201
 202 void
 203 unhandle_terminal_resize(int fd)
 204 {
 205         install_signal_handler(SIGWINCH, NULL, NULL, 0);
 206 }
 207
 208 void
 209 get_terminal_size(int fd, int *x, int *y)
 210 {
 211         struct winsize ws;
 212
 213         if (ioctl(1, TIOCGWINSZ, &ws) != -1) {
 214                 *x = ws.ws_col;
 215                 *y = ws.ws_row;
 216         } else {
 217                 *x = 0;
 218                 *y = 0;
 219         }
 220
 221         if (!*x) {
 222                 *x = get_e("COLUMNS");
 223                 if (!*x) *x = DEFAULT_TERMINAL_WIDTH;
 224         }
 225         if (!*y) {
 226                 *y = get_e("LINES");
 227                 if (!*y) *y = DEFAULT_TERMINAL_HEIGHT;
 228         }
 229 }
 230
 231 #endif
 232
 233 /* Pipe */
 234
 235 #if defined(CONFIG_OS_UNIX) || defined(CONFIG_OS_BEOS) || defined(CONFIG_OS_RISCOS)
 236
 237 void
 238 set_bin(int fd)
 239 {
 240 }
 241
 242 int
 243 c_pipe(int *fd)
 244 {
 245         return pipe(fd);
 246 }
 247
 248 #elif defined(CONFIG_OS_OS2) || defined(CONFIG_OS_WIN32)
 249
 250 void
 251 set_bin(int fd)
 252 {
 253         setmode(fd, O_BINARY);
 254 }
 255
 256 int
 257 c_pipe(int *fd)
 258 {
 259         int r = pipe(fd);
 260
 261         if (!r) {
 262                 set_bin(fd[0]);
 263                 set_bin(fd[1]);
 264         }
 265
 266         return r;
 267 }
 268
 269 #endif
 270
 271 /* Exec */
 272
 273 int
 274 is_twterm(void) /* Check if it make sense to call a twterm. */
 275 {
 276         static int tw = -1;
 277
 278         if (tw == -1) tw = !!getenv("TWDISPLAY");
 279
 280         return tw;
 281 }
 282
 283 int
 284 is_gnuscreen(void)
 285 {
 286         static int screen = -1;
 287
 288         if (screen == -1) screen = !!getenv("STY");
 289
 290         return screen;
 291 }
 292
 293
 294 #if defined(CONFIG_OS_UNIX) || defined(CONFIG_OS_WIN32)
 295
 296 int
 297 is_xterm(void)
 298 {
 299         static int xt = -1;
 300
 301         if (xt == -1) {
 302                 /* Paraphrased from debian bug 228977:
 303                  *
 304                  * It is not enough to simply check the DISPLAY env variable,
 305                  * as it is pretty legal to have a DISPLAY set. While these
 306                  * days this practice is pretty uncommon, it still makes sense
 307                  * sometimes, especially for people who prefer the text mode
 308                  * for some reason. Only relying on DISPLAY will results in bad
 309                  * codes being written to the terminal.
 310                  *
 311                  * Any real xterm derivative sets WINDOWID as well.
 312                  * Unfortunately, konsole is an exception, and it needs to be
 313                  * checked for separately.
 314                  *
 315                  * FIXME: The code below still fails to detect some terminals
 316                  * that do support a title (like the popular PuTTY ssh client).
 317                  * In general, proper xterm detection is a nightmarish task...
 318                  *
 319                  * -- Adam Borowski <kilobyte@mimuw.edu.pl> */
 320                 unsigned char *display = getenv("DISPLAY");
 321                 unsigned char *windowid = getenv("WINDOWID");
 322
 323                 if (!windowid || !*windowid)
 324                         windowid = getenv("KONSOLE_DCOP_SESSION");
 325                 xt = (display && *display && windowid && *windowid);
 326         }
 327
 328         return xt;
 329 }
 330
 331 #endif
 332
 333 unsigned int resize_count = 0;
 334
 335 #ifndef CONFIG_OS_OS2
 336
 337 #if !(defined(CONFIG_OS_BEOS) && defined(HAVE_SETPGID)) && !defined(CONFIG_OS_WIN32)
 338
 339 int
 340 exe(unsigned char *path)
 341 {
 342         return system(path);
 343 }
 344
 345 #endif
 346
 347 static unsigned char *clipboard;
 348
 349 unsigned char *
 350 get_clipboard_text(void)
 351 {
 352         /* The following support for GNU Screen's clipboard is
 353          * disabled for two reasons:
 354          *
 355          * 1. It does not actually return the string from that
 356          *    clipboard, but rather causes the clipboard contents to
 357          *    appear in stdin.  get_clipboard_text is normally called
 358          *    because the user pressed a Paste key in an input field,
 359          *    so the characters end up being inserted in that field;
 360          *    but if there are newlines in the clipboard, then the
 361          *    field may lose focus, in which case the remaining
 362          *    characters may trigger arbitrary actions in ELinks.
 363          *
 364          * 2. It pastes from both GNU Screen's clipboard and the ELinks
 365          *    internal clipboard.  Because set_clipboard_text also sets
 366          *    them both, the same text would typically get pasted twice.
 367          *
 368          * Users can instead use the GNU Screen key bindings to run the
 369          * paste command.  This method still suffers from problem 1 but
 370          * any user of GNU Screen should know that already.  */
 371 #if 0
 372         /* GNU Screen's clipboard */
 373         if (is_gnuscreen()) {
 374                 struct string str;
 375
 376                 if (!init_string(&str)) return NULL;
 377
 378                 add_to_string(&str, "screen -X paste .");
 379                 if (str.length) exe(str.source);
 380                 if (str.source) done_string(&str);
 381         }
 382 #endif
 383
 384         return stracpy(empty_string_or_(clipboard));
 385 }
 386
 387 void
 388 set_clipboard_text(unsigned char *data)
 389 {
 390         /* GNU Screen's clipboard */
 391         if (is_gnuscreen()) {
 392                 struct string str;
 393
 394                 if (!init_string(&str)) return;
 395
 396                 add_to_string(&str, "screen -X register . ");
 397                 add_shell_quoted_to_string(&str, data, strlen(data));
 398
 399                 if (str.length) exe(str.source);
 400                 if (str.source) done_string(&str);
 401         }
 402
 403         /* Shouldn't complain about leaks. */
 404         if (clipboard) free(clipboard);
 405         clipboard = strdup(data);
 406 }
 407
 408 /* Set xterm-like term window's title. */
 409 void
 410 set_window_title(unsigned char *title)
 411 {
 412         unsigned char *s;
 413         int xsize, ysize;
 414         int j = 0;
 415
 416 #ifndef HAVE_SYS_CYGWIN_H
 417         /* Check if we're in a xterm-like terminal. */
 418         if (!is_xterm() && !is_gnuscreen()) return;
 419 #endif
 420
 421         /* Retrieve terminal dimensions. */
 422         get_terminal_size(0, &xsize, &ysize);
 423
 424         /* Check if terminal width is reasonnable. */
 425         if (xsize < 1 || xsize > 1024) return;
 426
 427         /* Allocate space for title + 3 ending points + null char. */
 428         s = mem_alloc(xsize + 3 + 1);
 429         if (!s) return;
 430
 431         /* Copy title to s if different from NULL */
 432         if (title) {
 433                 int i;
 434
 435                 /* We limit title length to terminal width and ignore control
 436                  * chars if any. Note that in most cases window decoration
 437                  * reduces printable width, so it's just a precaution. */
 438                 /* Note that this is the right place where to do it, since
 439                  * potential alternative set_window_title() routines might
 440                  * want to take different precautions. */
 441                 for (i = 0; title[i] && i < xsize; i++) {
 442                         /* 0x80 .. 0x9f are ISO-8859-* control characters.
 443                          * In some other encodings they could be used for
 444                          * legitimate characters, though (ie. in Kamenicky).
 445                          * We should therefore maybe check for these only
 446                          * if the terminal is running in an ISO- encoding. */
 447                         if (iscntrl(title[i]) || (title[i] & 0x7f) < 0x20
 448                             || title[i] == 0x7f)
 449                                 continue;
 450
 451                         s[j++] = title[i];
 452                 }
 453
 454                 /* If title is truncated, add "..." */
 455                 if (i == xsize) {
 456                         s[j++] = '.';
 457                         s[j++] = '.';
 458                         s[j++] = '.';
 459                 }
 460         }
 461         s[j] = '\0';
 462
 463         /* Send terminal escape sequence + title string */
 464         printf("\033]0;%s\a", s);
 465
 466 #if 0
 467         /* Miciah don't like this so it is disabled because it changes the
 468          * default window name. --jonas */
 469         /* Set the GNU screen window name */
 470         if (is_gnuscreen())
 471                 printf("\033k%s\033\134", s);
 472 #endif
 473
 474         fflush(stdout);
 475
 476         mem_free(s);
 477 }
 478
 479 #ifdef HAVE_X11
 480 static int x_error = 0;
 481
 482 static int
 483 catch_x_error(void)
 484 {
 485         x_error = 1;
 486         return 0;
 487 }
 488 #endif
 489
 490 unsigned char *
 491 get_window_title(void)
 492 {
 493 #ifdef HAVE_X11
 494         /* Following code is stolen from our beloved vim. */
 495         unsigned char *winid;
 496         Display *display;
 497         Window window, root, parent, *children;
 498         XTextProperty text_prop;
 499         Status status;
 500         unsigned int num_children;
 501         unsigned char *ret = NULL;
 502
 503         if (!is_xterm())
 504                 return NULL;
 505
 506         winid = getenv("WINDOWID");
 507         if (!winid)
 508                 return NULL;
 509         window = (Window) atol(winid);
 510         if (!window)
 511                 return NULL;
 512
 513         display = XOpenDisplay(NULL);
 514         if (!display)
 515                 return NULL;
 516
 517         /* If WINDOWID is bad, we don't want X to abort us. */
 518         x_error = 0;
 519         XSetErrorHandler((int (*)(Display *, XErrorEvent *)) catch_x_error);
 520
 521         status = XGetWMName(display, window, &text_prop);
 522         /* status = XGetWMIconName(x11_display, x11_window, &text_prop); */
 523         while (!x_error && (!status || !text_prop.value)) {
 524                 if (!XQueryTree(display, window, &root, &parent, &children, &num_children))
 525                         break;
 526                 if (children)
 527                         XFree((void *) children);
 528                 if (parent == root || parent == 0)
 529                         break;
 530                 window = parent;
 531                 status = XGetWMName(display, window, &text_prop);
 532         }
 533
 534         if (!x_error && status && text_prop.value) {
 535                 ret = stracpy(text_prop.value);
 536                 XFree(text_prop.value);
 537         }
 538
 539         XCloseDisplay(display);
 540
 541         return ret;
 542 #else
 543         /* At least reset the window title to a blank one. */
 544         return stracpy("");
 545 #endif
 546 }
 547
 548 int
 549 resize_window(int width, int height, int old_width, int old_height)
 550 {
 551 #ifdef HAVE_X11
 552         /* Following code is stolen from our beloved vim. */
 553         unsigned char *winid;
 554         Display *display;
 555         Window window;
 556         Status status;
 557         XWindowAttributes attributes;
 558
 559         if (!is_xterm())
 560                 return -1;
 561
 562         winid = getenv("WINDOWID");
 563         if (!winid)
 564                 return -1;
 565         window = (Window) atol(winid);
 566         if (!window)
 567                 return -1;
 568
 569         display = XOpenDisplay(NULL);
 570         if (!display)
 571                 return -1;
 572
 573         /* If WINDOWID is bad, we don't want X to abort us. */
 574         x_error = 0;
 575         XSetErrorHandler((int (*)(Display *, XErrorEvent *)) catch_x_error);
 576
 577         status = XGetWindowAttributes(display, window, &attributes);
 578
 579         while (!x_error && !status) {
 580                 Window root, parent, *children;
 581                 unsigned int num_children;
 582
 583                 if (!XQueryTree(display, window, &root, &parent, &children, &num_children))
 584                         break;
 585                 if (children)
 586                         XFree((void *) children);
 587                 if (parent == root || parent == 0)
 588                         break;
 589                 window = parent;
 590                 status = XGetWindowAttributes(display, window, &attributes);
 591         }
 592
 593         if (!x_error && status) {
 594                 XSizeHints *size_hints;
 595                 long mask;
 596                 int px_width = 0;
 597                 int px_height = 0;
 598
 599                 /* With xterm 210, a window with 80x24 characters at
 600                  * a 6x13 font appears to have 484x316 pixels; both
 601                  * the width and height include four extra pixels.
 602                  * Computing a new size by scaling these values often
 603                  * results in windows that cannot display as many
 604                  * characters as was intended.  We can do better if we
 605                  * can find out the actual size of character cells.
 606                  * If the terminal emulator has set a window size
 607                  * increment, assume that is the cell size.  */
 608                 size_hints = XAllocSizeHints();
 609                 if (size_hints != NULL
 610                     && XGetWMNormalHints(display, window, size_hints, &mask)
 611                     && (mask & PResizeInc) != 0) {
 612                         px_width = attributes.width
 613                                 + (width - old_width) * size_hints->width_inc;
 614                         px_height = attributes.height
 615                                 + (height - old_height) * size_hints->height_inc;
 616                 }
 617                 if (px_width <= 0 || px_height <= 0) {
 618                         double ratio_width = (double) attributes.width  / old_width;
 619                         double ratio_height = (double) attributes.height / old_height;
 620
 621                         px_width  = (int) ((double) width * ratio_width);
 622                         px_height = (int) ((double) height * ratio_height);
 623                 }
 624
 625                 if (size_hints)
 626                         XFree(size_hints);
 627
 628                 status = XResizeWindow(display, window, px_width, px_height);
 629                 while (!x_error && !status) {
 630                         Window root, parent, *children;
 631                         unsigned int num_children;
 632
 633                         if (!XQueryTree(display, window, &root, &parent, &children, &num_children))
 634                                 break;
 635                         if (children)
 636                                 XFree((void *) children);
 637                         if (parent == root || parent == 0)
 638                                 break;
 639                         window = parent;
 640                         status = XResizeWindow(display, window, px_width, px_height);
 641                 }
 642         }
 643
 644         XCloseDisplay(display);
 645
 646         return 0;
 647 #else
 648         return -1;
 649 #endif
 650 }
 651
 652 #endif
 653
 654
 655 /* Threads */
 656
 657 #if defined(HAVE_BEGINTHREAD) || defined(CONFIG_OS_BEOS)
 658
 659 struct tdata {
 660         void (*fn)(void *, int);
 661         int h;
 662         unsigned char data[1];
 663 };
 664
 665 void
 666 bgt(struct tdata *t)
 667 {
 668 #ifdef SIGPIPE
 669         signal(SIGPIPE, SIG_IGN);
 670 #endif
 671         t->fn(t->data, t->h);
 672         write(t->h, "x", 1);
 673         close(t->h);
 674         free(t);
 675 }
 676
 677 #else
 678
 679 int
 680 start_thread(void (*fn)(void *, int), void *ptr, int l)
 681 {
 682         int p[2];
 683         pid_t pid;
 684
 685         if (c_pipe(p) < 0) return -1;
 686         if (set_nonblocking_fd(p[0]) < 0) return -1;
 687         if (set_nonblocking_fd(p[1]) < 0) return -1;
 688
 689         pid = fork();
 690         if (!pid) {
 691                 struct terminal *term;
 692
 693                 /* Close input in this thread; otherwise, if it will live
 694                  * longer than its parent, it'll block the terminal until it'll
 695                  * quit as well; this way it will hopefully just die unseen and
 696                  * in background, causing no trouble. */
 697                 /* Particularly, when async dns resolving was in progress and
 698                  * someone quitted ELinks, it could make a delay before the
 699                  * terminal would be really freed and returned to shell. */
 700                 foreach (term, terminals)
 701                         if (term->fdin > 0)
 702                                 close(term->fdin);
 703
 704                 close(p[0]);
 705                 fn(ptr, p[1]);
 706                 write(p[1], "x", 1);
 707                 close(p[1]);
 708                 /* We use _exit() here instead of exit(), see
 709                  * http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC6 for
 710                  * reasons. Fixed by Sven Neumann <sven@convergence.de>. */
 711                 _exit(0);
 712         }
 713         if (pid == -1) {
 714                 close(p[0]);
 715                 close(p[1]);
 716                 return -1;
 717         }
 718
 719         close(p[1]);
 720         return p[0];
 721 }
 722
 723 #endif
 724
 725
 726 #ifndef OS2_MOUSE
 727 void
 728 want_draw(void)
 729 {
 730 }
 731
 732 void
 733 done_draw(void)
 734 {
 735 }
 736 #endif
 737
 738
 739 #if !defined(CONFIG_OS_WIN32)
 740 int
 741 get_output_handle(void)
 742 {
 743         return 1;
 744 }
 745
 746 int
 747 get_ctl_handle(void)
 748 {
 749         static int fd = -1;
 750
 751         if (isatty(0)) return 0;
 752         if (fd < 0) fd = open("/dev/tty", O_RDONLY);
 753         return fd;
 754 }
 755 #endif
 756
 757
 758 #if !defined(CONFIG_OS_BEOS) && !(defined(HAVE_BEGINTHREAD) && defined(HAVE_READ_KBD)) \
 759         && !defined(CONFIG_OS_WIN32)
 760
 761 int
 762 get_input_handle(void)
 763 {
 764         return get_ctl_handle();
 765 }
 766
 767 #endif
 768
 769 #ifndef CONFIG_OS_WIN32
 770
 771 void
 772 init_osdep(void)
 773 {
 774 #ifdef HAVE_LOCALE_H
 775         setlocale(LC_ALL, "");
 776 #endif
 777 }
 778
 779 #endif
 780
 781 #if defined(CONFIG_OS_UNIX) || defined(CONFIG_OS_OS2) || defined(CONFIG_OS_RISCOS)
 782
 783 void
 784 terminate_osdep(void)
 785 {
 786 }
 787
 788 #endif
 789
 790 #ifndef CONFIG_OS_BEOS
 791
 792 void
 793 block_stdin(void)
 794 {
 795 }
 796
 797 void
 798 unblock_stdin(void)
 799 {
 800 }
 801
 802 #endif
 803
 804
 805 void
 806 elinks_cfmakeraw(struct termios *t)
 807 {
 808         /* This elinks_cfmakeraw() intentionally leaves the following
 809          * settings unchanged, even though the standard cfmakeraw()
 810          * would change some of them:
 811          *
 812          * - c_cflag & CSIZE: number of bits per character.
 813          *   Bug 54 asked ELinks not to change this.
 814          * - c_cflag & (PARENB | PARODD): parity bit in characters.
 815          *   Bug 54 asked ELinks not to change this.
 816          * - c_iflag & (IXON | IXOFF | IXANY): XON/XOFF flow control.
 817          *
 818          * The reasoning is, if the user has set up unusual values for
 819          * those settings before starting ELinks, then the terminal
 820          * probably expects those values and ELinks should not mess
 821          * with them.  */
 822         t->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL);
 823         t->c_oflag &= ~OPOST;
 824         t->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
 825         t->c_cc[VMIN] = 1;
 826         t->c_cc[VTIME] = 0;
 827 }
 828
 829 #if !defined(CONFIG_MOUSE) || (!defined(CONFIG_GPM) && !defined(CONFIG_SYSMOUSE) && !defined(OS2_MOUSE))
 830
 831 void *
 832 handle_mouse(int cons, void (*fn)(void *, unsigned char *, int),
 833              void *data)
 834 {
 835         return NULL;
 836 }
 837
 838 void
 839 unhandle_mouse(void *data)
 840 {
 841 }
 842
 843 void
 844 suspend_mouse(void *data)
 845 {
 846 }
 847
 848 void
 849 resume_mouse(void *data)
 850 {
 851 }
 852
 853 #endif
 854
 855 #ifndef CONFIG_OS_WIN32
 856 /* Create a bitmask consisting from system-independent envirnoment modifiers.
 857  * This is then complemented by system-specific modifiers in an appropriate
 858  * get_system_env() routine. */
 859 static int
 860 get_common_env(void)
 861 {
 862         int env = 0;
 863
 864         if (is_xterm()) env |= ENV_XWIN;
 865         if (is_twterm()) env |= ENV_TWIN;
 866         if (is_gnuscreen()) env |= ENV_SCREEN;
 867
 868         /* ENV_CONSOLE is always set now and indicates that we are working w/ a
 869          * displaying-capable character-adressed terminal. Sounds purely
 870          * theoretically now, but it already makes some things easier and it
 871          * could give us interesting opportunities later (after graphical
 872          * frontends will be introduced, when working in some mysterious daemon
 873          * mode or who knows what ;). --pasky */
 874         env |= ENV_CONSOLE;
 875
 876         return env;
 877 }
 878 #endif
 879
 880 #if defined(CONFIG_OS_UNIX) || defined(CONFIG_OS_RISCOS)
 881 int
 882 get_system_env(void)
 883 {
 884         return get_common_env();
 885 }
 886 #endif
 887
 888
 889 int
 890 can_resize_window(int environment)
 891 {
 892         return !!(environment & (ENV_OS2VIO | ENV_XWIN));
 893 }
 894
 895 #ifndef CONFIG_OS_OS2
 896 int
 897 can_open_os_shell(int environment)
 898 {
 899         return 1;
 900 }
 901
 902 void
 903 set_highpri(void)
 904 {
 905 }
 906 #endif
 907
 908
 909 unsigned char *
 910 get_system_str(int xwin)
 911 {
 912         return xwin ? SYSTEM_STR "-xwin" : SYSTEM_STR;
 913 }