gcc/ada/terminals.c

   1 /****************************************************************************
   2  *                                                                          *
   3  *                         GNAT RUN-TIME COMPONENTS                         *
   4  *                                                                          *
   5  *                            T E R M I N A L S                             *
   6  *                                                                          *
   7  *                          C Implementation File                           *
   8  *                                                                          *
   9  *                     Copyright (C) 2008-2018, AdaCore                     *
  10  *                                                                          *
  11  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  12  * terms of the  GNU General Public License as published  by the Free Soft- *
  13  * ware  Foundation;  either version 3,  or (at your option) any later ver- *
  14  * sion.  GNAT is distributed in the hope that it will be useful, but WITH- *
  15  * OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY *
  16  * or FITNESS FOR A PARTICULAR PURPOSE.                                     *
  17  *                                                                          *
  18  * As a special exception under Section 7 of GPL version 3, you are granted *
  19  * additional permissions described in the GCC Runtime Library Exception,   *
  20  * version 3.1, as published by the Free Software Foundation.               *
  21  *                                                                          *
  22  * You should have received a copy of the GNU General Public License and    *
  23  * a copy of the GCC Runtime Library Exception along with this program;     *
  24  * see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    *
  25  * <http://www.gnu.org/licenses/>.                                          *
  26  *                                                                          *
  27  * GNAT was originally developed  by the GNAT team at  New York University. *
  28  * Extensive contributions were provided by Ada Core Technologies Inc.      *
  29  *                                                                          *
  30  ****************************************************************************/
  31
  32 /* First all usupported platforms. Add stubs for exported routines. */
  33
  34 #if defined (VMS) || defined (__vxworks) || defined (__Lynx__) \
  35   || defined (__ANDROID__) || defined (__PikeOS__) || defined(__DJGPP__)
  36
  37 #define ATTRIBUTE_UNUSED __attribute__((unused))
  38
  39 void *
  40 __gnat_new_tty (void)
  41 {
  42   return (void*)0;
  43 }
  44
  45 char *
  46 __gnat_tty_name (void* t ATTRIBUTE_UNUSED)
  47 {
  48   return (char*)0;
  49 }
  50
  51 int
  52 __gnat_interrupt_pid (int pid ATTRIBUTE_UNUSED)
  53 {
  54   return -1;
  55 }
  56
  57 int
  58 __gnat_interrupt_process (void* desc ATTRIBUTE_UNUSED)
  59 {
  60   return -1;
  61 }
  62
  63 int
  64 __gnat_setup_communication (void** desc ATTRIBUTE_UNUSED)
  65 {
  66   return -1;
  67 }
  68
  69 void
  70 __gnat_setup_parent_communication (void *d ATTRIBUTE_UNUSED,
  71                                    int *i ATTRIBUTE_UNUSED,
  72                                    int *o ATTRIBUTE_UNUSED,
  73                                    int *e ATTRIBUTE_UNUSED,
  74                                    int *p ATTRIBUTE_UNUSED)
  75 {
  76 }
  77
  78 int
  79 __gnat_setup_child_communication (void *d ATTRIBUTE_UNUSED,
  80                                   char **n ATTRIBUTE_UNUSED,
  81                                   int u ATTRIBUTE_UNUSED)
  82 {
  83   return -1;
  84 }
  85
  86 int
  87 __gnat_terminate_process (void *desc ATTRIBUTE_UNUSED)
  88 {
  89   return -1;
  90 }
  91
  92 int
  93 __gnat_terminate_pid (int pid ATTRIBUTE_UNUSED)
  94 {
  95   return -1;
  96 }
  97
  98 int
  99 __gnat_tty_fd (void* t ATTRIBUTE_UNUSED)
 100 {
 101   return -1;
 102 }
 103
 104 int
 105 __gnat_tty_supported (void)
 106 {
 107   return 0;
 108 }
 109
 110 int
 111 __gnat_tty_waitpid (void *desc ATTRIBUTE_UNUSED)
 112 {
 113   return 1;
 114 }
 115
 116 void
 117 __gnat_close_tty (void* t ATTRIBUTE_UNUSED)
 118 {
 119 }
 120
 121 void
 122 __gnat_free_process (void** process ATTRIBUTE_UNUSED)
 123 {
 124 }
 125
 126 void
 127 __gnat_reset_tty (void* t ATTRIBUTE_UNUSED)
 128 {
 129 }
 130
 131 void
 132 __gnat_send_header (void* d ATTRIBUTE_UNUSED,
 133                     char h[5] ATTRIBUTE_UNUSED,
 134                     int s ATTRIBUTE_UNUSED,
 135                     int *r ATTRIBUTE_UNUSED)
 136 {
 137 }
 138
 139 void
 140 __gnat_setup_winsize (void *desc ATTRIBUTE_UNUSED,
 141                       int rows ATTRIBUTE_UNUSED,
 142                       int columns ATTRIBUTE_UNUSED)
 143 {
 144 }
 145
 146 /* For Windows platforms. */
 147
 148 #elif defined(_WIN32)
 149
 150 #include <errno.h>
 151 #include <stdio.h>
 152 #include <stdlib.h>
 153
 154 #include <windows.h>
 155
 156 #define MAXPATHLEN 1024
 157
 158 #define NILP(x) ((x) == 0)
 159 #define Qnil 0
 160 #define report_file_error(x, y) fprintf (stderr, "Error: %s\n", x);
 161 #define INTEGERP(x) 1
 162 #define XINT(x) x
 163
 164 struct TTY_Process {
 165   int pid;           /* Number of this process */
 166   PROCESS_INFORMATION procinfo;
 167   HANDLE w_infd, w_outfd;
 168   HANDLE w_forkin, w_forkout;
 169   BOOL usePipe;
 170 };
 171
 172 /* Control whether create_child cause the process to inherit GPS'
 173    error mode setting.  The default is 1, to minimize the possibility of
 174    subprocesses blocking when accessing unmounted drives.  */
 175 static int Vw32_start_process_inherit_error_mode = 1;
 176
 177 /* Control whether spawnve quotes arguments as necessary to ensure
 178    correct parsing by child process.  Because not all uses of spawnve
 179    are careful about constructing argv arrays, we make this behavior
 180    conditional (off by default, since a similar operation is already done
 181    in g-expect.adb by calling Normalize_Argument). */
 182 static int Vw32_quote_process_args = 0;
 183
 184 static DWORD AbsoluteSeek(HANDLE, DWORD);
 185 static VOID  ReadBytes(HANDLE, LPVOID, DWORD);
 186
 187 #define XFER_BUFFER_SIZE 2048
 188
 189 /* This tell if the executable we're about to launch uses a GUI interface. */
 190 /* if we can't determine it, we will return true */
 191 static int
 192 is_gui_app (char *exe)
 193 {
 194   HANDLE hImage;
 195
 196   DWORD  bytes;
 197   DWORD  iSection;
 198   DWORD  SectionOffset;
 199   DWORD  CoffHeaderOffset;
 200   DWORD  MoreDosHeader[16];
 201   CHAR   *file;
 202   size_t nlen;
 203
 204   ULONG  ntSignature;
 205
 206   IMAGE_DOS_HEADER      image_dos_header;
 207   IMAGE_FILE_HEADER     image_file_header;
 208   IMAGE_OPTIONAL_HEADER image_optional_header;
 209   IMAGE_SECTION_HEADER  image_section_header;
 210
 211   /*
 212    *  Open the reference file.
 213   */
 214   nlen = strlen (exe);
 215   file = exe;
 216   if (nlen > 2) {
 217     if (exe[0] == '"') {
 218       /* remove quotes */
 219       nlen -= 2;
 220       file = malloc ((nlen + 1) * sizeof (char));
 221       memcpy (file, &exe[1], nlen);
 222       file [nlen] = '\0';
 223     }
 224   }
 225   hImage = CreateFile(file,
 226                       GENERIC_READ,
 227                       FILE_SHARE_READ,
 228                       NULL,
 229                       OPEN_EXISTING,
 230                       FILE_ATTRIBUTE_NORMAL,
 231                       NULL);
 232
 233   if (file != exe) {
 234     free (file);
 235   }
 236
 237   if (INVALID_HANDLE_VALUE == hImage)
 238     {
 239       report_file_error ("Could not open exe: ", Qnil);
 240       report_file_error (exe, Qnil);
 241       report_file_error ("\n", Qnil);
 242       CloseHandle (hImage);
 243       return -1;
 244     }
 245
 246   /*
 247    *  Read the MS-DOS image header.
 248    */
 249   ReadBytes(hImage, &image_dos_header, sizeof(IMAGE_DOS_HEADER));
 250
 251   if (IMAGE_DOS_SIGNATURE != image_dos_header.e_magic)
 252     {
 253       report_file_error("Sorry, I do not understand this file.\n", Qnil);
 254       CloseHandle (hImage);
 255       return -1;
 256     }
 257
 258   /*
 259    *  Read more MS-DOS header.       */
 260   ReadBytes(hImage, MoreDosHeader, sizeof(MoreDosHeader));
 261    /*
 262    *  Get actual COFF header.
 263    */
 264   CoffHeaderOffset = AbsoluteSeek(hImage, image_dos_header.e_lfanew) +
 265                      sizeof(ULONG);
 266   if (CoffHeaderOffset < 0) {
 267     CloseHandle (hImage);
 268     return -1;
 269   }
 270
 271   ReadBytes (hImage, &ntSignature, sizeof(ULONG));
 272
 273   if (IMAGE_NT_SIGNATURE != ntSignature)
 274     {
 275       report_file_error ("Missing NT signature. Unknown file type.\n", Qnil);
 276       CloseHandle (hImage);
 277       return -1;
 278     }
 279
 280   SectionOffset = CoffHeaderOffset + IMAGE_SIZEOF_FILE_HEADER +
 281     IMAGE_SIZEOF_NT_OPTIONAL_HEADER;
 282
 283   ReadBytes(hImage, &image_file_header, IMAGE_SIZEOF_FILE_HEADER);
 284
 285   /*
 286    *  Read optional header.
 287    */
 288   ReadBytes(hImage,
 289             &image_optional_header,
 290             IMAGE_SIZEOF_NT_OPTIONAL_HEADER);
 291
 292   CloseHandle (hImage);
 293
 294   switch (image_optional_header.Subsystem)
 295     {
 296     case IMAGE_SUBSYSTEM_UNKNOWN:
 297         return 1;
 298
 299     case IMAGE_SUBSYSTEM_NATIVE:
 300         return 1;
 301
 302     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
 303         return 1;
 304
 305     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
 306         return 0;
 307
 308     case IMAGE_SUBSYSTEM_OS2_CUI:
 309         return 0;
 310
 311     case IMAGE_SUBSYSTEM_POSIX_CUI:
 312         return 0;
 313
 314     default:
 315         /* Unknown, return GUI app to be preservative: if yes, it will be
 316            correctly launched, if no, it will be launched, and a console will
 317            be also displayed, which is not a big deal */
 318         return 1;
 319     }
 320
 321 }
 322
 323 static DWORD
 324 AbsoluteSeek (HANDLE hFile, DWORD offset)
 325 {
 326     DWORD newOffset;
 327
 328     newOffset = SetFilePointer (hFile, offset, NULL, FILE_BEGIN);
 329
 330     if (newOffset == 0xFFFFFFFF)
 331       return -1;
 332     else
 333       return newOffset;
 334 }
 335
 336 static VOID
 337 ReadBytes (HANDLE hFile, LPVOID buffer, DWORD size)
 338 {
 339   DWORD bytes;
 340
 341   if (!ReadFile(hFile, buffer, size, &bytes, NULL))
 342     {
 343       size = 0;
 344       return;
 345     }
 346   else if (size != bytes)
 347     {
 348       return;
 349     }
 350 }
 351
 352 static int
 353 nt_spawnve (char *exe, char **argv, char *env, struct TTY_Process *process)
 354 {
 355   STARTUPINFO start;
 356   SECURITY_ATTRIBUTES sec_attrs;
 357   SECURITY_DESCRIPTOR sec_desc;
 358   DWORD flags;
 359   char dir[ MAXPATHLEN ];
 360   int pid;
 361   int is_gui, use_cmd;
 362   char *cmdline, *parg, **targ;
 363   int do_quoting = 0;
 364   char escape_char;
 365   int arglen;
 366
 367   /* we have to do some conjuring here to put argv and envp into the
 368      form CreateProcess wants...  argv needs to be a space separated/null
 369      terminated list of parameters, and envp is a null
 370      separated/double-null terminated list of parameters.
 371
 372      Additionally, zero-length args and args containing whitespace or
 373      quote chars need to be wrapped in double quotes - for this to work,
 374      embedded quotes need to be escaped as well.  The aim is to ensure
 375      the child process reconstructs the argv array we start with
 376      exactly, so we treat quotes at the beginning and end of arguments
 377      as embedded quotes.
 378
 379      Note that using backslash to escape embedded quotes requires
 380      additional special handling if an embedded quote is already
 381      preceded by backslash, or if an arg requiring quoting ends with
 382      backslash.  In such cases, the run of escape characters needs to be
 383      doubled.  For consistency, we apply this special handling as long
 384      as the escape character is not quote.
 385
 386      Since we have no idea how large argv and envp are likely to be we
 387      figure out list lengths on the fly and allocate them.  */
 388
 389   if (!NILP (Vw32_quote_process_args))
 390     {
 391       do_quoting = 1;
 392       /* Override escape char by binding w32-quote-process-args to
 393          desired character, or use t for auto-selection.  */
 394       if (INTEGERP (Vw32_quote_process_args))
 395         escape_char = XINT (Vw32_quote_process_args);
 396       else
 397         escape_char = '\\';
 398     }
 399
 400   /* do argv...  */
 401   arglen = 0;
 402   targ = argv;
 403   while (*targ)
 404     {
 405       char *p = *targ;
 406       int need_quotes = 0;
 407       int escape_char_run = 0;
 408
 409       if (*p == 0)
 410         need_quotes = 1;
 411       for ( ; *p; p++)
 412         {
 413           if (*p == '"')
 414             {
 415               /* allow for embedded quotes to be escaped */
 416               arglen++;
 417               need_quotes = 1;
 418               /* handle the case where the embedded quote is already escaped */
 419               if (escape_char_run > 0)
 420                 {
 421                   /* To preserve the arg exactly, we need to double the
 422                      preceding escape characters (plus adding one to
 423                      escape the quote character itself).  */
 424                   arglen += escape_char_run;
 425                 }
 426             }
 427           else if (*p == ' ' || *p == '\t')
 428             {
 429               need_quotes = 1;
 430             }
 431
 432           if (*p == escape_char && escape_char != '"')
 433             escape_char_run++;
 434           else
 435             escape_char_run = 0;
 436         }
 437       if (need_quotes)
 438         {
 439           arglen += 2;
 440           /* handle the case where the arg ends with an escape char - we
 441              must not let the enclosing quote be escaped.  */
 442           if (escape_char_run > 0)
 443             arglen += escape_char_run;
 444         }
 445       arglen += strlen (*targ) + 1;
 446       targ++;
 447     }
 448
 449   is_gui = is_gui_app (argv[0]);
 450   use_cmd = FALSE;
 451
 452   if (is_gui == -1) {
 453     /* could not determine application type. Try launching with "cmd /c" */
 454     is_gui = FALSE;
 455     arglen += 7;
 456     use_cmd = TRUE;
 457   }
 458
 459   cmdline = (char*)malloc (arglen + 1);
 460   targ = argv;
 461   parg = cmdline;
 462
 463   if (use_cmd == TRUE) {
 464     strcpy (parg, "cmd /c ");
 465     parg += 7;
 466   }
 467
 468   while (*targ)
 469     {
 470       char * p = *targ;
 471       int need_quotes = 0;
 472
 473       if (*p == 0)
 474         need_quotes = 1;
 475
 476       if (do_quoting)
 477         {
 478           for ( ; *p; p++)
 479             if (*p == ' ' || *p == '\t' || *p == '"')
 480               need_quotes = 1;
 481         }
 482       if (need_quotes)
 483         {
 484           int escape_char_run = 0;
 485           char * first;
 486           char * last;
 487
 488           p = *targ;
 489           first = p;
 490           last = p + strlen (p) - 1;
 491           *parg++ = '"';
 492           for ( ; *p; p++)
 493             {
 494               if (*p == '"')
 495                 {
 496                   /* double preceding escape chars if any */
 497                   while (escape_char_run > 0)
 498                     {
 499                       *parg++ = escape_char;
 500                       escape_char_run--;
 501                     }
 502                   /* escape all quote chars, even at beginning or end */
 503                   *parg++ = escape_char;
 504                 }
 505               *parg++ = *p;
 506
 507               if (*p == escape_char && escape_char != '"')
 508                 escape_char_run++;
 509               else
 510                 escape_char_run = 0;
 511             }
 512           /* double escape chars before enclosing quote */
 513           while (escape_char_run > 0)
 514             {
 515               *parg++ = escape_char;
 516               escape_char_run--;
 517             }
 518           *parg++ = '"';
 519         }
 520       else
 521         {
 522           strcpy (parg, *targ);
 523           parg += strlen (*targ);
 524         }
 525       *parg++ = ' ';
 526       targ++;
 527     }
 528   *--parg = '\0';
 529
 530   memset (&start, 0, sizeof (start));
 531   start.cb = sizeof (start);
 532
 533   if (process->usePipe == TRUE) {
 534     start.dwFlags = STARTF_USESTDHANDLES;
 535     start.hStdInput = process->w_forkin;
 536     start.hStdOutput = process->w_forkout;
 537     /* child's stderr is always redirected to outfd */
 538     start.hStdError = process->w_forkout;
 539   } else {
 540     start.dwFlags = STARTF_USESTDHANDLES;
 541     /* We only need to redirect stderr/stdout here. Stdin will be forced to
 542        the spawned process console by explaunch */
 543     start.hStdInput = NULL;
 544     start.hStdOutput = process->w_forkout;
 545     start.hStdError = process->w_forkout;
 546   }
 547
 548   /* Explicitly specify no security */
 549   if (!InitializeSecurityDescriptor (&sec_desc, SECURITY_DESCRIPTOR_REVISION))
 550     goto EH_Fail;
 551   if (!SetSecurityDescriptorDacl (&sec_desc, TRUE, NULL, FALSE))
 552     goto EH_Fail;
 553   sec_attrs.nLength = sizeof (sec_attrs);
 554   sec_attrs.lpSecurityDescriptor = &sec_desc;
 555   sec_attrs.bInheritHandle = FALSE;
 556
 557   /* creating a new console allow easier close. Do not use
 558      CREATE_NEW_PROCESS_GROUP as this results in disabling Ctrl+C */
 559   flags = CREATE_NEW_CONSOLE;
 560   if (NILP (Vw32_start_process_inherit_error_mode))
 561     flags |= CREATE_DEFAULT_ERROR_MODE;
 562
 563   /* if app is not a gui application, hide the console */
 564   if (is_gui == FALSE) {
 565     start.dwFlags |= STARTF_USESHOWWINDOW;
 566     start.wShowWindow = SW_HIDE;
 567   }
 568
 569   /* Set initial directory to null character to use current directory */
 570   if (!CreateProcess (NULL, cmdline, &sec_attrs, NULL, TRUE,
 571                       flags, env, NULL, &start, &process->procinfo))
 572     goto EH_Fail;
 573
 574   pid = (int) process->procinfo.hProcess;
 575   process->pid=pid;
 576
 577   return pid;
 578
 579  EH_Fail:
 580   return -1;
 581 }
 582
 583 /*************************
 584  ** __gnat_send_header ()
 585  *************************/
 586
 587 #define EXP_SLAVE_CREATE 'c'
 588 #define EXP_SLAVE_KEY    'k'
 589 #define EXP_SLAVE_MOUSE  'm'
 590 #define EXP_SLAVE_WRITE  'w'
 591 #define EXP_SLAVE_KILL   'x'
 592
 593 #define EXP_KILL_TERMINATE  0x1
 594 #define EXP_KILL_CTRL_C     0x2
 595 #define EXP_KILL_CTRL_BREAK 0x4
 596
 597 void
 598 __gnat_send_header (struct TTY_Process* p, char header[5], int size, int *ret)
 599 {
 600   if (p->usePipe == FALSE) {
 601     header[0] = EXP_SLAVE_WRITE;
 602     header[1] = size & 0xff;
 603     header[2] = (size & 0xff00) >> 8;
 604     header[3] = (size & 0xff0000) >> 16;
 605     header[4] = (size & 0xff000000) >> 24;
 606     *ret = 1;
 607   } else {
 608     *ret = 0;
 609   }
 610 }
 611
 612 /**********************************
 613  **  __gnat_setup_communication ()
 614  **********************************/
 615
 616 int
 617 __gnat_setup_communication (struct TTY_Process** process_out) /* output param */
 618 {
 619   struct TTY_Process* process;
 620
 621   process = (struct TTY_Process*)malloc (sizeof (struct TTY_Process));
 622   ZeroMemory (process, sizeof (struct TTY_Process));
 623   *process_out = process;
 624
 625   return 0;
 626 }
 627
 628 #define EXP_PIPE_BASENAME "\\\\.\\pipe\\ExpectPipe"
 629
 630 int
 631 __gnat_setup_child_communication
 632   (struct TTY_Process* process,
 633    char** argv,
 634    int Use_Pipes)
 635 {
 636   int cpid;
 637   HANDLE parent;
 638   SECURITY_ATTRIBUTES sec_attrs;
 639   char slavePath [MAX_PATH];
 640   char **nargv;
 641   int argc;
 642   int i;
 643   char pipeNameIn[100];
 644   HANDLE hSlaveInDrv = NULL; /* Handle to communicate with slave driver */
 645
 646   parent = GetCurrentProcess ();
 647
 648   /* Set inheritance for the pipe handles */
 649   sec_attrs.nLength = sizeof (SECURITY_ATTRIBUTES);
 650   sec_attrs.bInheritHandle = TRUE;
 651   sec_attrs.lpSecurityDescriptor = NULL;
 652
 653   if (Use_Pipes) {
 654     /* Create in and out pipes */
 655     if (!CreatePipe (&process->w_forkin, &process->w_infd, &sec_attrs, 0))
 656       report_file_error ("Creation of child's IN handle", Qnil);
 657     if (!CreatePipe (&process->w_outfd, &process->w_forkout, &sec_attrs, 0))
 658       report_file_error ("Creation of child's OUT handle", Qnil);
 659
 660     /* Do not inherit the parent's side of the pipes */
 661     SetHandleInformation (&process->w_infd, HANDLE_FLAG_INHERIT, 0);
 662     SetHandleInformation (&process->w_outfd, HANDLE_FLAG_INHERIT, 0);
 663
 664     /* use native argv */
 665     nargv = argv;
 666     process->usePipe = TRUE;
 667
 668   } else {
 669     static int pipeNameId = 0;
 670
 671     process->w_infd = NULL;
 672
 673     /* We create a named pipe for Input, as we handle input by sending special
 674        commands to the explaunch process, that uses it to feed the actual input
 675        of the process */
 676     sprintf(pipeNameIn, "%sIn%08x_%08x", EXP_PIPE_BASENAME,
 677             GetCurrentProcessId(), pipeNameId);
 678     pipeNameId++;
 679
 680     hSlaveInDrv = CreateNamedPipe(pipeNameIn,
 681                                   PIPE_ACCESS_OUTBOUND,
 682                                   PIPE_TYPE_BYTE | PIPE_WAIT, 1, 8192, 8192,
 683                                   20000, NULL);
 684     if (hSlaveInDrv == NULL)  goto end;
 685
 686     if (!CreatePipe (&process->w_outfd, &process->w_forkout, &sec_attrs, 0))
 687       report_file_error ("Creation of child's OUT handle", Qnil);
 688
 689     if (SearchPath (NULL, "explaunch.exe", NULL,
 690                     MAX_PATH, slavePath, NULL) == 0) goto end;
 691
 692     for (argc=0; argv[argc] != NULL; argc++) ;
 693     nargv = (char **) malloc (sizeof (char*) * (argc + 3));
 694     nargv[0] = slavePath;
 695     nargv[1] = pipeNameIn;
 696
 697     for (i = 0; i <= argc; i++) nargv[i + 2] = argv[i];
 698     process->usePipe = FALSE;
 699   }
 700
 701   /* Spawn the child. */
 702   cpid = nt_spawnve (nargv[0], nargv, NULL, process);
 703
 704   /* close the duplicated handles passed to the child */
 705   CloseHandle (process->w_forkout);
 706
 707   if (process->usePipe == TRUE) {
 708     CloseHandle (process->w_forkin);
 709
 710   } else {
 711     UCHAR buf[8];               /* enough space for child status info */
 712     DWORD count;
 713     BOOL bRet;
 714     DWORD dwRet;
 715
 716     /*
 717      * Wait for connection with the slave driver
 718      */
 719     bRet = ConnectNamedPipe(hSlaveInDrv, NULL);
 720     if (bRet == FALSE) {
 721       dwRet = GetLastError();
 722       if (dwRet == ERROR_PIPE_CONNECTED) {
 723         ;
 724       } else {
 725         goto end;
 726       }
 727     }
 728
 729     process->w_infd = hSlaveInDrv;
 730
 731     /*
 732      * wait for slave driver to initialize before allowing user to send to it
 733      */
 734     bRet = ReadFile(process->w_outfd, buf, 8, &count, NULL);
 735     if (bRet == FALSE) {
 736       cpid = -1;
 737     }
 738
 739     dwRet = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
 740     if (dwRet != 0) {
 741       cpid = -1;
 742     }
 743
 744     cpid = buf[4] | (buf[5] << 8) | (buf[6] << 16) | (buf[7] << 24);
 745     process->pid = cpid;
 746   }
 747
 748   if (cpid == -1)
 749     /* An error occurred while trying to spawn the process.  */
 750     report_file_error ("Spawning child process", Qnil);
 751
 752   return cpid;
 753  end:
 754   if (hSlaveInDrv != NULL)
 755     CloseHandle (hSlaveInDrv);
 756   return -1;
 757 }
 758
 759 void
 760 __gnat_setup_parent_communication
 761   (struct TTY_Process* process,
 762    int* in,
 763    int* out,
 764    int* err,
 765    int* pid)
 766 {
 767   *in = _open_osfhandle ((long) process->w_infd, 0);
 768   *out = _open_osfhandle ((long) process->w_outfd, 0);
 769   /* child's stderr is always redirected to outfd */
 770   *err = *out;
 771   *pid = process->pid;
 772 }
 773
 774 typedef struct _child_process
 775 {
 776   HWND                 hwnd;
 777   PROCESS_INFORMATION *procinfo;
 778 } child_process;
 779
 780 /* The major and minor versions of NT.  */
 781 static int w32_major_version;
 782 static int w32_minor_version;
 783
 784 /* Distinguish between Windows NT and Windows 95.  */
 785 static enum {OS_UNKNOWN, OS_WIN95, OS_NT} os_subtype = OS_UNKNOWN;
 786
 787 /* Cache information describing the NT system for later use.  */
 788 static void
 789 cache_system_info (void)
 790 {
 791   union
 792     {
 793       struct info
 794         {
 795           char  major;
 796           char  minor;
 797           short platform;
 798         } info;
 799       DWORD data;
 800     } version;
 801
 802   /* Cache the version of the operating system.  */
 803   version.data = GetVersion ();
 804   w32_major_version = version.info.major;
 805   w32_minor_version = version.info.minor;
 806
 807   if (version.info.platform & 0x8000)
 808     os_subtype = OS_WIN95;
 809   else
 810     os_subtype = OS_NT;
 811 }
 812
 813 static BOOL CALLBACK
 814 find_child_console (HWND hwnd, child_process * cp)
 815 {
 816   DWORD thread_id;
 817   DWORD process_id;
 818
 819   thread_id = GetWindowThreadProcessId (hwnd, &process_id);
 820   if (process_id == cp->procinfo->dwProcessId)
 821     {
 822       char window_class[32];
 823
 824       GetClassName (hwnd, window_class, sizeof (window_class));
 825       if (strcmp (window_class,
 826                   (os_subtype == OS_WIN95)
 827                   ? "tty"
 828                   : "ConsoleWindowClass") == 0)
 829         {
 830           cp->hwnd = hwnd;
 831           return FALSE;
 832         }
 833     }
 834   /* keep looking */
 835   return TRUE;
 836 }
 837
 838 int
 839 __gnat_interrupt_process (struct TTY_Process* p)
 840 {
 841   char buf[2];
 842   DWORD written;
 843   BOOL bret;
 844
 845   if (p->usePipe == TRUE) {
 846     bret = FALSE;
 847   } else {
 848     buf[0] = EXP_SLAVE_KILL;
 849     buf[1] = EXP_KILL_CTRL_C;
 850     bret = WriteFile (p->w_infd, buf, 2, &written, NULL);
 851   }
 852
 853   if (bret == FALSE) {
 854     return __gnat_interrupt_pid (p->procinfo.dwProcessId);
 855   }
 856   return 0;
 857 }
 858
 859 int
 860 __gnat_interrupt_pid (int pid)
 861 {
 862   volatile child_process cp;
 863   int rc = 0;
 864
 865   cp.procinfo = (LPPROCESS_INFORMATION) malloc (sizeof (PROCESS_INFORMATION));
 866   cp.procinfo->dwProcessId = pid;
 867
 868   if (os_subtype == OS_UNKNOWN)
 869     cache_system_info ();
 870
 871   /* Try to locate console window for process. */
 872   EnumWindows ((WNDENUMPROC) find_child_console, (LPARAM) &cp);
 873
 874   if (cp.hwnd)
 875     {
 876       BYTE control_scan_code = (BYTE) MapVirtualKey (VK_CONTROL, 0);
 877       /* Retrieve Ctrl-C scancode */
 878       BYTE vk_break_code = 'C';
 879       BYTE break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
 880       HWND foreground_window;
 881
 882       foreground_window = GetForegroundWindow ();
 883       if (foreground_window)
 884         {
 885           /* NT 5.0, and apparently also Windows 98, will not allow
 886              a Window to be set to foreground directly without the
 887              user's involvement. The workaround is to attach
 888              ourselves to the thread that owns the foreground
 889              window, since that is the only thread that can set the
 890              foreground window.  */
 891           DWORD foreground_thread, child_thread;
 892
 893           foreground_thread =
 894             GetWindowThreadProcessId (foreground_window, NULL);
 895           if (foreground_thread == GetCurrentThreadId ()
 896               || !AttachThreadInput (GetCurrentThreadId (),
 897                                      foreground_thread, TRUE))
 898             foreground_thread = 0;
 899
 900           child_thread = GetWindowThreadProcessId (cp.hwnd, NULL);
 901           if (child_thread == GetCurrentThreadId ()
 902               || !AttachThreadInput (GetCurrentThreadId (),
 903                                      child_thread, TRUE))
 904             child_thread = 0;
 905
 906           /* Set the foreground window to the child.  */
 907           if (SetForegroundWindow (cp.hwnd))
 908             {
 909               /* Generate keystrokes as if user had typed Ctrl-Break or
 910                  Ctrl-C.  */
 911               keybd_event (VK_CONTROL, control_scan_code, 0, 0);
 912               keybd_event (vk_break_code, break_scan_code,
 913                 (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY), 0);
 914               keybd_event (vk_break_code, break_scan_code,
 915                 (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY)
 916                  | KEYEVENTF_KEYUP, 0);
 917               keybd_event (VK_CONTROL, control_scan_code, KEYEVENTF_KEYUP, 0);
 918
 919               /* Sleep for a bit to give time for the main frame to respond
 920               to focus change events.  */
 921               Sleep (100);
 922
 923               SetForegroundWindow (foreground_window);
 924             }
 925           /* Detach from the foreground and child threads now that
 926              the foreground switching is over.  */
 927           if (foreground_thread)
 928             AttachThreadInput (GetCurrentThreadId (), foreground_thread, FALSE);
 929           if (child_thread)
 930             AttachThreadInput (GetCurrentThreadId (), child_thread, FALSE);
 931         }
 932     }
 933   /* Ctrl-Break is NT equivalent of SIGINT.  */
 934   else if (!GenerateConsoleCtrlEvent
 935              (CTRL_BREAK_EVENT, cp.procinfo->dwProcessId))
 936     {
 937       errno = EINVAL;
 938       rc = -1;
 939     }
 940
 941   free (cp.procinfo);
 942   return rc;
 943 }
 944
 945 /* kill a process, as this implementation use CreateProcess on Win32 we need
 946    to use Win32 TerminateProcess API */
 947 int
 948 __gnat_terminate_process (struct TTY_Process* p)
 949 {
 950   char buf[2];
 951   DWORD written;
 952   BOOL bret;
 953
 954   if (p->usePipe == TRUE) {
 955     bret = FALSE;
 956   } else {
 957     buf[0] = EXP_SLAVE_KILL;
 958     buf[1] = EXP_KILL_TERMINATE;
 959     bret = WriteFile (p->w_infd, buf, 2, &written, NULL);
 960   }
 961
 962   if (bret == FALSE) {
 963     if (!TerminateProcess (p->procinfo.hProcess, 1))
 964       return -1;
 965     else
 966       return 0;
 967   } else
 968     return 0;
 969 }
 970
 971 typedef struct {
 972   DWORD dwProcessId;
 973   HANDLE hwnd;
 974 } pid_struct;
 975
 976 static BOOL CALLBACK
 977 find_process_handle (HWND hwnd, pid_struct * ps)
 978 {
 979   DWORD thread_id;
 980   DWORD process_id;
 981
 982   thread_id = GetWindowThreadProcessId (hwnd, &process_id);
 983   if (process_id == ps->dwProcessId)
 984     {
 985       ps->hwnd = hwnd;
 986       return FALSE;
 987     }
 988   /* keep looking */
 989   return TRUE;
 990 }
 991
 992 int
 993 __gnat_terminate_pid (int pid)
 994 {
 995   pid_struct ps;
 996
 997   ps.dwProcessId = pid;
 998   ps.hwnd = 0;
 999   EnumWindows ((WNDENUMPROC) find_process_handle, (LPARAM) &ps);
1000
1001   if (ps.hwnd)
1002     {
1003       if (!TerminateProcess (ps.hwnd, 1))
1004         return -1;
1005       else
1006         return 0;
1007     }
1008
1009   return -1;
1010 }
1011
1012 /* wait for process pid to terminate and return the process status. This
1013    implementation is different from the adaint.c one for Windows as it uses
1014    the Win32 API instead of the C one. */
1015
1016 int
1017 __gnat_tty_waitpid (struct TTY_Process* p)
1018 {
1019   DWORD exitcode;
1020   DWORD res;
1021   HANDLE proc_hand = p->procinfo.hProcess;
1022
1023   res = WaitForSingleObject (proc_hand, 0);
1024   GetExitCodeProcess (proc_hand, &exitcode);
1025
1026   CloseHandle (p->procinfo.hThread);
1027   CloseHandle (p->procinfo.hProcess);
1028
1029   /* No need to close the handles: they were closed on the ada side */
1030
1031   return (int) exitcode;
1032 }
1033
1034 /********************************
1035  **  __gnat_free_process ()
1036  ********************************/
1037
1038 void
1039 __gnat_free_process (struct TTY_Process** process)
1040 {
1041   free (*process);
1042   *process = NULL;
1043 }
1044
1045 /* TTY handling */
1046
1047 typedef struct {
1048   int tty_fd;        /* descriptor for the tty */
1049   char tty_name[24]; /* Name of TTY device */
1050 } TTY_Handle;
1051
1052 int
1053 __gnat_tty_supported (void)
1054 {
1055   return 0;
1056 }
1057
1058 /* Return the tty name associated with p */
1059
1060 char *
1061 __gnat_tty_name (TTY_Handle* t)
1062 {
1063   return t->tty_name;
1064 }
1065
1066 int
1067 __gnat_tty_fd (TTY_Handle* t)
1068 {
1069   return t->tty_fd;
1070 }
1071
1072 TTY_Handle*
1073 __gnat_new_tty (void)
1074 {
1075   return (TTY_Handle*)0;
1076 }
1077
1078 void
1079 __gnat_reset_tty (TTY_Handle* t)
1080 {
1081   return;
1082 }
1083
1084 void
1085 __gnat_close_tty (TTY_Handle* t)
1086 {
1087   free (t);
1088 }
1089
1090 void
1091 __gnat_setup_winsize (void *desc, int rows, int columns)
1092 {
1093 }
1094
1095 #else /* defined(_WIN32, implementatin for all UNIXes */
1096
1097 /* First defined some macro to identify easily some systems */
1098 #if defined (__FreeBSD__) \
1099  || defined (__OpenBSD__) \
1100  || defined (__NetBSD__)  \
1101  || defined (__DragonFly__)
1102 #   define BSD
1103 #endif
1104
1105 /* Include every system header we need */
1106 #define _GNU_SOURCE
1107 #include <errno.h>
1108 #include <stdio.h>
1109 #include <stdlib.h>
1110
1111 /* On some system termio is either absent or including it will disable termios
1112    (HP-UX) */
1113 #if !defined (__hpux__) && !defined (BSD) && !defined (__APPLE__) \
1114   && !defined (__rtems__) && !defined (__QNXNTO__)
1115 #   include <termio.h>
1116 #endif
1117
1118 #include <sys/ioctl.h>
1119 #include <termios.h>
1120 #include <fcntl.h>
1121 #include <string.h>
1122 #include <sys/stat.h>
1123 #include <sys/types.h>
1124 #include <sys/wait.h>
1125 #include <unistd.h>
1126 #if defined (__sun__)
1127 #   include <sys/stropts.h>
1128 #endif
1129 #if defined (BSD) || defined (__sun__)
1130 #   include <sys/signal.h>
1131 #endif
1132 #if defined (__hpux__)
1133 #   include <sys/termio.h>
1134 #   include <sys/stropts.h>
1135 #endif
1136
1137 #define CDISABLE _POSIX_VDISABLE
1138
1139 /* On HP-UX and Sun system, there is a bzero function but with a different
1140    signature. Use memset instead */
1141 #if defined (__hpux__) || defined (__sun__) || defined (_AIX)
1142 #   define bzero(s,n) memset (s,0,n)
1143 #endif
1144
1145 /* POSIX does not specify how to open the master side of a terminal.Several
1146    methods are available (system specific):
1147       1- using a cloning device (USE_CLONE_DEVICE)
1148       2- getpt                  (USE_GETPT)
1149       3- openpty                (USE_OPENPTY)
1150
1151    When using the cloning device method, the macro USE_CLONE_DEVICE should
1152    contains a full path to the adequate device.
1153
1154    When a new system is about to be supported, one of the previous macro should
1155    be set otherwise allocate_pty_desc will return an error
1156 */
1157
1158 /* Configurable part */
1159 #if defined (__APPLE__) || defined (BSD)
1160 #define USE_OPENPTY
1161 #elif defined (__linux__)
1162 #define USE_GETPT
1163 #elif defined (__sun__)
1164 #define USE_CLONE_DEVICE "/dev/ptmx"
1165 #elif defined (_AIX)
1166 #define USE_CLONE_DEVICE "/dev/ptc"
1167 #elif defined (__hpux__)
1168 /* On HP-UX we use the streamed version. Using the non streamed version is not
1169    recommanded (through "/dev/ptym/clone"). Indeed it seems that there are
1170    issues to detect process terminations. */
1171 #define USE_CLONE_DEVICE "/dev/ptmx"
1172 #endif
1173
1174 /* structure that holds information about the terminal used and the process
1175    connected on the slave side */
1176 typedef struct pty_desc_struct {
1177    int  master_fd;     /* fd of the master side if the terminal */
1178    int  slave_fd;      /* fd of the slave side */
1179    char slave_name[32];   /* filename of the slave side */
1180    int  child_pid;     /* PID of the child process connected to the slave side
1181                          of the terminal */
1182 } pty_desc;
1183
1184 /* allocate_pty_desc - allocate a pseudo terminal
1185  *
1186  * PARAMETERS
1187  *   out desc  returned pointer to a pty_desc structure containing information
1188  *             about the opened pseudo terminal
1189  * RETURN VALUE
1190  *   -1        if failed
1191  *    0        if ok
1192  * COMMENTS
1193  *   If the function is successful we should have at least the master side fd
1194  *   and the slave side filename. On some system, the slave side will also be
1195  *   opened. If this is not the case the slave side will be open once we are in
1196  *   the child process (note that opening the slave side at this stage will
1197  *   failed...).
1198  */
1199
1200 extern char* ptsname (int);
1201
1202 static int
1203 allocate_pty_desc (pty_desc **desc) {
1204
1205    pty_desc *result;
1206    int  status      =  0;
1207    int  slave_fd    = -1;
1208    int  master_fd   = -1;
1209    char *slave_name = NULL;
1210
1211 #ifdef USE_GETPT
1212   master_fd = getpt ();
1213 #elif defined (USE_OPENPTY)
1214   status = openpty (&master_fd, &slave_fd, NULL, NULL, NULL);
1215 #elif defined (USE_CLONE_DEVICE)
1216   master_fd = open (USE_CLONE_DEVICE, O_RDWR | O_NONBLOCK, 0);
1217 #else
1218   printf ("[error]: terminal support is not configured\n");
1219   return -1;
1220 #endif
1221
1222   /* at this stage we should have the master side fd and status should be 0 */
1223   if (status != 0 || master_fd < 0)
1224     {
1225       /* If this is not the case close all opened files and return -1 */
1226       printf ("[error]: cannot allocate master side of the pty\n");
1227       if (master_fd >= 0) close (master_fd);
1228       if (slave_fd  >= 0) close (slave_fd);
1229       *desc = NULL;
1230       return -1;
1231     }
1232
1233   /* retrieve the file name of the slave side if necessary */
1234   if (slave_name == NULL) slave_name = (char *) ptsname (master_fd);
1235
1236   /* Now we should have slave file name */
1237   if (slave_name == NULL)
1238     {
1239       /* If not the case close any opened file and return - 1 */
1240       printf ("[error]: cannot allocate slave side of the pty\n");
1241       if (master_fd >= 0) close (master_fd);
1242       if (slave_fd  >= 0) close (slave_fd);
1243       *desc = NULL;
1244       return -1;
1245     }
1246
1247 #if !defined(__rtems__)
1248   /* grant access to the slave side */
1249   grantpt (master_fd);
1250   /* unlock the terminal */
1251   unlockpt (master_fd);
1252 #endif
1253
1254   /* set desc and return 0 */
1255   result = malloc (sizeof (pty_desc));
1256   result->master_fd  = master_fd;
1257   result->slave_fd   = slave_fd;
1258   /* the string returned by ptsname or _getpty is a static allocated string. So
1259      we should make a copy */
1260   strncpy (result->slave_name, slave_name, sizeof (result->slave_name));
1261   result->slave_name[sizeof (result->slave_name) - 1] = '\0';
1262   result->child_pid  = -1;
1263   *desc=result;
1264   return 0;
1265 }
1266
1267 /* some utility macro that make the code of child_setup_tty easier to read */
1268 #define __enable(a, b) ((a) |= (b))
1269 #define __disable(a, b) ((a) &= ~(b))
1270
1271 /* some properties do not exist on all systems. Set their value to 0 in that
1272    case */
1273 #ifndef IUCLC
1274 #define IUCLC 0
1275 #endif
1276 #ifndef OLCUC
1277 #define OLCUC 0
1278 #endif
1279 #ifndef NLDLY
1280 #define NLDLY 0
1281 #define CRDLY 0
1282 #define TABDLY 0
1283 #define BSDLY 0
1284 #define VTDLY 0
1285 #define FFDLY 0
1286 #endif
1287
1288 /* child_setup_tty - set terminal properties
1289  *
1290  * PARAMETERS
1291  *   file descriptor of the slave side of the terminal
1292  *
1293  * RETURN VALUE
1294  *   0 if success, any other value if failed.
1295  *
1296  * COMMENTS
1297  *   None
1298  */
1299 static int
1300 child_setup_tty (int fd)
1301 {
1302   struct termios s;
1303   int    status;
1304
1305   /* ensure that s is filled with 0 */
1306   bzero (&s, sizeof (s));
1307
1308   /* Get the current terminal settings */
1309   status = tcgetattr (fd, &s);
1310   if (status != 0) return -1;
1311
1312   /* Adjust input modes */
1313   __disable (s.c_iflag, IUCLC);    /* don't transform to lower case */
1314   __disable (s.c_iflag, ISTRIP);   /* don't delete 8th bit */
1315
1316   /* Adjust output modes */
1317   __enable  (s.c_oflag, OPOST);    /* enable postprocessing */
1318   __disable (s.c_oflag, ONLCR);    /* don't map LF to CR-LF */
1319   __disable (s.c_oflag, NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
1320                                    /* disable delays */
1321   __disable (s.c_oflag, OLCUC);    /* don't transform to upper case */
1322
1323   /* Adjust control modes */
1324   s.c_cflag = (s.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
1325
1326   /* Adjust local modes */
1327   __disable (s.c_lflag, ECHO);     /* disable echo */
1328   __enable  (s.c_lflag, ISIG);     /* enable signals */
1329   __enable  (s.c_lflag, ICANON);   /* erase/kill/eof processing */
1330
1331   /* Adjust control characters */
1332   /* IMPORTANT: we need to ensure that Ctrl-C will trigger an interrupt signal
1333      otherwise send_signal_via_characters will fail */
1334   s.c_cc[VEOF]   = 04;         /* insure that EOF is Control-D */
1335   s.c_cc[VERASE] = CDISABLE;   /* disable erase processing */
1336   s.c_cc[VKILL]  = CDISABLE;   /* disable kill processing */
1337   s.c_cc[VQUIT]  = 28;         /* Control-\ */
1338   s.c_cc[VINTR]  = 03;         /* Control-C */
1339   s.c_cc[VEOL]   = CDISABLE;
1340   s.c_cc[VSUSP]  = 26;         /* Control-Z */
1341
1342   /* push our changes */
1343   status = tcsetattr (fd, TCSADRAIN, &s);
1344   return status;
1345 }
1346
1347 /* __gnat_setup_communication - interface to the external world. Should be
1348  * called before forking. On Unixes this function only call allocate_pty_desc.
1349  * The Windows implementation (in different part of this file) is very
1350  * different.
1351  *
1352  * PARAMETERS
1353  *  out desc   returned pointer to a pty_desc structure
1354  * RETURN VALUE
1355  *  0 if success, -1 otherwise
1356  */
1357 int __gnat_setup_communication (pty_desc** desc) {
1358   return allocate_pty_desc (desc);
1359 }
1360
1361 /* __gnat_setup_parent_communication - interface to the external world. Should
1362  * be called after forking in the parent process
1363  *
1364  * PARAMETERS
1365  *   out in_fd
1366      out out_fd
1367      out err_fd fds corresponding to the parent side of the
1368                 terminal
1369      in pid_out child process pid
1370  * RETRUN VALUE
1371  *  0
1372  */
1373 void
1374 __gnat_setup_parent_communication
1375   (pty_desc *desc,
1376    int*     in_fd,  /* input */
1377    int*     out_fd, /* output */
1378    int*     err_fd, /* error */
1379    int*     pid_out)
1380 {
1381
1382   *in_fd = desc->master_fd;
1383   *out_fd= desc->master_fd;
1384   *err_fd= desc->master_fd;
1385   desc->child_pid = *pid_out;
1386 }
1387
1388 /* __gnat_setup_winsize - Sets up the size of the terminal
1389  * This lets the process know the size of the terminal
1390  */
1391
1392 void __gnat_setup_winsize (pty_desc *desc, int rows, int columns) {
1393 #ifdef TIOCGWINSZ
1394   struct winsize s;
1395   s.ws_row = (unsigned short)rows;
1396   s.ws_col = (unsigned short)columns;
1397   s.ws_xpixel = 0;
1398   s.ws_ypixel = 0;
1399   ioctl (desc->master_fd, TIOCSWINSZ, &s);
1400 #ifdef SIGWINCH
1401   if (desc->child_pid > 0) {
1402      /* Let the process know about the change in size */
1403      kill (desc->child_pid, SIGWINCH);
1404   }
1405 #endif
1406 #endif
1407 }
1408
1409 /* __gnat_setup_child_communication - interface to external world. Should be
1410  * called after forking in the child process. On Unixes, this function
1411  * first adjust the line setting, set standard output, input and error and
1412  * then spawn the program.
1413  *
1414  * PARAMETERS
1415  *   desc      a pty_desc structure containing the pty parameters
1416  *   new_argv  argv of the program to be spawned
1417  * RETURN VALUE
1418  *   this function should not return
1419  */
1420 int
1421 __gnat_setup_child_communication
1422    (pty_desc *desc,
1423     char **new_argv,
1424     int Use_Pipes)
1425 {
1426   int status;
1427   int pid = getpid ();
1428
1429   setsid ();
1430
1431   /* open the slave side of the terminal if necessary */
1432   if (desc->slave_fd == -1)
1433 #if defined (_AIX)
1434     /* On AIX, if the slave process is not opened with O_NDELAY or O_NONBLOCK
1435        then we might have some processes hanging on I/O system calls. Not sure
1436        we can do that for all platforms so do it only on AIX for the moment.
1437        On AIX O_NONBLOCK and O_NDELAY have slightly different meanings. When
1438        reading on the slave fd, in case there is no data available, if O_NDELAY
1439        is set then 0 is returned. If O_NON_BLOCK is -1 is returned. It seems
1440        that interactive programs such as GDB prefer the O_NDELAY behavior.
1441        We chose O_NONBLOCK because it allows us to make the distinction
1442        between a true EOF and an EOF returned because there is no data
1443        available to be read.  */
1444     desc->slave_fd = open (desc->slave_name, O_RDWR | O_NONBLOCK, 0);
1445 #else
1446     desc->slave_fd = open (desc->slave_name, O_RDWR, 0);
1447 #endif
1448
1449 #if defined (__sun__) || defined (__hpux__)
1450   /* On systems such as Solaris we are using stream. We need to push the right
1451      "modules" in order to get the expected terminal behaviors. Otherwise
1452      functionalities such as termios are not available.  */
1453   ioctl (desc->slave_fd, I_PUSH, "ptem");
1454   ioctl (desc->slave_fd, I_PUSH, "ldterm");
1455   ioctl (desc->slave_fd, I_PUSH, "ttcompat");
1456 #endif
1457
1458 #ifdef TIOCSCTTY
1459   /* make the tty the controlling terminal */
1460   if ((status = ioctl (desc->slave_fd, TIOCSCTTY, 0)) == -1)
1461     _exit (1);
1462 #endif
1463
1464   /* adjust tty settings */
1465   child_setup_tty (desc->slave_fd);
1466   __gnat_setup_winsize (desc, 24, 80); /* To prevent errors in some shells */
1467
1468   /* stdin, stdout and stderr should be now our tty */
1469   dup2 (desc->slave_fd, 0);
1470   dup2 (desc->slave_fd, 1);
1471   dup2 (desc->slave_fd, 2);
1472   if (desc->slave_fd > 2) close (desc->slave_fd);
1473
1474   /* adjust process group settings */
1475   /* ignore failures of the following two commands as the context might not
1476    * allow making those changes. */
1477   setpgid (pid, pid);
1478   tcsetpgrp (0, pid);
1479
1480   /* launch the program */
1481   execvp (new_argv[0], new_argv);
1482
1483   _exit (1);
1484 }
1485
1486 /* send_signal_via_characters - Send a characters that will trigger a signal
1487  * in the child process.
1488  *
1489  * PARAMETERS
1490  *  desc  a pty_desc structure containing terminal information
1491  *  int   a signal number
1492  * RETURN VALUE
1493  *  None
1494  */
1495 static void
1496 send_signal_via_characters
1497   (pty_desc *desc,
1498    int signal_number)
1499 {
1500   char ctrl_c         = 03;
1501   char ctrl_backslash = 28;
1502   char ctrl_Z         = 26;
1503
1504   switch (signal_number)
1505     {
1506       case SIGINT:
1507         write (desc->master_fd, &ctrl_c, 1); return;
1508       case SIGQUIT:
1509         write (desc->master_fd, &ctrl_backslash, 1); return;
1510       case SIGTSTP:
1511         write (desc->master_fd, &ctrl_Z, 1); return;
1512     }
1513 }
1514
1515 /* __gnat_interrupt_process - interrupt the child process
1516  *
1517  * PARAMETERS
1518  *   desc a pty_desc structure
1519  */
1520 int
1521 __gnat_interrupt_process (pty_desc *desc)
1522 {
1523   send_signal_via_characters (desc, SIGINT);
1524   return 0;
1525 }
1526
1527 /* __gnat_interrupt_pid - interrupt a process group
1528  *
1529  * PARAMETERS
1530  *   pid  pid of the process to interrupt
1531  */
1532 int
1533 __gnat_interrupt_pid (int pid)
1534 {
1535   kill (-pid, SIGINT);
1536   return 0;
1537 }
1538
1539 /* __gnat_terminate_process - kill a child process
1540  *
1541  * PARAMETERS
1542  *   desc pty_desc structure
1543  */
1544 int __gnat_terminate_process (pty_desc *desc)
1545 {
1546   return kill (desc->child_pid, SIGKILL);
1547 }
1548
1549 /* __gnat_terminate_pid - kill a process
1550  *
1551  * PARAMETERS
1552  *   pid unix process id
1553  */
1554 int
1555 __gnat_terminate_pid (int pid)
1556 {
1557   return kill (pid, SIGKILL);
1558 }
1559
1560 /* __gnat_tty_waitpid - wait for the child process to die
1561  *
1562  * PARAMETERS
1563  *   desc pty_desc structure
1564  * RETURN VALUE
1565  *   exit status of the child process
1566  */
1567 int
1568 __gnat_tty_waitpid (pty_desc *desc)
1569 {
1570   int status = 0;
1571   waitpid (desc->child_pid, &status, 0);
1572   return WEXITSTATUS (status);
1573 }
1574
1575 /* __gnat_tty_supported - Are tty supported ?
1576  *
1577  * RETURN VALUE
1578  *   always 1 on Unix systems
1579  */
1580 int
1581 __gnat_tty_supported (void)
1582 {
1583   return 1;
1584 }
1585
1586 /* __gnat_free_process - free a pty_desc structure
1587  *
1588  * PARAMETERS
1589  *   in out desc: a pty desc structure
1590  */
1591 void
1592 __gnat_free_process (pty_desc** desc)
1593 {
1594   free (*desc);
1595   *desc = NULL;
1596 }
1597
1598 /* __gnat_send_header - dummy function. this interface is only used on Windows */
1599 void
1600 __gnat_send_header (pty_desc* desc, char header[5], int size, int *ret)
1601 {
1602   *ret = 0;
1603 }
1604
1605 /* __gnat_reset_tty - reset line setting
1606  *
1607  * PARAMETERS
1608  *   desc: a pty_desc structure
1609  */
1610 void
1611 __gnat_reset_tty (pty_desc* desc)
1612 {
1613   child_setup_tty (desc->master_fd);
1614 }
1615
1616 /* __gnat_new_tty - allocate a new terminal
1617  *
1618  * RETURN VALUE
1619  *   a pty_desc structure
1620  */
1621 pty_desc *
1622 __gnat_new_tty (void)
1623 {
1624   int status;
1625   pty_desc* desc = NULL;
1626   if ((status = allocate_pty_desc (&desc)))
1627     child_setup_tty (desc->master_fd);
1628   return desc;
1629 }
1630
1631 /* __gnat_close_tty - close a terminal
1632  *
1633  * PARAMETERS
1634  *   desc  a pty_desc strucure
1635  */
1636 void __gnat_close_tty (pty_desc* desc)
1637 {
1638   if (desc->master_fd >= 0) close (desc->master_fd);
1639   if (desc->slave_fd  >= 0) close (desc->slave_fd);
1640 }
1641
1642 /* __gnat_tty_name - return slave side device name
1643  *
1644  * PARAMETERS
1645  *   desc  a pty_desc strucure
1646  * RETURN VALUE
1647  *   a string
1648  */
1649 char *
1650 __gnat_tty_name (pty_desc* desc)
1651 {
1652   return desc->slave_name;
1653 }
1654
1655 /* __gnat_tty_name - return master side fd
1656  *
1657  * PARAMETERS
1658  *   desc  a pty_desc strucure
1659  * RETURN VALUE
1660  *   a fd
1661  */
1662 int
1663 __gnat_tty_fd (pty_desc* desc)
1664 {
1665   return desc->master_fd;
1666 }
1667
1668 #endif /* WIN32 */