1/*
2 * Copyright (c) 2009-2012 Niels Provos and Nick Mathewson
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 *    derived from this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#ifndef _EVENT_IOCP_INTERNAL_H
28#define _EVENT_IOCP_INTERNAL_H
29
30#ifdef __cplusplus
31extern "C" {
32#endif
33
34struct event_overlapped;
35struct event_iocp_port;
36struct evbuffer;
37typedef void (*iocp_callback)(struct event_overlapped *, ev_uintptr_t, ev_ssize_t, int success);
38
39/* This whole file is actually win32 only. We wrap the structures in a win32
40 * ifdef so that we can test-compile code that uses these interfaces on
41 * non-win32 platforms. */
42#ifdef WIN32
43
44/**
45   Internal use only.  Wraps an OVERLAPPED that we're using for libevent
46   functionality.  Whenever an event_iocp_port gets an event for a given
47   OVERLAPPED*, it upcasts the pointer to an event_overlapped, and calls the
48   iocp_callback function with the event_overlapped, the iocp key, and the
49   number of bytes transferred as arguments.
50 */
51struct event_overlapped {
52	OVERLAPPED overlapped;
53	iocp_callback cb;
54};
55
56/* Mingw's headers don't define LPFN_ACCEPTEX. */
57
58typedef BOOL (WINAPI *AcceptExPtr)(SOCKET, SOCKET, PVOID, DWORD, DWORD, DWORD, LPDWORD, LPOVERLAPPED);
59typedef BOOL (WINAPI *ConnectExPtr)(SOCKET, const struct sockaddr *, int, PVOID, DWORD, LPDWORD, LPOVERLAPPED);
60typedef void (WINAPI *GetAcceptExSockaddrsPtr)(PVOID, DWORD, DWORD, DWORD, LPSOCKADDR *, LPINT, LPSOCKADDR *, LPINT);
61
62/** Internal use only. Holds pointers to functions that only some versions of
63    Windows provide.
64 */
65struct win32_extension_fns {
66	AcceptExPtr AcceptEx;
67	ConnectExPtr ConnectEx;
68	GetAcceptExSockaddrsPtr GetAcceptExSockaddrs;
69};
70
71/**
72    Internal use only. Stores a Windows IO Completion port, along with
73    related data.
74 */
75struct event_iocp_port {
76	/** The port itself */
77	HANDLE port;
78	/* A lock to cover internal structures. */
79	CRITICAL_SECTION lock;
80	/** Number of threads ever open on the port. */
81	short n_threads;
82	/** True iff we're shutting down all the threads on this port */
83	short shutdown;
84	/** How often the threads on this port check for shutdown and other
85	 * conditions */
86	long ms;
87	/* The threads that are waiting for events. */
88	HANDLE *threads;
89	/** Number of threads currently open on this port. */
90	short n_live_threads;
91	/** A semaphore to signal when we are done shutting down. */
92	HANDLE *shutdownSemaphore;
93};
94
95const struct win32_extension_fns *event_get_win32_extension_fns(void);
96#else
97/* Dummy definition so we can test-compile more things on unix. */
98struct event_overlapped {
99	iocp_callback cb;
100};
101#endif
102
103/** Initialize the fields in an event_overlapped.
104
105    @param overlapped The struct event_overlapped to initialize
106    @param cb The callback that should be invoked once the IO operation has
107	finished.
108 */
109void event_overlapped_init(struct event_overlapped *, iocp_callback cb);
110
111/** Allocate and return a new evbuffer that supports overlapped IO on a given
112    socket.  The socket must be associated with an IO completion port using
113    event_iocp_port_associate.
114*/
115struct evbuffer *evbuffer_overlapped_new(evutil_socket_t fd);
116
117/** XXXX Document (nickm) */
118evutil_socket_t _evbuffer_overlapped_get_fd(struct evbuffer *buf);
119
120void _evbuffer_overlapped_set_fd(struct evbuffer *buf, evutil_socket_t fd);
121
122/** Start reading data onto the end of an overlapped evbuffer.
123
124    An evbuffer can only have one read pending at a time.  While the read
125    is in progress, no other data may be added to the end of the buffer.
126    The buffer must be created with event_overlapped_init().
127    evbuffer_commit_read() must be called in the completion callback.
128
129    @param buf The buffer to read onto
130    @param n The number of bytes to try to read.
131    @param ol Overlapped object with associated completion callback.
132    @return 0 on success, -1 on error.
133 */
134int evbuffer_launch_read(struct evbuffer *buf, size_t n, struct event_overlapped *ol);
135
136/** Start writing data from the start of an evbuffer.
137
138    An evbuffer can only have one write pending at a time.  While the write is
139    in progress, no other data may be removed from the front of the buffer.
140    The buffer must be created with event_overlapped_init().
141    evbuffer_commit_write() must be called in the completion callback.
142
143    @param buf The buffer to read onto
144    @param n The number of bytes to try to read.
145    @param ol Overlapped object with associated completion callback.
146    @return 0 on success, -1 on error.
147 */
148int evbuffer_launch_write(struct evbuffer *buf, ev_ssize_t n, struct event_overlapped *ol);
149
150/** XXX document */
151void evbuffer_commit_read(struct evbuffer *, ev_ssize_t);
152void evbuffer_commit_write(struct evbuffer *, ev_ssize_t);
153
154/** Create an IOCP, and launch its worker threads.  Internal use only.
155
156    This interface is unstable, and will change.
157 */
158struct event_iocp_port *event_iocp_port_launch(int n_cpus);
159
160/** Associate a file descriptor with an iocp, such that overlapped IO on the
161    fd will happen on one of the iocp's worker threads.
162*/
163int event_iocp_port_associate(struct event_iocp_port *port, evutil_socket_t fd,
164    ev_uintptr_t key);
165
166/** Tell all threads serving an iocp to stop.  Wait for up to waitMsec for all
167    the threads to finish whatever they're doing.  If waitMsec is -1, wait
168    as long as required.  If all the threads are done, free the port and return
169    0. Otherwise, return -1.  If you get a -1 return value, it is safe to call
170    this function again.
171*/
172int event_iocp_shutdown(struct event_iocp_port *port, long waitMsec);
173
174/* FIXME document. */
175int event_iocp_activate_overlapped(struct event_iocp_port *port,
176    struct event_overlapped *o,
177    ev_uintptr_t key, ev_uint32_t n_bytes);
178
179struct event_base;
180/* FIXME document. */
181struct event_iocp_port *event_base_get_iocp(struct event_base *base);
182
183/* FIXME document. */
184int event_base_start_iocp(struct event_base *base, int n_cpus);
185void event_base_stop_iocp(struct event_base *base);
186
187/* FIXME document. */
188struct bufferevent *bufferevent_async_new(struct event_base *base,
189    evutil_socket_t fd, int options);
190
191/* FIXME document. */
192void bufferevent_async_set_connected(struct bufferevent *bev);
193int bufferevent_async_can_connect(struct bufferevent *bev);
194int bufferevent_async_connect(struct bufferevent *bev, evutil_socket_t fd,
195	const struct sockaddr *sa, int socklen);
196
197#ifdef __cplusplus
198}
199#endif
200
201#endif
202