← Back to branch summary

~ubuntu-branches/ubuntu/karmic/insight/karmic

« back to all changes in this revision

Viewing changes to gdb/ser-mingw.c

  • Committer: Bazaar Package Importer
  • Author(s): Masayuki Hatta (mhatta)
  • Date: 2007-12-04 22:37:09 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20071204223709-jxj396d1ox92s8ox
Tags: 6.7.1.dfsg.1-1
http://bugs.debian.org/314037
* New upstream release.
* This typo has been fixed in the upstream - closes: #314037.
* Removed non-free documents (GFDL'd with Invariant Sections, etc.).

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdb/ser-mingw.c
1
1
/* Serial interface for local (hardwired) serial ports on Windows systems
2
2
 
3
 
   Copyright (C) 2006
4
 
   Free Software Foundation, Inc.
 
3
   Copyright (C) 2006, 2007 Free Software Foundation, Inc.
5
4
 
6
5
   This file is part of GDB.
7
6
 
8
7
   This program is free software; you can redistribute it and/or modify
9
8
   it under the terms of the GNU General Public License as published by
10
 
   the Free Software Foundation; either version 2 of the License, or
 
9
   the Free Software Foundation; either version 3 of the License, or
11
10
   (at your option) any later version.
12
11
 
13
12
   This program is distributed in the hope that it will be useful,
16
15
   GNU General Public License for more details.
17
16
 
18
17
   You should have received a copy of the GNU General Public License
19
 
   along with this program; if not, write to the Free Software
20
 
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
21
 
   Boston, MA 02110-1301, USA.  */
 
18
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
19
 
23
20
#include "defs.h"
24
21
#include "serial.h"
454
451
    return 0;
455
452
}
456
453
 
 
454
static int
 
455
fd_is_file (int fd)
 
456
{
 
457
  if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
 
458
    return 1;
 
459
  else
 
460
    return 0;
 
461
}
 
462
 
457
463
static DWORD WINAPI
458
464
pipe_select_thread (void *arg)
459
465
{
502
508
    }
503
509
}
504
510
 
 
511
static DWORD WINAPI
 
512
file_select_thread (void *arg)
 
