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 (serial_t scb, int num)
 782 {
 783   struct hardwire_ttystate state;
 784   int newbit;
 785
 786   if (get_tty_state (scb, &state))
 787     return -1;
 788
 789   switch (num)
 790     {
 791     case SERIAL_1_STOPBITS:
 792       newbit = 0;
 793       break;
 794     case SERIAL_1_AND_A_HALF_STOPBITS:
 795     case SERIAL_2_STOPBITS:
 796       newbit = 1;
 797       break;
 798     default:
 799       return 1;
 800     }
 801
 802 #ifdef HAVE_TERMIOS
 803   if (!newbit)
 804     state.termios.c_cflag &= ~CSTOPB;
 805   else
 806     state.termios.c_cflag |= CSTOPB;    /* two bits */
 807 #endif
 808
 809 #ifdef HAVE_TERMIO
 810   if (!newbit)
 811     state.termio.c_cflag &= ~CSTOPB;
 812   else
 813     state.termio.c_cflag |= CSTOPB;     /* two bits */
 814 #endif
 815
 816 #ifdef HAVE_SGTTY
 817   return 0;                     /* sgtty doesn't support this */
 818 #endif
 819
 820   return set_tty_state (scb, &state);
 821 }
 822
 823 static void
 824 hardwire_close (serial_t scb)
 825 {
 826   if (scb->fd < 0)
 827     return;
 828
 829   close (scb->fd);
 830   scb->fd = -1;
 831 }
 832
 833 \f
 834 /* Generic operations used by all UNIX/FD based serial interfaces. */
 835
 836 serial_ttystate
 837 ser_unix_nop_get_tty_state (serial_t scb)
 838 {
 839   /* allocate a dummy */
 840   return (serial_ttystate) XMALLOC (int);
 841 }
 842
 843 int
 844 ser_unix_nop_set_tty_state (serial_t scb, serial_ttystate ttystate)
 845 {
 846   return 0;
 847 }
 848
 849 void
 850 ser_unix_nop_raw (serial_t scb)
 851 {
 852   return;                       /* Always in raw mode */
 853 }
 854
 855 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 856    otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
 857
 858 int
 859 ser_unix_wait_for (serial_t scb, int timeout)
 860 {
 861   int numfds;
 862   struct timeval tv;
 863   fd_set readfds, exceptfds;
 864
 865   FD_ZERO (&readfds);
 866   FD_ZERO (&exceptfds);
 867
 868   tv.tv_sec = timeout;
 869   tv.tv_usec = 0;
 870
 871   FD_SET (scb->fd, &readfds);
 872   FD_SET (scb->fd, &exceptfds);
 873
 874   while (1)
 875     {
 876       if (timeout >= 0)
 877         numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
 878       else
 879         numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
 880
 881       if (numfds <= 0)
 882         {
 883           if (numfds == 0)
 884             return SERIAL_TIMEOUT;
 885           else if (errno == EINTR)
 886             continue;
 887           else
 888             return SERIAL_ERROR;        /* Got an error from select or poll */
 889         }
 890
 891       return 0;
 892     }
 893 }
 894
 895 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 896    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 897    char if successful.  Returns -2 if timeout expired, EOF if line dropped
 898    dead, or -3 for any other error (see errno in that case). */
 899
 900 static int
 901 do_unix_readchar (serial_t scb, int timeout)
 902 {
 903   int status;
 904   int delta;
 905
 906   /* We have to be able to keep the GUI alive here, so we break the original
 907      timeout into steps of 1 second, running the "keep the GUI alive" hook
 908      each time through the loop.
 909
 910      Also, timeout = 0 means to poll, so we just set the delta to 0, so we
 911      will only go through the loop once. */
 912
 913   delta = (timeout == 0 ? 0 : 1);
 914   while (1)
 915     {
 916
 917       /* N.B. The UI may destroy our world (for instance by calling
 918          remote_stop,) in which case we want to get out of here as
 919          quickly as possible.  It is not safe to touch scb, since
 920          someone else might have freed it.  The ui_loop_hook signals that
 921          we should exit by returning 1. */
 922
 923       if (ui_loop_hook)
 924         {
 925           if (ui_loop_hook (0))
 926             return SERIAL_TIMEOUT;
 927         }
 928
 929       status = ser_unix_wait_for (scb, delta);
 930       timeout -= delta;
 931
 932       /* If we got a character or an error back from wait_for, then we can
 933          break from the loop before the timeout is completed. */
 934
 935       if (status != SERIAL_TIMEOUT)
 936         {
 937           break;
 938         }
 939
 940       /* If we have exhausted the original timeout, then generate
 941          a SERIAL_TIMEOUT, and pass it out of the loop. */
 942
 943       else if (timeout == 0)
 944         {
 945           status = SERIAL_TIMEOUT;
 946           break;
 947         }
 948     }
 949
 950   if (status < 0)
 951     return status;
 952
 953   while (1)
 954     {
 955       status = read (scb->fd, scb->buf, BUFSIZ);
 956       if (status != -1 || errno != EINTR)
 957         break;
 958     }
 959
 960   if (status <= 0)
 961     {
 962       if (status == 0)
 963         return SERIAL_TIMEOUT;  /* 0 chars means timeout [may need to
 964                                    distinguish between EOF & timeouts
 965                                    someday] */
 966       else
 967         return SERIAL_ERROR;    /* Got an error from read */
 968     }
 969
 970   scb->bufcnt = status;
 971   scb->bufcnt--;
 972   scb->bufp = scb->buf;
 973   return *scb->bufp++;
 974 }
 975
 976 /* Perform operations common to both old and new readchar. */
 977
 978 /* Return the next character from the input FIFO.  If the FIFO is
 979    empty, call the SERIAL specific routine to try and read in more
 980    characters.
 981
 982    Initially data from the input FIFO is returned (fd_event()
 983    pre-reads the input into that FIFO.  Once that has been emptied,
 984    further data is obtained by polling the input FD using the device
 985    specific readchar() function.  Note: reschedule() is called after
 986    every read.  This is because there is no guarentee that the lower
 987    level fd_event() poll_event() code (which also calls reschedule())
 988    will be called. */
 989
 990 static int
 991 generic_readchar (serial_t scb, int timeout,
 992                   int (do_readchar) (serial_t scb, int timeout))
 993 {
 994   int ch;
 995   if (scb->bufcnt > 0)
 996     {
 997       ch = *scb->bufp;
 998       scb->bufcnt--;
 999       scb->bufp++;
1000     }
1001   else if (scb->bufcnt < 0)
1002     {
1003       /* Some errors/eof are are sticky. */
1004       ch = scb->bufcnt;
1005     }
1006   else
1007     {
1008       ch = do_readchar (scb, timeout);
1009       if (ch < 0)
1010         {
1011           switch ((enum serial_rc) ch)
1012             {
1013             case SERIAL_EOF:
1014             case SERIAL_ERROR:
1015               /* Make the error/eof stick. */
1016               scb->bufcnt = ch;
1017               break;
1018             case SERIAL_TIMEOUT:
1019               scb->bufcnt = 0;
1020               break;
1021             }
1022         }
1023     }
1024   reschedule (scb);
1025   return ch;
1026 }
1027
1028 int
1029 ser_unix_readchar (serial_t scb, int timeout)
1030 {
1031   return generic_readchar (scb, timeout, do_unix_readchar);
1032 }
1033
1034 int
1035 ser_unix_nop_noflush_set_tty_state (serial_t scb,
1036                                     serial_ttystate new_ttystate,
1037                                     serial_ttystate old_ttystate)
1038 {
1039   return 0;
1040 }
1041
1042 void
1043 ser_unix_nop_print_tty_state (serial_t scb,
1044                               serial_ttystate ttystate,
1045                               struct ui_file *stream)
1046 {
1047   /* Nothing to print.  */
1048   return;
1049 }
1050
1051 int
1052 ser_unix_nop_setbaudrate (serial_t scb, int rate)
1053 {
1054   return 0;                     /* Never fails! */
1055 }
1056
1057 int
1058 ser_unix_nop_setstopbits (serial_t scb, int num)
1059 {
1060   return 0;                     /* Never fails! */
1061 }
1062
1063 int
1064 ser_unix_write (serial_t scb, const char *str, int len)
1065 {
1066   int cc;
1067
1068   while (len > 0)
1069     {
1070       cc = write (scb->fd, str, len);
1071
1072       if (cc < 0)
1073         return 1;
1074       len -= cc;
1075       str += cc;
1076     }
1077   return 0;
1078 }
1079
1080 int
1081 ser_unix_nop_flush_output (serial_t scb)
1082 {
1083   return 0;
1084 }
1085
1086 int
1087 ser_unix_flush_input (serial_t scb)
1088 {
1089   if (scb->bufcnt >= 0)
1090     {
1091       scb->bufcnt = 0;
1092       scb->bufp = scb->buf;
1093       return 0;
1094     }
1095   else
1096     return SERIAL_ERROR;
1097 }
1098
1099 int
1100 ser_unix_nop_send_break (serial_t scb)
1101 {
1102   return 0;
1103 }
1104
1105 int
1106 ser_unix_nop_drain_output (serial_t scb)
1107 {
1108   return 0;
1109 }
1110
1111
1112 \f
1113 /* Event handling for ASYNC serial code.
1114
1115    At any time the SERIAL device either: has an empty FIFO and is
1116    waiting on a FD event; or has a non-empty FIFO/error condition and
1117    is constantly scheduling timer events.
1118
1119    ASYNC only stops pestering its client when it is de-async'ed or it
1120    is told to go away. */
1121
1122 /* Value of scb->async_state: */
1123 enum {
1124   /* >= 0 (TIMER_SCHEDULED) */
1125   /* The ID of the currently scheduled timer event. This state is
1126      rarely encountered.  Timer events are one-off so as soon as the
1127      event is delivered the state is shanged to NOTHING_SCHEDULED. */
1128   FD_SCHEDULED = -1,
1129   /* The fd_event() handler is scheduled.  It is called when ever the
1130      file descriptor becomes ready. */
1131   NOTHING_SCHEDULED = -2
1132   /* Either no task is scheduled (just going into ASYNC mode) or a
1133      timer event has just gone off and the current state has been
1134      forced into nothing scheduled. */
1135 };
1136
1137 /* Identify and schedule the next ASYNC task based on scb->async_state
1138    and scb->buf* (the input FIFO).  A state machine is used to avoid
1139    the need to make redundant calls into the event-loop - the next
1140    scheduled task is only changed when needed. */
1141
1142 static void
1143 reschedule (serial_t scb)
1144 {
1145   if (SERIAL_IS_ASYNC_P (scb))
1146     {
1147       int next_state;
1148       switch (scb->async_state)
1149         {
1150         case FD_SCHEDULED:
1151           if (scb->bufcnt == 0)
1152             next_state = FD_SCHEDULED;
1153           else
1154             {
1155               delete_file_handler (scb->fd);
1156               next_state = create_timer (0, push_event, scb);
1157             }
1158           break;
1159         case NOTHING_SCHEDULED:
1160           if (scb->bufcnt == 0)
1161             {
1162               add_file_handler (scb->fd, fd_event, scb);
1163               next_state = FD_SCHEDULED;
1164             }
1165           else
1166             {
1167               next_state = create_timer (0, push_event, scb);
1168             }
1169           break;
1170         default: /* TIMER SCHEDULED */
1171           if (scb->bufcnt == 0)
1172             {
1173               delete_timer (scb->async_state);
1174               add_file_handler (scb->fd, fd_event, scb);
1175               next_state = FD_SCHEDULED;
1176             }
1177           else
1178             next_state = scb->async_state;
1179           break;
1180         }
1181       if (SERIAL_DEBUG_P (scb))
1182         {
1183           switch (next_state)
1184             {
1185             case FD_SCHEDULED:
1186               if (scb->async_state != FD_SCHEDULED)
1187                 fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
1188                                     scb->fd);
1189               break;
1190             default: /* TIMER SCHEDULED */
1191               if (scb->async_state == FD_SCHEDULED)
1192                 fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
1193                                     scb->fd);
1194               break;
1195             }
1196         }
1197       scb->async_state = next_state;
1198     }
1199 }
1200
1201 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
1202    is no pending error).  As soon as data arrives, it is read into the
1203    input FIFO and the client notified.  The client should then drain
1204    the FIFO using readchar().  If the FIFO isn't immediatly emptied,
1205    push_event() is used to nag the client until it is. */
1206
1207 static void
1208 fd_event (int error, void *context)
1209 {
1210   serial_t scb = context;
1211   if (error != 0)
1212     {
1213       scb->bufcnt = SERIAL_ERROR;
1214     }
1215   else if (scb->bufcnt == 0)
1216     {
1217       /* Prime the input FIFO.  The readchar() function is used to
1218          pull characters out of the buffer.  See also
1219          generic_readchar(). */
1220       int nr;
1221       do
1222         {
1223           nr = read (scb->fd, scb->buf, BUFSIZ);
1224         }
1225       while (nr == -1 && errno == EINTR);
1226       if (nr == 0)
1227         {
1228           scb->bufcnt = SERIAL_EOF;
1229         }
1230       else if (nr > 0)
1231         {
1232           scb->bufcnt = nr;
1233           scb->bufp = scb->buf;
1234         }
1235       else
1236         {
1237           scb->bufcnt = SERIAL_ERROR;
1238         }
1239     }
1240   scb->async_handler (scb, scb->async_context);
1241   reschedule (scb);
1242 }
1243
1244 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
1245    error).  Nag the client until all the data has been read.  In the
1246    case of errors, the client will need to close or de-async the
1247    device before naging stops. */
1248
1249 static void
1250 push_event (void *context)
1251 {
1252   serial_t scb = context;
1253   scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
1254   scb->async_handler (scb, scb->async_context);
1255   /* re-schedule */
1256   reschedule (scb);
1257 }
1258
1259 /* Put the SERIAL device into/out-of ASYNC mode.  */
1260
1261 void
1262 ser_unix_async (serial_t scb,
1263                 int async_p)
1264 {
1265   if (async_p)
1266     {
1267       /* Force a re-schedule. */
1268       scb->async_state = NOTHING_SCHEDULED;
1269       if (SERIAL_DEBUG_P (scb))
1270         fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
1271                             scb->fd);
1272       reschedule (scb);
1273     }
1274   else
1275     {
1276       if (SERIAL_DEBUG_P (scb))
1277         fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
1278                             scb->fd);
1279       /* De-schedule what ever tasks are currently scheduled. */
1280       switch (scb->async_state)
1281         {
1282         case FD_SCHEDULED:
1283           delete_file_handler (scb->fd);
1284           break;
1285         NOTHING_SCHEDULED:
1286           break;
1287         default: /* TIMER SCHEDULED */
1288           delete_timer (scb->async_state);
1289           break;
1290         }
1291     }
1292 }
1293
1294 void
1295 _initialize_ser_hardwire (void)
1296 {
1297   struct serial_ops *ops = XMALLOC (struct serial_ops);
1298   memset (ops, sizeof (struct serial_ops), 0);
1299   ops->name = "hardwire";
1300   ops->next = 0;
1301   ops->open = hardwire_open;
1302   ops->close = hardwire_close;
1303   /* FIXME: Don't replace this with the equivalent ser_unix*() until
1304      the old TERMIOS/SGTTY/... timer code has been flushed. cagney
1305      1999-09-16. */
1306   ops->readchar = hardwire_readchar;
1307   ops->write = ser_unix_write;
1308   ops->flush_output = hardwire_flush_output;
1309   ops->flush_input = hardwire_flush_input;
1310   ops->send_break = hardwire_send_break;
1311   ops->go_raw = hardwire_raw;
1312   ops->get_tty_state = hardwire_get_tty_state;
1313   ops->set_tty_state = hardwire_set_tty_state;
1314   ops->print_tty_state = hardwire_print_tty_state;
1315   ops->noflush_set_tty_state = hardwire_noflush_set_tty_state;
1316   ops->setbaudrate = hardwire_setbaudrate;
1317   ops->setstopbits = hardwire_setstopbits;
1318   ops->drain_output = hardwire_drain_output;
1319   ops->async = ser_unix_async;
1320   serial_add_interface (ops);
1321 }