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