mono/metadata/console-unix.c

   1 /*
   2  * console-io.c: ConsoleDriver internal calls for Unix systems.
   3  *
   4  * Author:
   5  *      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   6  *
   7  * Copyright (C) 2005-2009 Novell, Inc. (http://www.novell.com)
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <fcntl.h>
  15 #include <errno.h>
  16 #include <signal.h>
  17 #ifdef HAVE_SYS_TIME_H
  18 #    include <sys/time.h>
  19 #endif
  20 #include <sys/types.h>
  21 #ifdef HAVE_UNISTD_H
  22 #    include <unistd.h>
  23 #endif
  24 #include <mono/metadata/appdomain.h>
  25 #include <mono/metadata/object-internals.h>
  26 #include <mono/metadata/class-internals.h>
  27 #include <mono/metadata/domain-internals.h>
  28 #include <mono/metadata/metadata.h>
  29 #include <mono/metadata/threadpool.h>
  30
  31 /* On solaris, curses.h must come before both termios.h and term.h */
  32 #ifdef HAVE_CURSES_H
  33 #    include <curses.h>
  34 #endif
  35 #ifdef HAVE_TERMIOS_H
  36 #    include <termios.h>
  37 #endif
  38 #ifdef HAVE_TERM_H
  39 #    include <term.h>
  40 #endif
  41
  42 /* Needed for FIONREAD under solaris */
  43 #ifdef HAVE_SYS_FILIO_H
  44 #    include <sys/filio.h>
  45 #endif
  46 #ifndef TIOCGWINSZ
  47 #    ifdef HAVE_SYS_IOCTL_H
  48 #        include <sys/ioctl.h>
  49 #    endif
  50 #endif
  51
  52 #include <mono/metadata/console-io.h>
  53 #include <mono/metadata/exception.h>
  54
  55 static gboolean setup_finished;
  56 static gboolean atexit_called;
  57
  58 /* The string used to return the terminal to its previous state */
  59 static gchar *teardown_str;
  60
  61 /* The string used to set the terminal into keypad xmit mode after SIGCONT is received */
  62 static gchar *keypad_xmit_str;
  63
  64 #ifdef HAVE_TERMIOS_H
  65 /* This is the last state used by Mono, used after a CONT signal is received */
  66 static struct termios mono_attr;
  67 #endif
  68
  69 void
  70 mono_console_init (void)
  71 {
  72         int fd;
  73
  74         /* Make sure the standard file descriptors are opened */
  75         fd = open ("/dev/null", O_RDWR);
  76         while (fd >= 0 && fd < 3) {
  77                 fd = open ("/dev/null", O_RDWR);
  78         }
  79         close (fd);
  80 }
  81
  82 static struct termios initial_attr;
  83
  84 MonoBoolean
  85 ves_icall_System_ConsoleDriver_Isatty (HANDLE handle)
  86 {
  87         MONO_ARCH_SAVE_REGS;
  88
  89         return isatty (GPOINTER_TO_INT (handle));
  90 }
  91
  92 static MonoBoolean
  93 set_property (gint property, gboolean value)
  94 {
  95         struct termios attr;
  96         gboolean callset = FALSE;
  97         gboolean check;
  98
  99         MONO_ARCH_SAVE_REGS;
 100
 101         if (tcgetattr (STDIN_FILENO, &attr) == -1)
 102                 return FALSE;
 103
 104         check = (attr.c_lflag & property) != 0;
 105         if ((value || check) && !(value && check)) {
 106                 callset = TRUE;
 107                 if (value)
 108                         attr.c_lflag |= property;
 109                 else
 110                         attr.c_lflag &= ~property;
 111         }
 112
 113         if (!callset)
 114                 return TRUE;
 115
 116         if (tcsetattr (STDIN_FILENO, TCSANOW, &attr) == -1)
 117                 return FALSE;
 118
 119         mono_attr = attr;
 120         return TRUE;
 121 }
 122
 123 MonoBoolean
 124 ves_icall_System_ConsoleDriver_SetEcho (MonoBoolean want_echo)
 125 {
 126
 127         return set_property (ECHO, want_echo);
 128 }
 129
 130 MonoBoolean
 131 ves_icall_System_ConsoleDriver_SetBreak (MonoBoolean want_break)
 132 {
 133         return set_property (IGNBRK, !want_break);
 134 }
 135
 136 gint32
 137 ves_icall_System_ConsoleDriver_InternalKeyAvailable (gint32 timeout)
 138 {
 139         fd_set rfds;
 140         struct timeval tv;
 141         struct timeval *tvptr;
 142         div_t divvy;
 143         int ret, nbytes;
 144
 145         MONO_ARCH_SAVE_REGS;
 146
 147         do {
 148                 FD_ZERO (&rfds);
 149                 FD_SET (STDIN_FILENO, &rfds);
 150                 if (timeout >= 0) {
 151                         divvy = div (timeout, 1000);
 152                         tv.tv_sec = divvy.quot;
 153                         tv.tv_usec = divvy.rem;
 154                         tvptr = &tv;
 155                 } else {
 156                         tvptr = NULL;
 157                 }
 158                 ret = select (STDIN_FILENO + 1, &rfds, NULL, NULL, tvptr);
 159         } while (ret == -1 && errno == EINTR);
 160
 161         if (ret > 0) {
 162                 nbytes = 0;
 163                 ret = ioctl (STDIN_FILENO, FIONREAD, &nbytes);
 164                 if (ret >= 0)
 165                         ret = nbytes;
 166         }
 167
 168         return (ret > 0) ? ret : 0;
 169 }
 170
 171 static gint32 cols_and_lines;
 172
 173 #ifdef TIOCGWINSZ
 174 static int
 175 terminal_get_dimensions (void)
 176 {
 177         struct winsize ws;
 178
 179         if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) == 0)
 180                 return (ws.ws_col << 16) | ws.ws_row;
 181
 182         return -1;
 183 }
 184 #else
 185 static int
 186 terminal_get_dimensions (void)
 187 {
 188         return -1;
 189 }
 190 #endif
 191
 192 static void
 193 tty_teardown (void)
 194 {
 195         MONO_ARCH_SAVE_REGS;
 196
 197         if (!setup_finished)
 198                 return;
 199
 200         if (teardown_str != NULL) {
 201                 write (STDOUT_FILENO, teardown_str, strlen (teardown_str));
 202                 g_free (teardown_str);
 203                 teardown_str = NULL;
 204         }
 205
 206         tcflush (STDIN_FILENO, TCIFLUSH);
 207         tcsetattr (STDIN_FILENO, TCSANOW, &initial_attr);
 208         set_property (ECHO, TRUE);
 209         setup_finished = FALSE;
 210 }
 211
 212 static void
 213 do_console_cancel_event (void)
 214 {
 215         static MonoClassField *cancel_handler_field;
 216         MonoDomain *domain = mono_domain_get ();
 217         MonoClass *klass;
 218         MonoDelegate *load_value;
 219         MonoMethod *method;
 220         MonoMethodMessage *msg;
 221         MonoMethod *im;
 222
 223         if (!domain->domain)
 224                 return;
 225
 226         klass = mono_class_from_name (mono_defaults.corlib, "System", "Console");
 227         if (klass == NULL)
 228                 return;
 229
 230         if (cancel_handler_field == NULL) {
 231                 cancel_handler_field = mono_class_get_field_from_name (klass, "cancel_handler");
 232                 g_assert (cancel_handler_field);
 233         }
 234
 235         mono_field_static_get_value (mono_class_vtable (domain, klass), cancel_handler_field, &load_value);
 236         if (load_value == NULL)
 237                 return;
 238
 239         klass = load_value->object.vtable->klass;
 240         method = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
 241         g_assert (method != NULL);
 242         im = mono_get_delegate_invoke (method->klass);
 243         msg = mono_method_call_message_new (method, NULL, im, NULL, NULL);
 244         mono_thread_pool_add ((MonoObject *) load_value, msg, NULL, NULL);
 245 }
 246
 247 static gboolean in_sigint;
 248 static void
 249 sigint_handler (int signo)
 250 {
 251         MONO_ARCH_SAVE_REGS;
 252
 253         if (in_sigint)
 254                 return;
 255
 256         in_sigint = TRUE;
 257         do_console_cancel_event ();
 258         in_sigint = FALSE;
 259 }
 260
 261 static struct sigaction save_sigcont, save_sigint, save_sigwinch;
 262
 263 static void
 264 sigcont_handler (int signo, void *the_siginfo, void *data)
 265 {
 266         // Ignore error, there is not much we can do in the sigcont handler.
 267         tcsetattr (STDIN_FILENO, TCSANOW, &mono_attr);
 268
 269         if (keypad_xmit_str != NULL)
 270                 write (STDOUT_FILENO, keypad_xmit_str, strlen (keypad_xmit_str));
 271
 272         // Call previous handler
 273         if (save_sigcont.sa_sigaction != NULL &&
 274             save_sigcont.sa_sigaction != (void *)SIG_DFL &&
 275             save_sigcont.sa_sigaction != (void *)SIG_IGN)
 276                 (*save_sigcont.sa_sigaction) (signo, the_siginfo, data);
 277 }
 278
 279 static void
 280 sigwinch_handler (int signo, void *the_siginfo, void *data)
 281 {
 282         int dims = terminal_get_dimensions ();
 283         if (dims != -1)
 284                 cols_and_lines = dims;
 285
 286         // Call previous handler
 287         if (save_sigwinch.sa_sigaction != NULL &&
 288             save_sigwinch.sa_sigaction != (void *)SIG_DFL &&
 289             save_sigwinch.sa_sigaction != (void *)SIG_IGN)
 290                 (*save_sigwinch.sa_sigaction) (signo, the_siginfo, data);
 291 }
 292
 293 void
 294 console_set_signal_handlers ()
 295 {
 296         struct sigaction sigcont, sigint, sigwinch;
 297
 298         memset (&sigcont, 0, sizeof (struct sigaction));
 299         memset (&sigint, 0, sizeof (struct sigaction));
 300         memset (&sigwinch, 0, sizeof (struct sigaction));
 301
 302         // Continuing
 303         sigcont.sa_handler = (void *) sigcont_handler;
 304         sigcont.sa_flags = 0;
 305         sigemptyset (&sigcont.sa_mask);
 306         sigaction (SIGCONT, &sigcont, &save_sigcont);
 307
 308         // Interrupt handler
 309         sigint.sa_handler = sigint_handler;
 310         sigint.sa_flags = 0;
 311         sigemptyset (&sigint.sa_mask);
 312         sigaction (SIGINT, &sigint, &save_sigint);
 313
 314         // Window size changed
 315         sigwinch.sa_handler = (void *) sigwinch_handler;
 316         sigwinch.sa_flags = 0;
 317         sigemptyset (&sigwinch.sa_mask);
 318         sigaction (SIGWINCH, &sigwinch, &save_sigwinch);
 319 }
 320
 321 //
 322 // Currently unused, should we ever call the restore handler?
 323 // Perhaps before calling into Process.Start?
 324 //
 325 void
 326 console_restore_signal_handlers ()
 327 {
 328         sigaction (SIGCONT, &save_sigcont, NULL);
 329         sigaction (SIGINT, &save_sigint, NULL);
 330         sigaction (SIGWINCH, &save_sigwinch, NULL);
 331 }
 332
 333 static void
 334 set_control_chars (MonoArray *control_chars, const guchar *cc)
 335 {
 336         /* The index into the array comes from corlib/System/ControlCharacters.cs */
 337 #ifdef VINTR
 338         mono_array_set (control_chars, gchar, 0, cc [VINTR]);
 339 #endif
 340 #ifdef VQUIT
 341         mono_array_set (control_chars, gchar, 1, cc [VQUIT]);
 342 #endif
 343 #ifdef VERASE
 344         mono_array_set (control_chars, gchar, 2, cc [VERASE]);
 345 #endif
 346 #ifdef VKILL
 347         mono_array_set (control_chars, gchar, 3, cc [VKILL]);
 348 #endif
 349 #ifdef VEOF
 350         mono_array_set (control_chars, gchar, 4, cc [VEOF]);
 351 #endif
 352 #ifdef VTIME
 353         mono_array_set (control_chars, gchar, 5, cc [VTIME]);
 354 #endif
 355 #ifdef VMIN
 356         mono_array_set (control_chars, gchar, 6, cc [VMIN]);
 357 #endif
 358 #ifdef VSWTC
 359         mono_array_set (control_chars, gchar, 7, cc [VSWTC]);
 360 #endif
 361 #ifdef VSTART
 362         mono_array_set (control_chars, gchar, 8, cc [VSTART]);
 363 #endif
 364 #ifdef VSTOP
 365         mono_array_set (control_chars, gchar, 9, cc [VSTOP]);
 366 #endif
 367 #ifdef VSUSP
 368         mono_array_set (control_chars, gchar, 10, cc [VSUSP]);
 369 #endif
 370 #ifdef VEOL
 371         mono_array_set (control_chars, gchar, 11, cc [VEOL]);
 372 #endif
 373 #ifdef VREPRINT
 374         mono_array_set (control_chars, gchar, 12, cc [VREPRINT]);
 375 #endif
 376 #ifdef VDISCARD
 377         mono_array_set (control_chars, gchar, 13, cc [VDISCARD]);
 378 #endif
 379 #ifdef VWERASE
 380         mono_array_set (control_chars, gchar, 14, cc [VWERASE]);
 381 #endif
 382 #ifdef VLNEXT
 383         mono_array_set (control_chars, gchar, 15, cc [VLNEXT]);
 384 #endif
 385 #ifdef VEOL2
 386         mono_array_set (control_chars, gchar, 16, cc [VEOL2]);
 387 #endif
 388 }
 389
 390 MonoBoolean
 391 ves_icall_System_ConsoleDriver_TtySetup (MonoString *keypad, MonoString *teardown, MonoArray **control_chars, int **size)
 392 {
 393         int dims;
 394
 395         MONO_ARCH_SAVE_REGS;
 396
 397         dims = terminal_get_dimensions ();
 398         if (dims == -1){
 399                 int cols = 0, rows = 0;
 400
 401                 char *str = getenv ("COLUMNS");
 402                 if (str != NULL)
 403                         cols = atoi (str);
 404                 str = getenv ("LINES");
 405                 if (str != NULL)
 406                         rows = atoi (str);
 407
 408                 if (cols != 0 && rows != 0)
 409                         cols_and_lines = (cols << 16) | rows;
 410                 else
 411                         cols_and_lines = -1;
 412         } else {
 413                 cols_and_lines = dims;
 414         }
 415
 416         *size = &cols_and_lines;
 417
 418         /* 17 is the number of entries set in set_control_chars() above.
 419          * NCCS is the total size, but, by now, we only care about those 17 values*/
 420         *control_chars = mono_array_new (mono_domain_get (), mono_defaults.byte_class, 17);
 421         if (tcgetattr (STDIN_FILENO, &initial_attr) == -1)
 422                 return FALSE;
 423
 424         mono_attr = initial_attr;
 425         mono_attr.c_lflag &= ~(ICANON);
 426         mono_attr.c_iflag &= ~(IXON|IXOFF);
 427         mono_attr.c_cc [VMIN] = 1;
 428         mono_attr.c_cc [VTIME] = 0;
 429         if (tcsetattr (STDIN_FILENO, TCSANOW, &mono_attr) == -1)
 430                 return FALSE;
 431
 432         set_control_chars (*control_chars, mono_attr.c_cc);
 433         /* If initialized from another appdomain... */
 434         if (setup_finished)
 435                 return TRUE;
 436
 437         keypad_xmit_str = keypad != NULL ? mono_string_to_utf8 (keypad) : NULL;
 438
 439         console_set_signal_handlers ();
 440         setup_finished = TRUE;
 441         if (!atexit_called) {
 442                 if (teardown != NULL)
 443                         teardown_str = mono_string_to_utf8 (teardown);
 444
 445                 atexit (tty_teardown);
 446         }
 447
 448         return TRUE;
 449 }