2 * General mechanism for wrapping up reading/writing of Windows
3 * HANDLEs into a PuTTY Socket abstraction.
10 #define DEFINE_PLUG_METHOD_MACROS
15 typedef struct Socket_handle_tag *Handle_Socket;
17 struct Socket_handle_tag {
18 const struct socket_function_table *fn;
19 /* the above variable absolutely *must* be the first in this structure */
21 HANDLE send_H, recv_H, stderr_H;
22 struct handle *send_h, *recv_h, *stderr_h;
25 * Freezing one of these sockets is a slightly fiddly business,
26 * because the reads from the handle are happening in a separate
27 * thread as blocking system calls and so once one is in progress
28 * it can't sensibly be interrupted. Hence, after the user tries
29 * to freeze one of these sockets, it's unavoidable that we may
30 * receive one more load of data before we manage to get
31 * winhandl.c to stop reading.
34 UNFROZEN, /* reading as normal */
35 FREEZING, /* have been set to frozen but winhandl is still reading */
36 FROZEN, /* really frozen - winhandl has been throttled */
37 THAWING /* we're gradually releasing our remaining data */
39 /* We buffer data here if we receive it from winhandl while frozen. */
42 /* Data received from stderr_H, if we have one. */
45 int defer_close, deferred_close; /* in case of re-entrance */
52 static int handle_gotdata(struct handle *h, void *data, int len)
54 Handle_Socket ps = (Handle_Socket) handle_get_privdata(h);
57 return plug_closing(ps->plug, "Read error from handle",
59 } else if (len == 0) {
60 return plug_closing(ps->plug, NULL, 0, 0);
62 assert(ps->frozen != FROZEN && ps->frozen != THAWING);
63 if (ps->frozen == FREEZING) {
65 * If we've received data while this socket is supposed to
66 * be frozen (because the read winhandl.c started before
67 * sk_set_frozen was called has now returned) then buffer
68 * the data for when we unfreeze.
70 bufchain_add(&ps->inputdata, data, len);
74 * And return a very large backlog, to prevent further
75 * data arriving from winhandl until we unfreeze.
79 return plug_receive(ps->plug, 0, data, len);
84 static int handle_stderr(struct handle *h, void *data, int len)
86 Handle_Socket ps = (Handle_Socket) handle_get_privdata(h);
89 log_proxy_stderr(ps->plug, &ps->stderrdata, data, len);
94 static void handle_sentdata(struct handle *h, int new_backlog)
96 Handle_Socket ps = (Handle_Socket) handle_get_privdata(h);
98 if (new_backlog < 0) {
99 /* Special case: this is actually reporting an error writing
100 * to the underlying handle, and our input value is the error
101 * code itself, negated. */
102 plug_closing(ps->plug, win_strerror(-new_backlog), -new_backlog, 0);
106 plug_sent(ps->plug, new_backlog);
109 static Plug sk_handle_plug(Socket s, Plug p)
111 Handle_Socket ps = (Handle_Socket) s;
118 static void sk_handle_close(Socket s)
120 Handle_Socket ps = (Handle_Socket) s;
122 if (ps->defer_close) {
123 ps->deferred_close = TRUE;
127 handle_free(ps->send_h);
128 handle_free(ps->recv_h);
129 CloseHandle(ps->send_H);
130 if (ps->recv_H != ps->send_H)
131 CloseHandle(ps->recv_H);
132 bufchain_clear(&ps->inputdata);
133 bufchain_clear(&ps->stderrdata);
138 static int sk_handle_write(Socket s, const char *data, int len)
140 Handle_Socket ps = (Handle_Socket) s;
142 return handle_write(ps->send_h, data, len);
145 static int sk_handle_write_oob(Socket s, const char *data, int len)
148 * oob data is treated as inband; nasty, but nothing really
151 return sk_handle_write(s, data, len);
154 static void sk_handle_write_eof(Socket s)
156 Handle_Socket ps = (Handle_Socket) s;
158 handle_write_eof(ps->send_h);
161 static void sk_handle_flush(Socket s)
163 /* Handle_Socket ps = (Handle_Socket) s; */
167 static void handle_socket_unfreeze(void *psv)
169 Handle_Socket ps = (Handle_Socket) psv;
171 int len, new_backlog;
174 * If we've been put into a state other than THAWING since the
175 * last callback, then we're done.
177 if (ps->frozen != THAWING)
181 * Get some of the data we've buffered.
183 bufchain_prefix(&ps->inputdata, &data, &len);
187 * Hand it off to the plug. Be careful of re-entrance - that might
188 * have the effect of trying to close this socket.
190 ps->defer_close = TRUE;
191 new_backlog = plug_receive(ps->plug, 0, data, len);
192 bufchain_consume(&ps->inputdata, len);
193 ps->defer_close = FALSE;
194 if (ps->deferred_close) {
199 if (bufchain_size(&ps->inputdata) > 0) {
201 * If there's still data in our buffer, stay in THAWING state,
202 * and reschedule ourself.
204 queue_toplevel_callback(handle_socket_unfreeze, ps);
207 * Otherwise, we've successfully thawed!
209 ps->frozen = UNFROZEN;
210 handle_unthrottle(ps->recv_h, new_backlog);
214 static void sk_handle_set_frozen(Socket s, int is_frozen)
216 Handle_Socket ps = (Handle_Socket) s;
219 switch (ps->frozen) {
222 return; /* nothing to do */
226 * We were in the middle of emptying our bufchain, and got
227 * frozen again. In that case, winhandl.c is already
228 * throttled, so just return to FROZEN state. The toplevel
229 * callback will notice and disable itself.
236 * The normal case. Go to FREEZING, and expect one more
237 * load of data from winhandl if we're unlucky.
239 ps->frozen = FREEZING;
243 switch (ps->frozen) {
246 return; /* nothing to do */
250 * If winhandl didn't send us any data throughout the time
251 * we were frozen, then we'll still be in this state and
252 * can just unfreeze in the trivial way.
254 assert(bufchain_size(&ps->inputdata) == 0);
255 ps->frozen = UNFROZEN;
260 * If we have buffered data, go to THAWING and start
261 * releasing it in top-level callbacks.
263 ps->frozen = THAWING;
264 queue_toplevel_callback(handle_socket_unfreeze, ps);
269 static const char *sk_handle_socket_error(Socket s)
271 Handle_Socket ps = (Handle_Socket) s;
275 static char *sk_handle_peer_info(Socket s)
277 Handle_Socket ps = (Handle_Socket) s;
279 static HMODULE kernel32_module;
280 DECL_WINDOWS_FUNCTION(static, BOOL, GetNamedPipeClientProcessId,
283 if (!kernel32_module) {
284 kernel32_module = load_system32_dll("kernel32.dll");
285 GET_WINDOWS_FUNCTION(kernel32_module, GetNamedPipeClientProcessId);
289 * Of course, not all handles managed by this module will be
290 * server ends of named pipes, but if they are, then it's useful
291 * to log what we can find out about the client end.
293 if (p_GetNamedPipeClientProcessId &&
294 p_GetNamedPipeClientProcessId(ps->send_H, &pid))
295 return dupprintf("process id %lu", (unsigned long)pid);
300 Socket make_handle_socket(HANDLE send_H, HANDLE recv_H, HANDLE stderr_H,
301 Plug plug, int overlapped)
303 static const struct socket_function_table socket_fn_table = {
310 sk_handle_set_frozen,
311 sk_handle_socket_error,
316 int flags = (overlapped ? HANDLE_FLAG_OVERLAPPED : 0);
318 ret = snew(struct Socket_handle_tag);
319 ret->fn = &socket_fn_table;
322 ret->frozen = UNFROZEN;
323 bufchain_init(&ret->inputdata);
324 bufchain_init(&ret->stderrdata);
326 ret->recv_H = recv_H;
327 ret->recv_h = handle_input_new(ret->recv_H, handle_gotdata, ret, flags);
328 ret->send_H = send_H;
329 ret->send_h = handle_output_new(ret->send_H, handle_sentdata, ret, flags);
330 ret->stderr_H = stderr_H;
332 ret->stderr_h = handle_input_new(ret->stderr_H, handle_stderr,
335 ret->defer_close = ret->deferred_close = FALSE;