aboutsummaryrefslogtreecommitdiff
path: root/winsup/cygwin/fhandler_windows.cc
blob: 7a5870f647ce8e6e34fb2706d7268f9143c45e08 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
/* fhandler_windows.cc: code to access windows message queues.

   Copyright 1998, 1999, 2000, 2001 Red Hat, Inc.

   Written by Sergey S. Okhapkin (sos@prospect.com.ru).
   Feedback and testing by Andy Piper (andyp@parallax.co.uk).

This file is part of Cygwin.

This software is a copyrighted work licensed under the terms of the
Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
details. */

#include "winsup.h"
#include <errno.h>
#include <wingdi.h>
#include <winuser.h>
#include "cygerrno.h"
#include "security.h"
#include "fhandler.h"

/*
The following unix-style calls are supported:

	open ("/dev/windows", flags, mode=0)
		- create a unix fd for message queue.
		  O_NONBLOCK flag controls the read() call behavior.

	read (fd, buf, len)
		- return next message from queue. buf must point to MSG
		  structure, len must be >= sizeof (MSG). If read is set to
		  non-blocking and the queue is empty, read call returns -1
		  immediately with errno set to EAGAIN, otherwise it blocks
		  untill the message will be received.

	write (fd, buf, len)
		- send a message pointed by buf. len argument ignored.

	ioctl (fd, command, *param)
		- control read()/write() behavior.
		ioctl (fd, WINDOWS_POST, NULL): write() will PostMessage();
		ioctl (fd, WINDOWS_SEND, NULL): write() will SendMessage();
		ioctl (fd, WINDOWS_HWND, &hWnd): read() messages for
			hWnd window.

	select () call marks read fd when any message posted to queue.
*/

fhandler_windows::fhandler_windows (const char *name) :
	fhandler_base (FH_WINDOWS, name)
{
  set_cb (sizeof *this);
  hWnd_ = NULL;
  method_ = WINDOWS_POST;
}

int
fhandler_windows::open (const char *, int flags, mode_t)
{
  set_flags (flags);
  set_close_on_exec_flag (1);
  set_open_status ();
  return 1;
}

int
fhandler_windows::write (const void *buf, size_t)
{
  MSG *ptr = (MSG *) buf;

  if (method_ == WINDOWS_POST)
    {
      if (!PostMessage (ptr->hwnd, ptr->message, ptr->wParam, ptr->lParam))
	{
	  __seterrno ();
	  return -1;
	}
      else
	return sizeof (MSG);
    }
  else
    return SendMessage (ptr->hwnd, ptr->message, ptr->wParam, ptr->lParam);
}

int
fhandler_windows::read (void *buf, size_t len)
{
  MSG *ptr = (MSG *) buf;
  int ret;

  if (len < sizeof (MSG))
    {
      set_errno (EINVAL);
      return -1;
    }

  ret = GetMessage (ptr, hWnd_, 0, 0);

  if (ret == -1)
    {
      __seterrno ();
    }
  set_errno (0);
  return ret;
}

int
fhandler_windows::ioctl (unsigned int cmd, void *val)
{
  switch (cmd)
    {
    case WINDOWS_POST:
    case WINDOWS_SEND:
      method_ = cmd;
      break;
    case WINDOWS_HWND:
      if (val == NULL)
	{
	  set_errno (EINVAL);
	  return -1;
	}
      hWnd_ = * ((HWND *) val);
      break;
    default:
      set_errno (EINVAL);
      return -1;
    }
  return 0;
}

void
fhandler_windows::set_close_on_exec (int val)
{
  if (get_handle ())
    this->fhandler_base::set_close_on_exec (val);
  else
    this->fhandler_base::set_close_on_exec_flag (val);
  void *h = hWnd_;
  if (h)
    set_inheritance (h, val);
}

void
fhandler_windows::fixup_after_fork (HANDLE parent)
{
  if (get_handle ())
    this->fhandler_base::fixup_after_fork (parent);
  void *h = hWnd_;
  if (h)
    fork_fixup (parent, h, "hWnd_");
}