513
{
 
514
  struct serial *scb = arg;
 
515
  struct ser_console_state *state;
 
516
  int event_index;
 
517
  HANDLE h;
 
518
 
 
519
  state = scb->state;
 
520
  h = (HANDLE) _get_osfhandle (scb->fd);
 
521
 
 
522
  while (1)
 
523
    {
 
524
      HANDLE wait_events[2];
 
525
      DWORD n_avail;
 
526
 
 
527
      SetEvent (state->have_stopped);
 
528
 
 
529
      wait_events[0] = state->start_select;
 
530
      wait_events[1] = state->exit_select;
 
531
 
 
532
      if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
 
533
        return 0;
 
534
 
 
535
      ResetEvent (state->have_stopped);
 
536
 
 
537
      if (SetFilePointer (h, 0, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
 
538
        {
 
539
          SetEvent (state->except_event);
 
540
          continue;
 
541
        }
 
542
 
 
543
      SetEvent (state->read_event);
 
544
    }
 
545
}
 
546
 
505
547
static void
506
548
ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
507
549
{
513
555
      int is_tty;
514
556
 
515
557
      is_tty = isatty (scb->fd);
516
 
      if (!is_tty && !fd_is_pipe (scb->fd))
 
558
      if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
517
559
        {
518
560
          *read = NULL;
519
561
          *except = NULL;
542
584
      if (is_tty)
543
585
        state->thread = CreateThread (NULL, 0, console_select_thread, scb, 0,
544
586
                                      &threadId);
 
587
      else if (fd_is_pipe (scb->fd))
 
588
        state->thread = CreateThread (NULL, 0, pipe_select_thread, scb, 0,
 
589
                                      &threadId);
545
590
      else
546
 
        state->thread = CreateThread (NULL, 0, pipe_select_thread, scb, 0,
 
591
        state->thread = CreateThread (NULL, 0, file_select_thread, scb, 0,
547
592
                                      &threadId);
548
593
    }
549
594
 
697
742
static int
698
743
pipe_windows_open (struct serial *scb, const char *name)
699
744
{
 
745
  struct pipe_state *ps;
 
746
  FILE *pex_stderr;
 
747
 
700
748
  char **argv = buildargv (name);
701
749
  struct cleanup *back_to = make_cleanup_freeargv (argv);
702
750
  if (! argv[0] || argv[0][0] == '\0')
703
751
    error ("missing child command");
704
752
 
705
 
  struct pipe_state *ps = make_pipe_state ();
 
753
 
 
754
  ps = make_pipe_state ();
706
755
  make_cleanup (cleanup_pipe_state, ps);
707
756
 
708
757
  ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL);
715
764
  {
716
765
    int err;
717
766
    const char *err_msg
718
 
      = pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT,
 
767
      = pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT
 
768
                 | PEX_STDERR_TO_PIPE,
719
769
                 argv[0], argv, NULL, NULL,
720
770
                 &err);
721
771
 
737
787
  ps->output = pex_read_output (ps->pex, 1);
738
788
  if (! ps->output)
739
789
    goto fail;
740
 
 
741
790
  scb->fd = fileno (ps->output);
 
791
 
 
792
  pex_stderr = pex_read_err (ps->pex, 1);
 
793
  if (! pex_stderr)
 
794
    goto fail;
 
795
  scb->error_fd = fileno (pex_stderr);
 
796
 
742
797
  scb->state = (void *) ps;
743
798
 
744
799
  discard_cleanups (back_to);
767
822
pipe_windows_read (struct serial *scb, size_t count)
768
823
{
769
824
  HANDLE pipeline_out = (HANDLE) _get_osfhandle (scb->fd);
 
825
  DWORD available;
 
826
  DWORD bytes_read;
 
827
 
770
828
  if (pipeline_out == INVALID_HANDLE_VALUE)
771
829
    return -1;
772
830
 
773
 
  DWORD available;
774
831
  if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
775
832
    return -1;
776
833
 
777
834
  if (count > available)
778
835
    count = available;
779
836
 
780
 
  DWORD bytes_read;
781
837
  if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
782
838
    return -1;
783
839
 
789
845
pipe_windows_write (struct serial *scb, const void *buf, size_t count)
790
846
{
791
847
  struct pipe_state *ps = scb->state;
 
848
  HANDLE pipeline_in;
 
849
  DWORD written;
 
850
 
792
851
  int pipeline_in_fd = fileno (ps->input);
793
852
  if (pipeline_in_fd < 0)
794
853
    return -1;
795
854
 
796
 
  HANDLE pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
 
855
  pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
797
856
  if (pipeline_in == INVALID_HANDLE_VALUE)
798
857
    return -1;
799
858
 
800
 
  DWORD written;
801
859
  if (! WriteFile (pipeline_in, buf, count, &written, NULL))
802
860
    return -1;
803
861
 
860
918
  WaitForSingleObject (ps->wait.have_stopped, INFINITE);
861
919
}
862
920
 
 
921
static int
 
922
pipe_avail (struct serial *scb, int fd)
 
923
{
 
924
  HANDLE h = (HANDLE) _get_osfhandle (fd);
 
925
  DWORD numBytes;
 
926
  BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
 
927
  if (r == FALSE)
 
928
    numBytes = 0;
 
929
  return numBytes;
 
930
}
 
931
 
863
932
struct net_windows_state
864
933
{
865
934
  HANDLE read_event;
1159
1228
  ops->write_prim = pipe_windows_write;
1160
1229
  ops->wait_handle = pipe_wait_handle;
1161
1230
  ops->done_wait_handle = pipe_done_wait_handle;
 
1231
  ops->avail = pipe_avail;
1162
1232
 
1163
1233
  serial_add_interface (ops);
1164
1234