gdb/ser-unix.c

   1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
   2    Copyright 1992-1994, 1998-2000 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "serial.h"
  23 #include "ser-unix.h"
  24
  25 #include <fcntl.h>
  26 #include <sys/types.h>
  27 #include "terminal.h"
  28 #include "gdb_wait.h"
  29 #include <sys/socket.h>
  30 #include <sys/time.h>
  31
  32 #include "gdb_string.h"
  33 #include "event-loop.h"
  34
  35 #ifdef HAVE_TERMIOS
  36
  37 struct hardwire_ttystate
  38   {
  39     struct termios termios;
  40   };
  41 #endif /* termios */
  42
  43 #ifdef HAVE_TERMIO
  44
  45 /* It is believed that all systems which have added job control to SVR3
  46    (e.g. sco) have also added termios.  Even if not, trying to figure out
  47    all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
  48    bewildering.  So we don't attempt it.  */
  49
  50 struct hardwire_ttystate
  51   {
  52     struct termio termio;
  53   };
  54 #endif /* termio */
  55
  56 #ifdef HAVE_SGTTY
  57 struct hardwire_ttystate
  58   {
  59     struct sgttyb sgttyb;
  60     struct tchars tc;
  61     struct ltchars ltc;
  62     /* Line discipline flags.  */
  63     int lmode;
  64   };
  65 #endif /* sgtty */
  66
  67 static int hardwire_open (serial_t scb, const char *name);
  68 static void hardwire_raw (serial_t scb);
  69 static int wait_for (serial_t scb, int timeout);
  70 static int hardwire_readchar (serial_t scb, int timeout);
  71 static int do_hardwire_readchar (serial_t scb, int timeout);
  72 static int generic_readchar (serial_t scb, int timeout, int (*do_readchar) (serial_t scb, int timeout));
  73 static int rate_to_code (int rate);
  74 static int hardwire_setbaudrate (serial_t scb, int rate);
  75 static void hardwire_close (serial_t scb);
  76 static int get_tty_state (serial_t scb, struct hardwire_ttystate * state);
  77 static int set_tty_state (serial_t scb, struct hardwire_ttystate * state);
  78 static serial_ttystate hardwire_get_tty_state (serial_t scb);
  79 static int hardwire_set_tty_state (serial_t scb, serial_ttystate state);
  80 static int hardwire_noflush_set_tty_state (serial_t, serial_ttystate,
  81                                                    serial_ttystate);
  82 static void hardwire_print_tty_state (serial_t, serial_ttystate, struct ui_file *);
  83 static int hardwire_drain_output (serial_t);
  84 static int hardwire_flush_output (serial_t);
  85 static int hardwire_flush_input (serial_t);
  86 static int hardwire_send_break (serial_t);
  87 static int hardwire_setstopbits (serial_t, int);
  88
  89 static int do_unix_readchar (serial_t scb, int timeout);
  90 static timer_handler_func push_event;
  91 static handler_func fd_event;
  92 static void reschedule (serial_t scb);
  93
  94 void _initialize_ser_hardwire (void);
  95
  96 extern int (*ui_loop_hook) (int);
  97
  98 /* Open up a real live device for serial I/O */
  99
 100 static int
 101 hardwire_open (serial_t scb, const char *name)
 102 {
 103   scb->fd = open (name, O_RDWR);
 104   if (scb->fd < 0)
 105     return -1;
 106
 107   return 0;
 108 }
 109
 110 static int
 111 get_tty_state (serial_t scb, struct hardwire_ttystate *state)
 112 {
 113 #ifdef HAVE_TERMIOS
 114   if (tcgetattr (scb->fd, &state->termios) < 0)
 115     return -1;
 116
 117   return 0;
 118 #endif
 119
 120 #ifdef HAVE_TERMIO
 121   if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
 122     return -1;
 123   return 0;
 124 #endif
 125
 126 #ifdef HAVE_SGTTY
 127   if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
 128     return -1;
 129   if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
 130     return -1;
 131   if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
 132     return -1;
 133   if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
 134     return -1;
 135
 136   return 0;
 137 #endif
 138 }
 139
 140 static int
 141 set_tty_state (serial_t scb, struct hardwire_ttystate *state)
 142 {
 143 #ifdef HAVE_TERMIOS
 144   if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
 145     return -1;
 146
 147   return 0;
 148 #endif
 149
 150 #ifdef HAVE_TERMIO
 151   if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
 152     return -1;
 153   return 0;
 154 #endif
 155
 156 #ifdef HAVE_SGTTY
 157   if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
 158     return -1;
 159   if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
 160     return -1;
 161   if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
 162     return -1;
 163   if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
 164     return -1;
 165
 166   return 0;
 167 #endif
 168 }
 169
 170 static serial_ttystate
 171 hardwire_get_tty_state (serial_t scb)
 172 {
 173   struct hardwire_ttystate *state;
 174
 175   state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
 176
 177   if (get_tty_state (scb, state))
 178     return NULL;
 179
 180   return (serial_ttystate) state;
 181 }
 182
 183 static int
 184 hardwire_set_tty_state (serial_t scb, serial_ttystate ttystate)
 185 {
 186   struct hardwire_ttystate *state;
 187
 188   state = (struct hardwire_ttystate *) ttystate;
 189
 190   return set_tty_state (scb, state);
 191 }
 192
 193 static int
 194 hardwire_noflush_set_tty_state (serial_t scb,
 195                                 serial_ttystate new_ttystate,
 196                                 serial_ttystate old_ttystate)
 197 {
 198   struct hardwire_ttystate new_state;
 199 #ifdef HAVE_SGTTY
 200   struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
 201 #endif
 202
 203   new_state = *(struct hardwire_ttystate *) new_ttystate;
 204
 205   /* Don't change in or out of raw mode; we don't want to flush input.
 206      termio and termios have no such restriction; for them flushing input
 207      is separate from setting the attributes.  */
 208
 209 #ifdef HAVE_SGTTY
 210   if (state->sgttyb.sg_flags & RAW)
 211     new_state.sgttyb.sg_flags |= RAW;
 212   else
 213     new_state.sgttyb.sg_flags &= ~RAW;
 214
 215   /* I'm not sure whether this is necessary; the manpage just mentions
 216      RAW not CBREAK.  */
 217   if (state->sgttyb.sg_flags & CBREAK)
 218     new_state.sgttyb.sg_flags |= CBREAK;
 219   else
 220     new_state.sgttyb.sg_flags &= ~CBREAK;
 221 #endif
 222
 223   return set_tty_state (scb, &new_state);
 224 }
 225
 226 static void
 227 hardwire_print_tty_state (serial_t scb,
 228                           serial_ttystate ttystate,
 229                           struct ui_file *stream)
 230 {
 231   struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
 232   int i;
 233
 234 #ifdef HAVE_TERMIOS
 235   fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
 236                     (int) state->termios.c_iflag,
 237                     (int) state->termios.c_oflag);
 238   fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
 239                     (int) state->termios.c_cflag,
 240                     (int) state->termios.c_lflag);
 241 #if 0
 242   /* This not in POSIX, and is not really documented by those systems
 243      which have it (at least not Sun).  */
 244   fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
 245 #endif
 246   fprintf_filtered (stream, "c_cc: ");
 247   for (i = 0; i < NCCS; i += 1)
 248     fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
 249   fprintf_filtered (stream, "\n");
 250 #endif
 251
 252 #ifdef HAVE_TERMIO
 253   fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
 254                     state->termio.c_iflag, state->termio.c_oflag);
 255   fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
 256                     state->termio.c_cflag, state->termio.c_lflag,
 257                     state->termio.c_line);
 258   fprintf_filtered (stream, "c_cc: ");
 259   for (i = 0; i < NCC; i += 1)
 260     fprintf_filtered (stream, "0x%x ", state->termio.c_cc[i]);
 261   fprintf_filtered (stream, "\n");
 262 #endif
 263
 264 #ifdef HAVE_SGTTY
 265   fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n",
 266                     state->sgttyb.sg_flags);
 267
 268   fprintf_filtered (stream, "tchars: ");
 269   for (i = 0; i < (int) sizeof (struct tchars); i++)
 270     fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->tc)[i]);
 271   fprintf_filtered ("\n");
 272
 273   fprintf_filtered (stream, "ltchars: ");
 274   for (i = 0; i < (int) sizeof (struct ltchars); i++)
 275     fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->ltc)[i]);
 276   fprintf_filtered (stream, "\n");
 277
 278   fprintf_filtered (stream, "lmode:  0x%x\n", state->lmode);
 279 #endif
 280 }
 281
 282 /* Wait for the output to drain away, as opposed to flushing (discarding) it */
 283
 284 static int
 285 hardwire_drain_output (serial_t scb)
 286 {
 287 #ifdef HAVE_TERMIOS
 288   return tcdrain (scb->fd);
 289 #endif
 290
 291 #ifdef HAVE_TERMIO
 292   return ioctl (scb->fd, TCSBRK, 1);
 293 #endif
 294
 295 #ifdef HAVE_SGTTY
 296   /* Get the current state and then restore it using TIOCSETP,
 297      which should cause the output to drain and pending input
 298      to be discarded. */
 299   {
 300     struct hardwire_ttystate state;
 301     if (get_tty_state (scb, &state))
 302       {
 303         return (-1);
 304       }
 305     else
 306       {
 307         return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
 308       }
 309   }
 310 #endif
 311 }
 312
 313 static int
 314 hardwire_flush_output (serial_t scb)
 315 {
 316 #ifdef HAVE_TERMIOS
 317   return tcflush (scb->fd, TCOFLUSH);
 318 #endif
 319
 320 #ifdef HAVE_TERMIO
 321   return ioctl (scb->fd, TCFLSH, 1);
 322 #endif
 323
 324 #ifdef HAVE_SGTTY
 325   /* This flushes both input and output, but we can't do better.  */
 326   return ioctl (scb->fd, TIOCFLUSH, 0);
 327 #endif
 328 }
 329
 330 static int
 331 hardwire_flush_input (serial_t scb)
 332 {
 333   ser_unix_flush_input (scb);
 334
 335 #ifdef HAVE_TERMIOS
 336   return tcflush (scb->fd, TCIFLUSH);
 337 #endif
 338
 339 #ifdef HAVE_TERMIO
 340   return ioctl (scb->fd, TCFLSH, 0);
 341 #endif
 342
 343 #ifdef HAVE_SGTTY
 344   /* This flushes both input and output, but we can't do better.  */
 345   return ioctl (scb->fd, TIOCFLUSH, 0);
 346 #endif
 347 }
 348
 349 static int
 350 hardwire_send_break (serial_t scb)
 351 {
 352 #ifdef HAVE_TERMIOS
 353   return tcsendbreak (scb->fd, 0);
 354 #endif
 355
 356 #ifdef HAVE_TERMIO
 357   return ioctl (scb->fd, TCSBRK, 0);
 358 #endif
 359
 360 #ifdef HAVE_SGTTY
 361   {
 362     int status;
 363     struct timeval timeout;
 364
 365     status = ioctl (scb->fd, TIOCSBRK, 0);
 366
 367     /* Can't use usleep; it doesn't exist in BSD 4.2.  */
 368     /* Note that if this select() is interrupted by a signal it will not wait
 369        the full length of time.  I think that is OK.  */
 370     timeout.tv_sec = 0;
 371     timeout.tv_usec = 250000;
 372     select (0, 0, 0, 0, &timeout);
 373     status = ioctl (scb->fd, TIOCCBRK, 0);
 374     return status;
 375   }
 376 #endif
 377 }
 378
 379 static void
 380 hardwire_raw (serial_t scb)
 381 {
 382   struct hardwire_ttystate state;
 383
 384   if (get_tty_state (scb, &state))
 385     fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
 386
 387 #ifdef HAVE_TERMIOS
 388   state.termios.c_iflag = 0;
 389   state.termios.c_oflag = 0;
 390   state.termios.c_lflag = 0;
 391   state.termios.c_cflag &= ~(CSIZE | PARENB);
 392   state.termios.c_cflag |= CLOCAL | CS8;
 393   state.termios.c_cc[VMIN] = 0;
 394   state.termios.c_cc[VTIME] = 0;
 395 #endif
 396
 397 #ifdef HAVE_TERMIO
 398   state.termio.c_iflag = 0;
 399   state.termio.c_oflag = 0;
 400   state.termio.c_lflag = 0;
 401   state.termio.c_cflag &= ~(CSIZE | PARENB);
 402   state.termio.c_cflag |= CLOCAL | CS8;
 403   state.termio.c_cc[VMIN] = 0;
 404   state.termio.c_cc[VTIME] = 0;
 405 #endif
 406
 407 #ifdef HAVE_SGTTY
 408   state.sgttyb.sg_flags |= RAW | ANYP;
 409   state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
 410 #endif
 411
 412   scb->current_timeout = 0;
 413
 414   if (set_tty_state (scb, &state))
 415     fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
 416 }
 417
 418 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 419    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
 420
 421    For termio{s}, we actually just setup VTIME if necessary, and let the
 422    timeout occur in the read() in hardwire_read().
 423  */
 424
 425 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
 426    ser_unix*() until the old TERMIOS/SGTTY/... timer code has been
 427    flushed. . */
 428
 429 /* NOTE: cagney/1999-09-30: Much of the code below is dead.  The only
 430    possible values of the TIMEOUT parameter are ONE and ZERO.
 431    Consequently all the code that tries to handle the possability of
 432    an overflowed timer is unnecessary. */
 433
 434 static int
 435 wait_for (serial_t scb, int timeout)
 436 {
 437 #ifdef HAVE_SGTTY
 438   {
 439     struct timeval tv;
 440     fd_set readfds;
 441
 442     FD_ZERO (&readfds);
 443
 444     tv.tv_sec = timeout;
 445     tv.tv_usec = 0;
 446
 447     FD_SET (scb->fd, &readfds);
 448
 449     while (1)
 450       {
 451         int numfds;
 452
 453         if (timeout >= 0)
 454           numfds = select (scb->fd + 1, &readfds, 0, 0, &tv);
 455         else
 456           numfds = select (scb->fd + 1, &readfds, 0, 0, 0);
 457
 458         if (numfds <= 0)
 459           if (numfds == 0)
 460             return SERIAL_TIMEOUT;
 461           else if (errno == EINTR)
 462             continue;
 463           else
 464             return SERIAL_ERROR;        /* Got an error from select or poll */
 465
 466         return 0;
 467       }
 468   }
 469 #endif /* HAVE_SGTTY */
 470
 471 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
 472   if (timeout == scb->current_timeout)
 473     return 0;
 474
 475   scb->current_timeout = timeout;
 476
 477   {
 478     struct hardwire_ttystate state;
 479
 480     if (get_tty_state (scb, &state))
 481       fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
 482
 483 #ifdef HAVE_TERMIOS
 484     if (timeout < 0)
 485       {
 486         /* No timeout.  */
 487         state.termios.c_cc[VTIME] = 0;
 488         state.termios.c_cc[VMIN] = 1;
 489       }
 490     else
 491       {
 492         state.termios.c_cc[VMIN] = 0;
 493         state.termios.c_cc[VTIME] = timeout * 10;
 494         if (state.termios.c_cc[VTIME] != timeout * 10)
 495           {
 496
 497             /* If c_cc is an 8-bit signed character, we can't go
 498                bigger than this.  If it is always unsigned, we could use
 499                25.  */
 500
 501             scb->current_timeout = 12;
 502             state.termios.c_cc[VTIME] = scb->current_timeout * 10;
 503             scb->timeout_remaining = timeout - scb->current_timeout;
 504           }
 505       }
 506 #endif
 507
 508 #ifdef HAVE_TERMIO
 509     if (timeout < 0)
 510       {
 511         /* No timeout.  */
 512         state.termio.c_cc[VTIME] = 0;
 513         state.termio.c_cc[VMIN] = 1;
 514       }
 515     else
 516       {
 517         state.termio.c_cc[VMIN] = 0;
 518         state.termio.c_cc[VTIME] = timeout * 10;
 519         if (state.termio.c_cc[VTIME] != timeout * 10)
 520           {
 521             /* If c_cc is an 8-bit signed character, we can't go
 522                bigger than this.  If it is always unsigned, we could use
 523                25.  */
 524
 525             scb->current_timeout = 12;
 526             state.termio.c_cc[VTIME] = scb->current_timeout * 10;
 527             scb->timeout_remaining = timeout - scb->current_timeout;
 528           }
 529       }
 530 #endif
 531
 532     if (set_tty_state (scb, &state))
 533       fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
 534
 535     return 0;
 536   }
 537 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
 538 }
 539
 540 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 541    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 542    char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
 543    dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
 544
 545 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
 546    ser_unix*() until the old TERMIOS/SGTTY/... timer code has been
 547    flushed. */
 548
 549 /* NOTE: cagney/1999-09-16: This function is not identical to
 550    ser_unix_readchar() as part of replacing it with ser_unix*()
 551    merging will be required - this code handles the case where read()
 552    times out due to no data while ser_unix_readchar() doesn't expect
 553    that. */
 554
 555 static int
 556 do_hardwire_readchar (serial_t scb, int timeout)
 557 {
 558   int status, delta;
 559   int detach = 0;
 560
 561   if (timeout > 0)
 562     timeout++;
 563
 564   /* We have to be able to keep the GUI alive here, so we break the original
 565      timeout into steps of 1 second, running the "keep the GUI alive" hook
 566      each time through the loop.
 567      Also, timeout = 0 means to poll, so we just set the delta to 0, so we
 568      will only go through the loop once. */
 569
 570   delta = (timeout == 0 ? 0 : 1);
 571   while (1)
 572     {
 573
 574       /* N.B. The UI may destroy our world (for instance by calling
 575          remote_stop,) in which case we want to get out of here as
 576          quickly as possible.  It is not safe to touch scb, since
 577          someone else might have freed it.  The ui_loop_hook signals that
 578          we should exit by returning 1. */
 579
 580       if (ui_loop_hook)
 581         detach = ui_loop_hook (0);
 582
 583       if (detach)
 584         return SERIAL_TIMEOUT;
 585
 586       scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
 587       status = wait_for (scb, delta);
 588
 589       if (status < 0)
 590         return status;
 591
 592       status = read (scb->fd, scb->buf, BUFSIZ);
 593
 594       if (status <= 0)
 595         {
 596           if (status == 0)
 597             {
 598               /* Zero characters means timeout (it could also be EOF, but
 599                  we don't (yet at least) distinguish).  */
 600               if (scb->timeout_remaining > 0)
 601                 {
 602                   timeout = scb->timeout_remaining;
 603                   continue;
 604                 }
 605               else if (scb->timeout_remaining < 0)
 606                 continue;
 607               else
 608                 return SERIAL_TIMEOUT;
 609             }
 610           else if (errno == EINTR)
 611             continue;
 612           else
 613             return SERIAL_ERROR;        /* Got an error from read */
 614         }
 615
 616       scb->bufcnt = status;
 617       scb->bufcnt--;
 618       scb->bufp = scb->buf;
 619       return *scb->bufp++;
 620     }
 621 }
 622
 623 static int
 624 hardwire_readchar (serial_t scb, int timeout)
 625 {
 626   return generic_readchar (scb, timeout, do_hardwire_readchar);
 627 }
 628
 629
 630 #ifndef B19200
 631 #define B19200 EXTA
 632 #endif
 633
 634 #ifndef B38400
 635 #define B38400 EXTB
 636 #endif
 637
 638 /* Translate baud rates from integers to damn B_codes.  Unix should
 639    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 640
 641 static struct
 642 {
 643   int rate;
 644   int code;
 645 }
 646 baudtab[] =
 647 {
 648   {
 649     50, B50
 650   }
 651   ,
 652   {
 653     75, B75
 654   }
 655   ,
 656   {
 657     110, B110
 658   }
 659   ,
 660   {
 661     134, B134
 662   }
 663   ,
 664   {
 665     150, B150
 666   }
 667   ,
 668   {
 669     200, B200
 670   }
 671   ,
 672   {
 673     300, B300
 674   }
 675   ,
 676   {
 677     600, B600
 678   }
 679   ,
 680   {
 681     1200, B1200
 682   }
 683   ,
 684   {
 685     1800, B1800
 686   }
 687   ,
 688   {
 689     2400, B2400
 690   }
 691   ,
 692   {
 693     4800, B4800
 694   }
 695   ,
 696   {
 697     9600, B9600
 698   }
 699   ,
 700   {
 701     19200, B19200
 702   }
 703   ,
 704   {
 705     38400, B38400
 706   }
 707   ,
 708 #ifdef B57600
 709   {
 710     57600, B57600
 711   }
 712   ,
 713 #endif
 714 #ifdef B115200
 715   {
 716     115200, B115200
 717   }
 718   ,
 719 #endif
 720 #ifdef B230400
 721   {
 722     230400, B230400
 723   }
 724   ,
 725 #endif
 726 #ifdef B460800
 727   {
 728     460800, B460800
 729   }
 730   ,
 731 #endif
 732   {
 733     -1, -1
 734   }
 735   ,
 736 };
 737
 738 static int
 739 rate_to_code (int rate)
 740 {
 741   int i;
 742
 743   for (i = 0; baudtab[i].rate != -1; i++)
 744     if (rate == baudtab[i].rate)
 745       return baudtab[i].code;
 746
 747   return -1;
 748 }
 749
 750 static int
 751 hardwire_setbaudrate (serial_t scb, int rate)
 752 {
 753   struct hardwire_ttystate state;
 754
 755   if (get_tty_state (scb, &state))
 756     return -1;
 757
 758 #ifdef HAVE_TERMIOS
 759   cfsetospeed (&state.termios, rate_to_code (rate));
 760   cfsetispeed (&state.termios, rate_to_code (rate));
 761 #endif
 762
 763 #ifdef HAVE_TERMIO
 764 #ifndef CIBAUD
 765 #define CIBAUD CBAUD
 766 #endif
 767
 768   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
 769   state.termio.c_cflag |= rate_to_code (rate);
 770 #endif
 771
 772 #ifdef HAVE_SGTTY
 773   state.sgttyb.sg_ispeed = rate_to_code (rate);
 774   state.sgttyb.sg_ospeed = rate_to_code (rate);
 775 #endif
 776
 777   return set_tty_state (scb, &state);
 778 }
 779
 780 static int
 781 hardwire_setstopbits (scb, num)
 782      serial_t scb;
 783      int num;
 784 {
 785   struct hardwire_ttystate state;
 786   int newbit;
 787
 788   if (get_tty_state (scb, &state))
 789     return -1;
 790
 791   switch (num)
 792     {
 793     case SERIAL_1_STOPBITS:
 794       newbit = 0;
 795       break;
 796     case SERIAL_1_AND_A_HALF_STOPBITS:
 797     case SERIAL_2_STOPBITS:
 798       newbit = 1;
 799       break;
 800     default:
 801       return 1;
 802     }
 803
 804 #ifdef HAVE_TERMIOS
 805   if (!newbit)
 806     state.termios.c_cflag &= ~CSTOPB;
 807   else
 808     state.termios.c_cflag |= CSTOPB;    /* two bits */
 809 #endif
 810
 811 #ifdef HAVE_TERMIO
 812   if (!newbit)
 813     state.termio.c_cflag &= ~CSTOPB;
 814   else
 815     state.termio.c_cflag |= CSTOPB;     /* two bits */
 816 #endif
 817
 818 #ifdef HAVE_SGTTY
 819   return 0;                     /* sgtty doesn't support this */
 820 #endif
 821
 822   return set_tty_state (scb, &state);
 823 }
 824
 825 static void
 826 hardwire_close (serial_t scb)
 827 {
 828   if (scb->fd < 0)
 829     return;
 830
 831   close (scb->fd);
 832   scb->fd = -1;
 833 }
 834
 835 \f
 836 /* Generic operations used by all UNIX/FD based serial interfaces. */
 837
 838 serial_ttystate
 839 ser_unix_nop_get_tty_state (serial_t scb)
 840 {
 841   /* allocate a dummy */
 842   return (serial_ttystate) XMALLOC (int);
 843 }
 844
 845 int
 846 ser_unix_nop_set_tty_state (serial_t scb, serial_ttystate ttystate)
 847 {
 848   return 0;
 849 }
 850
 851 void
 852 ser_unix_nop_raw (serial_t scb)
 853 {
 854   return;                       /* Always in raw mode */
 855 }
 856
 857 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 858    otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
 859
 860 int
 861 ser_unix_wait_for (serial_t scb, int timeout)
 862 {
 863   int numfds;
 864   struct timeval tv;
 865   fd_set readfds, exceptfds;
 866
 867   FD_ZERO (&readfds);
 868   FD_ZERO (&exceptfds);
 869
 870   tv.tv_sec = timeout;
 871   tv.tv_usec = 0;
 872
 873   FD_SET (scb->fd, &readfds);
 874   FD_SET (scb->fd, &exceptfds);
 875
 876   while (1)
 877     {
 878       if (timeout >= 0)
 879         numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
 880       else
 881         numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
 882
 883       if (numfds <= 0)
 884         {
 885           if (numfds == 0)
 886             return SERIAL_TIMEOUT;
 887           else if (errno == EINTR)
 888             continue;
 889           else
 890             return SERIAL_ERROR;        /* Got an error from select or poll */
 891         }
 892
 893       return 0;
 894     }
 895 }
 896
 897 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 898    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 899    char if successful.  Returns -2 if timeout expired, EOF if line dropped
 900    dead, or -3 for any other error (see errno in that case). */
 901
 902 static int
 903 do_unix_readchar (serial_t scb, int timeout)
 904 {
 905   int status;
 906   int delta;
 907
 908   /* We have to be able to keep the GUI alive here, so we break the original
 909      timeout into steps of 1 second, running the "keep the GUI alive" hook
 910      each time through the loop.
 911
 912      Also, timeout = 0 means to poll, so we just set the delta to 0, so we
 913      will only go through the loop once. timeout < 0 means to wait forever. */
 914
 915   delta = (timeout <= 0 ? 0 : 1);
 916   while (1)
 917     {
 918
 919       /* N.B. The UI may destroy our world (for instance by calling
 920          remote_stop,) in which case we want to get out of here as
 921          quickly as possible.  It is not safe to touch scb, since
 922          someone else might have freed it.  The ui_loop_hook signals that
 923          we should exit by returning 1. */
 924
 925       if (ui_loop_hook)
 926         {
 927           if (ui_loop_hook (0))
 928             return SERIAL_TIMEOUT;
 929         }
 930
 931       status = ser_unix_wait_for (scb, timeout < 0 ? timeout : delta);
 932       timeout -= delta;
 933
 934       /* If we got an error back from wait_for, then we can return */
 935
 936       if (status == SERIAL_ERROR)
 937         return status;
 938
 939       status = read (scb->fd, scb->buf, BUFSIZ);
 940
 941       if (status <= 0)
 942         {
 943           if (status == 0)
 944             {
 945               if (timeout != 0)
 946                 continue;
 947               else
 948                 return SERIAL_TIMEOUT;  /* 0 chars means timeout [may need to
 949                                            distinguish between EOF & timeouts
 950                                            someday] */
 951             }
 952           else if (errno == EINTR)
 953             continue;
 954           else
 955             return SERIAL_ERROR;        /* Got an error from read */
 956         }
 957
 958       scb->bufcnt = status;
 959       scb->bufcnt--;
 960       scb->bufp = scb->buf;
 961       return *scb->bufp++;
 962     }
 963 }
 964
 965 /* Perform operations common to both old and new readchar. */
 966
 967 /* Return the next character from the input FIFO.  If the FIFO is
 968    empty, call the SERIAL specific routine to try and read in more
 969    characters.
 970
 971    Initially data from the input FIFO is returned (fd_event()
 972    pre-reads the input into that FIFO.  Once that has been emptied,
 973    further data is obtained by polling the input FD using the device
 974    specific readchar() function.  Note: reschedule() is called after
 975    every read.  This is because there is no guarentee that the lower
 976    level fd_event() poll_event() code (which also calls reschedule())
 977    will be called. */
 978
 979 static int
 980 generic_readchar (serial_t scb, int timeout,
 981                   int (do_readchar) (serial_t scb, int timeout))
 982 {
 983   int ch;
 984   if (scb->bufcnt > 0)
 985     {
 986       ch = *scb->bufp;
 987       scb->bufcnt--;
 988       scb->bufp++;
 989     }
 990   else if (scb->bufcnt < 0)
 991     {
 992       /* Some errors/eof are are sticky. */
 993       ch = scb->bufcnt;
 994     }
 995   else
 996     {
 997       ch = do_readchar (scb, timeout);
 998       if (ch < 0)
 999         {
1000           switch ((enum serial_rc) ch)
1001             {
1002             case SERIAL_EOF:
1003             case SERIAL_ERROR:
1004               /* Make the error/eof stick. */
1005               scb->bufcnt = ch;
1006               break;
1007             case SERIAL_TIMEOUT:
1008               scb->bufcnt = 0;
1009               break;
1010             }
1011         }
1012     }
1013   reschedule (scb);
1014   return ch;
1015 }
1016
1017 int
1018 ser_unix_readchar (serial_t scb, int timeout)
1019 {
1020   return generic_readchar (scb, timeout, do_unix_readchar);
1021 }
1022
1023 int
1024 ser_unix_nop_noflush_set_tty_state (serial_t scb,
1025                                     serial_ttystate new_ttystate,
1026                                     serial_ttystate old_ttystate)
1027 {
1028   return 0;
1029 }
1030
1031 void
1032 ser_unix_nop_print_tty_state (serial_t scb,
1033                               serial_ttystate ttystate,
1034                               struct ui_file *stream)
1035 {
1036   /* Nothing to print.  */
1037   return;
1038 }
1039
1040 int
1041 ser_unix_nop_setbaudrate (serial_t scb, int rate)
1042 {
1043   return 0;                     /* Never fails! */
1044 }
1045
1046 int
1047 ser_unix_nop_setstopbits (serial_t scb, int num)
1048 {
1049   return 0;                     /* Never fails! */
1050 }
1051
1052 int
1053 ser_unix_write (serial_t scb, const char *str, int len)
1054 {
1055   int cc;
1056
1057   while (len > 0)
1058     {
1059       cc = write (scb->fd, str, len);
1060
1061       if (cc < 0)
1062         return 1;
1063       len -= cc;
1064       str += cc;
1065     }
1066   return 0;
1067 }
1068
1069 int
1070 ser_unix_nop_flush_output (serial_t scb)
1071 {
1072   return 0;
1073 }
1074
1075 int
1076 ser_unix_flush_input (serial_t scb)
1077 {
1078   if (scb->bufcnt >= 0)
1079     {
1080       scb->bufcnt = 0;
1081       scb->bufp = scb->buf;
1082       return 0;
1083     }
1084   else
1085     return SERIAL_ERROR;
1086 }
1087
1088 int
1089 ser_unix_nop_send_break (serial_t scb)
1090 {
1091   return 0;
1092 }
1093
1094 int
1095 ser_unix_nop_drain_output (serial_t scb)
1096 {
1097   return 0;
1098 }
1099
1100
1101 \f
1102 /* Event handling for ASYNC serial code.
1103
1104    At any time the SERIAL device either: has an empty FIFO and is
1105    waiting on a FD event; or has a non-empty FIFO/error condition and
1106    is constantly scheduling timer events.
1107
1108    ASYNC only stops pestering its client when it is de-async'ed or it
1109    is told to go away. */
1110
1111 /* Value of scb->async_state: */
1112 enum {
1113   /* >= 0 (TIMER_SCHEDULED) */
1114   /* The ID of the currently scheduled timer event. This state is
1115      rarely encountered.  Timer events are one-off so as soon as the
1116      event is delivered the state is shanged to NOTHING_SCHEDULED. */
1117   FD_SCHEDULED = -1,
1118   /* The fd_event() handler is scheduled.  It is called when ever the
1119      file descriptor becomes ready. */
1120   NOTHING_SCHEDULED = -2
1121   /* Either no task is scheduled (just going into ASYNC mode) or a
1122      timer event has just gone off and the current state has been
1123      forced into nothing scheduled. */
1124 };
1125
1126 /* Identify and schedule the next ASYNC task based on scb->async_state
1127    and scb->buf* (the input FIFO).  A state machine is used to avoid
1128    the need to make redundant calls into the event-loop - the next
1129    scheduled task is only changed when needed. */
1130
1131 static void
1132 reschedule (serial_t scb)
1133 {
1134   if (SERIAL_IS_ASYNC_P (scb))
1135     {
1136       int next_state;
1137       switch (scb->async_state)
1138         {
1139         case FD_SCHEDULED:
1140           if (scb->bufcnt == 0)
1141             next_state = FD_SCHEDULED;
1142           else
1143             {
1144               delete_file_handler (scb->fd);
1145               next_state = create_timer (0, push_event, scb);
1146             }
1147           break;
1148         case NOTHING_SCHEDULED:
1149           if (scb->bufcnt == 0)
1150             {
1151               add_file_handler (scb->fd, fd_event, scb);
1152               next_state = FD_SCHEDULED;
1153             }
1154           else
1155             {
1156               next_state = create_timer (0, push_event, scb);
1157             }
1158           break;
1159         default: /* TIMER SCHEDULED */
1160           if (scb->bufcnt == 0)
1161             {
1162               delete_timer (scb->async_state);
1163               add_file_handler (scb->fd, fd_event, scb);
1164               next_state = FD_SCHEDULED;
1165             }
1166           else
1167             next_state = scb->async_state;
1168           break;
1169         }
1170       if (SERIAL_DEBUG_P (scb))
1171         {
1172           switch (next_state)
1173             {
1174             case FD_SCHEDULED:
1175               if (scb->async_state != FD_SCHEDULED)
1176                 fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
1177                                     scb->fd);
1178               break;
1179             default: /* TIMER SCHEDULED */
1180               if (scb->async_state == FD_SCHEDULED)
1181                 fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
1182                                     scb->fd);
1183               break;
1184             }
1185         }
1186       scb->async_state = next_state;
1187     }
1188 }
1189
1190 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
1191    is no pending error).  As soon as data arrives, it is read into the
1192    input FIFO and the client notified.  The client should then drain
1193    the FIFO using readchar().  If the FIFO isn't immediatly emptied,
1194    push_event() is used to nag the client until it is. */
1195
1196 static void
1197 fd_event (int error, void *context)
1198 {
1199   serial_t scb = context;
1200   if (error != 0)
1201     {
1202       scb->bufcnt = SERIAL_ERROR;
1203     }
1204   else if (scb->bufcnt == 0)
1205     {
1206       /* Prime the input FIFO.  The readchar() function is used to
1207          pull characters out of the buffer.  See also
1208          generic_readchar(). */
1209       int nr;
1210       do
1211         {
1212           nr = read (scb->fd, scb->buf, BUFSIZ);
1213         }
1214       while (nr == -1 && errno == EINTR);
1215       if (nr == 0)
1216         {
1217           scb->bufcnt = SERIAL_EOF;
1218         }
1219       else if (nr > 0)
1220         {
1221           scb->bufcnt = nr;
1222           scb->bufp = scb->buf;
1223         }
1224       else
1225         {
1226           scb->bufcnt = SERIAL_ERROR;
1227         }
1228     }
1229   scb->async_handler (scb, scb->async_context);
1230   reschedule (scb);
1231 }
1232
1233 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
1234    error).  Nag the client until all the data has been read.  In the
1235    case of errors, the client will need to close or de-async the
1236    device before naging stops. */
1237
1238 static void
1239 push_event (void *context)
1240 {
1241   serial_t scb = context;
1242   scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
1243   scb->async_handler (scb, scb->async_context);
1244   /* re-schedule */
1245   reschedule (scb);
1246 }
1247
1248 /* Put the SERIAL device into/out-of ASYNC mode.  */
1249
1250 void
1251 ser_unix_async (serial_t scb,
1252                 int async_p)
1253 {
1254   if (async_p)
1255     {
1256       /* Force a re-schedule. */
1257       scb->async_state = NOTHING_SCHEDULED;
1258       if (SERIAL_DEBUG_P (scb))
1259         fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
1260                             scb->fd);
1261       reschedule (scb);
1262     }
1263   else
1264     {
1265       if (SERIAL_DEBUG_P (scb))
1266         fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
1267                             scb->fd);
1268       /* De-schedule what ever tasks are currently scheduled. */
1269       switch (scb->async_state)
1270         {
1271         case FD_SCHEDULED:
1272           delete_file_handler (scb->fd);
1273           break;
1274         NOTHING_SCHEDULED:
1275           break;
1276         default: /* TIMER SCHEDULED */
1277           delete_timer (scb->async_state);
1278           break;
1279         }
1280     }
1281 }
1282
1283 void
1284 _initialize_ser_hardwire (void)
1285 {
1286   struct serial_ops *ops = XMALLOC (struct serial_ops);
1287   memset (ops, sizeof (struct serial_ops), 0);
1288   ops->name = "hardwire";
1289   ops->next = 0;
1290   ops->open = hardwire_open;
1291   ops->close = hardwire_close;
1292   /* FIXME: Don't replace this with the equivalent ser_unix*() until
1293      the old TERMIOS/SGTTY/... timer code has been flushed. cagney
1294      1999-09-16. */
1295   ops->readchar = hardwire_readchar;
1296   ops->write = ser_unix_write;
1297   ops->flush_output = hardwire_flush_output;
1298   ops->flush_input = hardwire_flush_input;
1299   ops->send_break = hardwire_send_break;
1300   ops->go_raw = hardwire_raw;
1301   ops->get_tty_state = hardwire_get_tty_state;
1302   ops->set_tty_state = hardwire_set_tty_state;
1303   ops->print_tty_state = hardwire_print_tty_state;
1304   ops->noflush_set_tty_state = hardwire_noflush_set_tty_state;
1305   ops->setbaudrate = hardwire_setbaudrate;
1306   ops->setstopbits = hardwire_setstopbits;
1307   ops->drain_output = hardwire_drain_output;
1308   ops->async = ser_unix_async;
1309   serial_add_interface (ops);
1310 }