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, int codepage)
 411 {
 412         struct string filtered;
 413
 414 #ifndef HAVE_SYS_CYGWIN_H
 415         /* Check if we're in a xterm-like terminal. */
 416         if (!is_xterm()) return;
 417 #endif
 418
 419         if (!init_string(&filtered)) return;
 420
 421         /* Copy title to filtered if different from NULL */
 422         if (title) {
 423                 unsigned char *scan = title;
 424                 unsigned char *end = title + strlen(title);
 425
 426                 /* Remove control characters, so that they cannot
 427                  * interfere with the command we send to the terminal.
 428                  * However, do not attempt to limit the title length
 429                  * to terminal width, because the title is usually
 430                  * drawn in a different font anyway.  */
 431                 /* Note that this is the right place where to do it, since
 432                  * potential alternative set_window_title() routines might
 433                  * want to take different precautions. */
 434                 for (;;) {
 435                         unsigned char *charbegin = scan;
 436                         unicode_val_T unicode
 437                                 = cp_to_unicode(codepage, &scan, end);
 438                         int charlen = scan - charbegin;
 439
 440                         if (unicode == UCS_NO_CHAR)
 441                                 break;
 442
 443                         /* This need not recognize all Unicode control
 444                          * characters.  Only those that can make the
 445                          * terminal misparse the command.  */
 446                         if (unicode < 0x20
 447                             || (unicode >= 0x7F && unicode < 0xA0))
 448                                 continue;
 449
 450                         /* If the title is getting too long, truncate
 451                          * it and add an ellipsis.
 452                          *
 453                          * xterm entirely rejects 1024-byte or longer
 454                          * titles.  GNU Screen 4.00.03 misparses
 455                          * titles longer than 765 bytes, and is unable
 456                          * to display the title in hardstatus if the
 457                          * title and other stuff together exceed 766
 458                          * bytes.  So set the limit quite a bit lower.  */
 459                         if (filtered.length + charlen >= 600 - 3) {
 460                                 add_to_string(&filtered, "...");
 461                                 break;
 462                         }
 463
 464                         add_bytes_to_string(&filtered, charbegin, charlen);
 465                 }
 466         }
 467
 468         /* Send terminal escape sequence + title string */
 469         printf("\033]0;%s\a", filtered.source);
 470
 471 #if 0
 472         /* Miciah don't like this so it is disabled because it changes the
 473          * default window name. --jonas */
 474         /* Set the GNU screen window name */
 475         if (is_gnuscreen())
 476                 printf("\033k%s\033\134", filtered.source);
 477 #endif
 478
 479         fflush(stdout);
 480
 481         done_string(&filtered);
 482 }
 483
 484 #ifdef HAVE_X11
 485 static int x_error = 0;
 486
 487 static int
 488 catch_x_error(void)
 489 {
 490         x_error = 1;
 491         return 0;
 492 }
 493
 494 /** Convert a STRING XTextProperty to a string in the specified codepage.
 495  *
 496  * @return the string that the caller must free with mem_free(),
 497  * or NULL on error.  */
 498 static unsigned char *
 499 xprop_to_string(Display *display, const XTextProperty *text_prop, int to_cp)
 500 {
 501         int from_cp;
 502         char **list = NULL;
 503         int count = 0;
 504         struct conv_table *convert_table;
 505         unsigned char *ret = NULL;
 506
 507         /* <X11/Xlib.h> defines X_HAVE_UTF8_STRING if
 508          * Xutf8TextPropertyToTextList is available.
 509          *
 510          * The X...TextPropertyToTextList functions return a negative
 511          * error code, or Success=0, or the number of unconvertible
 512          * characters.  Use the result even if some characters were
 513          * unconvertible, because convert_string() can be lossy too,
 514          * and it seems better to restore an approximation of the
 515          * original title than to restore a default title that may be
 516          * entirely different.  */
 517 #if defined(CONFIG_UTF8) && defined(X_HAVE_UTF8_STRING)
 518
 519         from_cp = get_cp_index("UTF-8");
 520         if (Xutf8TextPropertyToTextList(display, text_prop, &list,
 521                                         &count) < 0)
 522                 return NULL;
 523
 524 #else  /* !defined(X_HAVE_UTF8_STRING) || !defined(CONFIG_UTF8) */
 525
 526         from_cp = get_cp_index("System");
 527         if (XmbTextPropertyToTextList(display, text_prop, &list,
 528                                       &count) < 0)
 529                 return NULL;
 530
 531 #endif /* !defined(X_HAVE_UTF8_STRING) || !defined(CONFIG_UTF8) */
 532
 533         convert_table = get_translation_table(from_cp, to_cp);
 534         if (count >= 1 && convert_table)
 535                 ret = convert_string(convert_table, list[0], strlen(list[0]),
 536                                      to_cp, CSM_NONE, NULL, NULL, NULL);
 537
 538         XFreeStringList(list);
 539         return ret;
 540 }
 541 #endif  /* HAVE_X11 */
 542
 543 unsigned char *
 544 get_window_title(int codepage)
 545 {
 546 #ifdef HAVE_X11
 547         /* Following code is stolen from our beloved vim. */
 548         unsigned char *winid;
 549         Display *display;
 550         Window window, root, parent, *children;
 551         XTextProperty text_prop;
 552         Status status;
 553         unsigned int num_children;
 554         unsigned char *ret = NULL;
 555
 556         if (!is_xterm())
 557                 return NULL;
 558
 559         winid = getenv("WINDOWID");
 560         if (!winid)
 561                 return NULL;
 562         window = (Window) atol(winid);
 563         if (!window)
 564                 return NULL;
 565
 566         display = XOpenDisplay(NULL);
 567         if (!display)
 568                 return NULL;
 569
 570         /* If WINDOWID is bad, we don't want X to abort us. */
 571         x_error = 0;
 572         XSetErrorHandler((int (*)(Display *, XErrorEvent *)) catch_x_error);
 573
 574         status = XGetWMName(display, window, &text_prop);
 575         /* status = XGetWMIconName(x11_display, x11_window, &text_prop); */
 576         while (!x_error && (!status || !text_prop.value)) {
 577                 if (!XQueryTree(display, window, &root, &parent, &children, &num_children))
 578                         break;
 579                 if (children)
 580                         XFree((void *) children);
 581                 if (parent == root || parent == 0)
 582                         break;
 583                 window = parent;
 584                 status = XGetWMName(display, window, &text_prop);
 585         }
 586
 587         if (!x_error && status && text_prop.value) {
 588                 ret = xprop_to_string(display, &text_prop, codepage);
 589                 XFree(text_prop.value);
 590         }
 591
 592         XCloseDisplay(display);
 593
 594         return ret;
 595 #else
 596         /* At least reset the window title to a blank one. */
 597         return stracpy("");
 598 #endif
 599 }
 600
 601 int
 602 resize_window(int width, int height, int old_width, int old_height)
 603 {
 604 #ifdef HAVE_X11
 605         /* Following code is stolen from our beloved vim. */
 606         unsigned char *winid;
 607         Display *display;
 608         Window window;
 609         Status status;
 610         XWindowAttributes attributes;
 611
 612         if (!is_xterm())
 613                 return -1;
 614
 615         winid = getenv("WINDOWID");
 616         if (!winid)
 617                 return -1;
 618         window = (Window) atol(winid);
 619         if (!window)
 620                 return -1;
 621
 622         display = XOpenDisplay(NULL);
 623         if (!display)
 624                 return -1;
 625
 626         /* If WINDOWID is bad, we don't want X to abort us. */
 627         x_error = 0;
 628         XSetErrorHandler((int (*)(Display *, XErrorEvent *)) catch_x_error);
 629
 630         status = XGetWindowAttributes(display, window, &attributes);
 631
 632         while (!x_error && !status) {
 633                 Window root, parent, *children;
 634                 unsigned int num_children;
 635
 636                 if (!XQueryTree(display, window, &root, &parent, &children, &num_children))
 637                         break;
 638                 if (children)
 639                         XFree((void *) children);
 640                 if (parent == root || parent == 0)
 641                         break;
 642                 window = parent;
 643                 status = XGetWindowAttributes(display, window, &attributes);
 644         }
 645
 646         if (!x_error && status) {
 647                 XSizeHints *size_hints;
 648                 long mask;
 649                 int px_width = 0;
 650                 int px_height = 0;
 651
 652                 /* With xterm 210, a window with 80x24 characters at
 653                  * a 6x13 font appears to have 484x316 pixels; both
 654                  * the width and height include four extra pixels.
 655                  * Computing a new size by scaling these values often
 656                  * results in windows that cannot display as many
 657                  * characters as was intended.  We can do better if we
 658                  * can find out the actual size of character cells.
 659                  * If the terminal emulator has set a window size
 660                  * increment, assume that is the cell size.  */
 661                 size_hints = XAllocSizeHints();
 662                 if (size_hints != NULL
 663                     && XGetWMNormalHints(display, window, size_hints, &mask)
 664                     && (mask & PResizeInc) != 0) {
 665                         px_width = attributes.width
 666                                 + (width - old_width) * size_hints->width_inc;
 667                         px_height = attributes.height
 668                                 + (height - old_height) * size_hints->height_inc;
 669                 }
 670                 if (px_width <= 0 || px_height <= 0) {
 671                         double ratio_width = (double) attributes.width  / old_width;
 672                         double ratio_height = (double) attributes.height / old_height;
 673
 674                         px_width  = (int) ((double) width * ratio_width);
 675                         px_height = (int) ((double) height * ratio_height);
 676                 }
 677
 678                 if (size_hints)
 679                         XFree(size_hints);
 680
 681                 status = XResizeWindow(display, window, px_width, px_height);
 682                 while (!x_error && !status) {
 683                         Window root, parent, *children;
 684                         unsigned int num_children;
 685
 686                         if (!XQueryTree(display, window, &root, &parent, &children, &num_children))
 687                                 break;
 688                         if (children)
 689                                 XFree((void *) children);
 690                         if (parent == root || parent == 0)
 691                                 break;
 692                         window = parent;
 693                         status = XResizeWindow(display, window, px_width, px_height);
 694                 }
 695         }
 696
 697         XCloseDisplay(display);
 698
 699         return 0;
 700 #else
 701         return -1;
 702 #endif
 703 }
 704
 705 #endif
 706
 707
 708 /* Threads */
 709
 710 #if defined(HAVE_BEGINTHREAD) || defined(CONFIG_OS_BEOS)
 711
 712 struct tdata {
 713         void (*fn)(void *, int);
 714         int h;
 715         unsigned char data[1];
 716 };
 717
 718 void
 719 bgt(struct tdata *t)
 720 {
 721 #ifdef SIGPIPE
 722         signal(SIGPIPE, SIG_IGN);
 723 #endif
 724         t->fn(t->data, t->h);
 725         write(t->h, "x", 1);
 726         close(t->h);
 727         free(t);
 728 }
 729
 730 #else
 731
 732 int
 733 start_thread(void (*fn)(void *, int), void *ptr, int l)
 734 {
 735         int p[2];
 736         pid_t pid;
 737
 738         if (c_pipe(p) < 0) return -1;
 739         if (set_nonblocking_fd(p[0]) < 0) return -1;
 740         if (set_nonblocking_fd(p[1]) < 0) return -1;
 741
 742         pid = fork();
 743         if (!pid) {
 744                 struct terminal *term;
 745
 746                 /* Close input in this thread; otherwise, if it will live
 747                  * longer than its parent, it'll block the terminal until it'll
 748                  * quit as well; this way it will hopefully just die unseen and
 749                  * in background, causing no trouble. */
 750                 /* Particularly, when async dns resolving was in progress and
 751                  * someone quitted ELinks, it could make a delay before the
 752                  * terminal would be really freed and returned to shell. */
 753                 foreach (term, terminals)
 754                         if (term->fdin > 0)
 755                                 close(term->fdin);
 756
 757                 close(p[0]);
 758                 fn(ptr, p[1]);
 759                 write(p[1], "x", 1);
 760                 close(p[1]);
 761                 /* We use _exit() here instead of exit(), see
 762                  * http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC6 for
 763                  * reasons. Fixed by Sven Neumann <sven@convergence.de>. */
 764                 _exit(0);
 765         }
 766         if (pid == -1) {
 767                 close(p[0]);
 768                 close(p[1]);
 769                 return -1;
 770         }
 771
 772         close(p[1]);
 773         return p[0];
 774 }
 775
 776 #endif
 777
 778
 779 #ifndef OS2_MOUSE
 780 void
 781 want_draw(void)
 782 {
 783 }
 784
 785 void
 786 done_draw(void)
 787 {
 788 }
 789 #endif
 790
 791
 792 #if !defined(CONFIG_OS_WIN32)
 793 int
 794 get_output_handle(void)
 795 {
 796         return 1;
 797 }
 798
 799 int
 800 get_ctl_handle(void)
 801 {
 802         static int fd = -1;
 803
 804         if (isatty(0)) return 0;
 805         if (fd < 0) fd = open("/dev/tty", O_RDONLY);
 806         return fd;
 807 }
 808 #endif
 809
 810
 811 #if !defined(CONFIG_OS_BEOS) && !(defined(HAVE_BEGINTHREAD) && defined(HAVE_READ_KBD)) \
 812         && !defined(CONFIG_OS_WIN32)
 813
 814 int
 815 get_input_handle(void)
 816 {
 817         return get_ctl_handle();
 818 }
 819
 820 #endif
 821
 822 #ifndef CONFIG_OS_WIN32
 823
 824 void
 825 init_osdep(void)
 826 {
 827 #ifdef HAVE_LOCALE_H
 828         setlocale(LC_ALL, "");
 829 #endif
 830 }
 831
 832 #endif
 833
 834 #if defined(CONFIG_OS_UNIX) || defined(CONFIG_OS_OS2) || defined(CONFIG_OS_RISCOS)
 835
 836 void
 837 terminate_osdep(void)
 838 {
 839 }
 840
 841 #endif
 842
 843 #ifndef CONFIG_OS_BEOS
 844
 845 void
 846 block_stdin(void)
 847 {
 848 }
 849
 850 void
 851 unblock_stdin(void)
 852 {
 853 }
 854
 855 #endif
 856
 857
 858 void
 859 elinks_cfmakeraw(struct termios *t)
 860 {
 861         /* This elinks_cfmakeraw() intentionally leaves the following
 862          * settings unchanged, even though the standard cfmakeraw()
 863          * would change some of them:
 864          *
 865          * - c_cflag & CSIZE: number of bits per character.
 866          *   Bug 54 asked ELinks not to change this.
 867          * - c_cflag & (PARENB | PARODD): parity bit in characters.
 868          *   Bug 54 asked ELinks not to change this.
 869          * - c_iflag & (IXON | IXOFF | IXANY): XON/XOFF flow control.
 870          *
 871          * The reasoning is, if the user has set up unusual values for
 872          * those settings before starting ELinks, then the terminal
 873          * probably expects those values and ELinks should not mess
 874          * with them.  */
 875         t->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL);
 876         t->c_oflag &= ~OPOST;
 877         t->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
 878         t->c_cc[VMIN] = 1;
 879         t->c_cc[VTIME] = 0;
 880 }
 881
 882 #if !defined(CONFIG_MOUSE) || (!defined(CONFIG_GPM) && !defined(CONFIG_SYSMOUSE) && !defined(OS2_MOUSE))
 883
 884 void *
 885 handle_mouse(int cons, void (*fn)(void *, unsigned char *, int),
 886              void *data)
 887 {
 888         return NULL;
 889 }
 890
 891 void
 892 unhandle_mouse(void *data)
 893 {
 894 }
 895
 896 void
 897 suspend_mouse(void *data)
 898 {
 899 }
 900
 901 void
 902 resume_mouse(void *data)
 903 {
 904 }
 905
 906 #endif
 907
 908 #ifndef CONFIG_OS_WIN32
 909 /* Create a bitmask consisting from system-independent envirnoment modifiers.
 910  * This is then complemented by system-specific modifiers in an appropriate
 911  * get_system_env() routine. */
 912 static int
 913 get_common_env(void)
 914 {
 915         int env = 0;
 916
 917         if (is_xterm()) env |= ENV_XWIN;
 918         if (is_twterm()) env |= ENV_TWIN;
 919         if (is_gnuscreen()) env |= ENV_SCREEN;
 920
 921         /* ENV_CONSOLE is always set now and indicates that we are working w/ a
 922          * displaying-capable character-adressed terminal. Sounds purely
 923          * theoretically now, but it already makes some things easier and it
 924          * could give us interesting opportunities later (after graphical
 925          * frontends will be introduced, when working in some mysterious daemon
 926          * mode or who knows what ;). --pasky */
 927         env |= ENV_CONSOLE;
 928
 929         return env;
 930 }
 931 #endif
 932
 933 #if defined(CONFIG_OS_UNIX) || defined(CONFIG_OS_RISCOS)
 934 int
 935 get_system_env(void)
 936 {
 937         return get_common_env();
 938 }
 939 #endif
 940
 941
 942 int
 943 can_resize_window(int environment)
 944 {
 945         return !!(environment & (ENV_OS2VIO | ENV_XWIN));
 946 }
 947
 948 #ifndef CONFIG_OS_OS2
 949 int
 950 can_open_os_shell(int environment)
 951 {
 952         return 1;
 953 }
 954
 955 void
 956 set_highpri(void)
 957 {
 958 }
 959 #endif
 960
 961
 962 unsigned char *
 963 get_system_str(int xwin)
 964 {
 965         return xwin ? SYSTEM_STR "-xwin" : SYSTEM_STR;
 966 }