Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
C
com.ccwangluo.accelerator
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
sheteng
com.ccwangluo.accelerator
Commits
d3f10dac
Commit
d3f10dac
authored
Jul 08, 2016
by
Max Lv
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Remove redudant libev source code
parent
a21d099a
Changes
19
Expand all
Hide whitespace changes
Inline
Side-by-side
Showing
19 changed files
with
427 additions
and
8967 deletions
+427
-8967
src/main/jni/Android.mk
src/main/jni/Android.mk
+8
-5
src/main/jni/include/libev/config.h
src/main/jni/include/libev/config.h
+0
-0
src/main/jni/include/shadowsocks-libev/config.h
src/main/jni/include/shadowsocks-libev/config.h
+419
-0
src/main/jni/libev/Changes
src/main/jni/libev/Changes
+0
-477
src/main/jni/libev/LICENSE
src/main/jni/libev/LICENSE
+0
-37
src/main/jni/libev/README
src/main/jni/libev/README
+0
-58
src/main/jni/libev/ev++.h
src/main/jni/libev/ev++.h
+0
-816
src/main/jni/libev/ev.c
src/main/jni/libev/ev.c
+0
-4480
src/main/jni/libev/ev.h
src/main/jni/libev/ev.h
+0
-839
src/main/jni/libev/ev_epoll.c
src/main/jni/libev/ev_epoll.c
+0
-279
src/main/jni/libev/ev_kqueue.c
src/main/jni/libev/ev_kqueue.c
+0
-198
src/main/jni/libev/ev_poll.c
src/main/jni/libev/ev_poll.c
+0
-148
src/main/jni/libev/ev_port.c
src/main/jni/libev/ev_port.c
+0
-185
src/main/jni/libev/ev_select.c
src/main/jni/libev/ev_select.c
+0
-318
src/main/jni/libev/ev_vars.h
src/main/jni/libev/ev_vars.h
+0
-204
src/main/jni/libev/ev_win32.c
src/main/jni/libev/ev_win32.c
+0
-153
src/main/jni/libev/ev_wrap.h
src/main/jni/libev/ev_wrap.h
+0
-198
src/main/jni/libev/event.c
src/main/jni/libev/event.c
+0
-402
src/main/jni/libev/event.h
src/main/jni/libev/event.h
+0
-170
No files found.
src/main/jni/Android.mk
View file @
d3f10dac
...
...
@@ -331,10 +331,11 @@ include $(BUILD_STATIC_LIBRARY)
include
$(CLEAR_VARS)
LOCAL_MODULE
:=
libev
LOCAL_CFLAGS
+=
-O2
-DNDEBUG
-DHAVE_CONFIG_H
LOCAL_CFLAGS
+=
-O2
-DNDEBUG
-DHAVE_CONFIG_H
\
-I
$(LOCAL_PATH)
/include/libev
LOCAL_SRC_FILES
:=
\
libev/ev.c
\
libev/event.c
shadowsocks-libev/
libev/ev.c
\
shadowsocks-libev/
libev/event.c
include
$(BUILD_STATIC_LIBRARY)
...
...
@@ -395,7 +396,8 @@ LOCAL_CFLAGS := -Wall -O2 -fno-strict-aliasing -DMODULE_LOCAL \
-I
$(LOCAL_PATH)
/shadowsocks-libev/libcork/include
\
-I
$(LOCAL_PATH)
/shadowsocks-libev/libsodium/src/libsodium/include
\
-I
$(LOCAL_PATH)
/shadowsocks-libev/libsodium/src/libsodium/include/sodium
\
-I
$(LOCAL_PATH)
/shadowsocks-libev/libipset/include
-I
$(LOCAL_PATH)
/shadowsocks-libev/libipset/include
\
-I
$(LOCAL_PATH)
/include/shadowsocks-libev
LOCAL_STATIC_LIBRARIES
:=
libev libcrypto libipset libcork libudns libsodium libancillary
...
...
@@ -423,7 +425,8 @@ LOCAL_CFLAGS := -Wall -O2 -fno-strict-aliasing -DMODULE_TUNNEL \
-I
$(LOCAL_PATH)
/shadowsocks-libev/libcork/include
\
-I
$(LOCAL_PATH)
/shadowsocks-libev/libsodium/src/libsodium/include
\
-I
$(LOCAL_PATH)
/shadowsocks-libev/libsodium/src/libsodium/include/sodium
\
-I
$(LOCAL_PATH)
/openssl/include
-I
$(LOCAL_PATH)
/openssl/include
\
-I
$(LOCAL_PATH)
/include/shadowsocks-libev
LOCAL_STATIC_LIBRARIES
:=
libev libcrypto libsodium libcork libudns libancillary
...
...
src/main/jni/libev/config.h
→
src/main/jni/
include/
libev/config.h
View file @
d3f10dac
File moved
src/main/jni/include/shadowsocks-libev/config.h
0 → 100644
View file @
d3f10dac
This diff is collapsed.
Click to expand it.
src/main/jni/libev/Changes
deleted
100644 → 0
View file @
a21d099a
This diff is collapsed.
Click to expand it.
src/main/jni/libev/LICENSE
deleted
100644 → 0
View file @
a21d099a
All files in libev are
Copyright (c)2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Alternatively, the contents of this package may be used under the terms
of the GNU General Public License ("GPL") version 2 or any later version,
in which case the provisions of the GPL are applicable instead of the
above. If you wish to allow the use of your version of this package only
under the terms of the GPL and not to allow others to use your version of
this file under the BSD license, indicate your decision by deleting the
provisions above and replace them with the notice and other provisions
required by the GPL in this and the other files of this package. If you do
not delete the provisions above, a recipient may use your version of this
file under either the BSD or the GPL.
src/main/jni/libev/README
deleted
100644 → 0
View file @
a21d099a
libev is a high-performance event loop/event model with lots of features.
(see benchmark at http://libev.schmorp.de/bench.html)
ABOUT
Homepage: http://software.schmorp.de/pkg/libev
Mailinglist: libev@lists.schmorp.de
http://lists.schmorp.de/cgi-bin/mailman/listinfo/libev
Library Documentation: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod
Libev is modelled (very losely) after libevent and the Event perl
module, but is faster, scales better and is more correct, and also more
featureful. And also smaller. Yay.
Some of the specialties of libev not commonly found elsewhere are:
- extensive and detailed, readable documentation (not doxygen garbage).
- fully supports fork, can detect fork in various ways and automatically
re-arms kernel mechanisms that do not support fork.
- highly optimised select, poll, epoll, kqueue and event ports backends.
- filesystem object (path) watching (with optional linux inotify support).
- wallclock-based times (using absolute time, cron-like).
- relative timers/timeouts (handle time jumps).
- fast intra-thread communication between multiple
event loops (with optional fast linux eventfd backend).
- extremely easy to embed (fully documented, no dependencies,
autoconf supported but optional).
- very small codebase, no bloated library, simple code.
- fully extensible by being able to plug into the event loop,
integrate other event loops, integrate other event loop users.
- very little memory use (small watchers, small event loop data).
- optional C++ interface allowing method and function callbacks
at no extra memory or runtime overhead.
- optional Perl interface with similar characteristics (capable
of running Glib/Gtk2 on libev).
- support for other languages (multiple C++ interfaces, D, Ruby,
Python) available from third-parties.
Examples of programs that embed libev: the EV perl module, node.js,
auditd, rxvt-unicode, gvpe (GNU Virtual Private Ethernet), the
Deliantra MMORPG server (http://www.deliantra.net/), Rubinius (a
next-generation Ruby VM), the Ebb web server, the Rev event toolkit.
CONTRIBUTORS
libev was written and designed by Marc Lehmann and Emanuele Giaquinta.
The following people sent in patches or made other noteworthy
contributions to the design (for minor patches, see the Changes
file. If I forgot to include you, please shout at me, it was an
accident):
W.C.A. Wijngaards
Christopher Layne
Chris Brody
src/main/jni/libev/ev++.h
deleted
100644 → 0
View file @
a21d099a
This diff is collapsed.
Click to expand it.
src/main/jni/libev/ev.c
deleted
100644 → 0
View file @
a21d099a
This diff is collapsed.
Click to expand it.
src/main/jni/libev/ev.h
deleted
100644 → 0
View file @
a21d099a
This diff is collapsed.
Click to expand it.
src/main/jni/libev/ev_epoll.c
deleted
100644 → 0
View file @
a21d099a
/*
* libev epoll fd activity backend
*
* Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
/*
* general notes about epoll:
*
* a) epoll silently removes fds from the fd set. as nothing tells us
* that an fd has been removed otherwise, we have to continually
* "rearm" fds that we suspect *might* have changed (same
* problem with kqueue, but much less costly there).
* b) the fact that ADD != MOD creates a lot of extra syscalls due to a)
* and seems not to have any advantage.
* c) the inability to handle fork or file descriptors (think dup)
* limits the applicability over poll, so this is not a generic
* poll replacement.
* d) epoll doesn't work the same as select with many file descriptors
* (such as files). while not critical, no other advanced interface
* seems to share this (rather non-unixy) limitation.
* e) epoll claims to be embeddable, but in practise you never get
* a ready event for the epoll fd (broken: <=2.6.26, working: >=2.6.32).
* f) epoll_ctl returning EPERM means the fd is always ready.
*
* lots of "weird code" and complication handling in this file is due
* to these design problems with epoll, as we try very hard to avoid
* epoll_ctl syscalls for common usage patterns and handle the breakage
* ensuing from receiving events for closed and otherwise long gone
* file descriptors.
*/
#include <sys/epoll.h>
#define EV_EMASK_EPERM 0x80
static
void
epoll_modify
(
EV_P_
int
fd
,
int
oev
,
int
nev
)
{
struct
epoll_event
ev
;
unsigned
char
oldmask
;
/*
* we handle EPOLL_CTL_DEL by ignoring it here
* on the assumption that the fd is gone anyways
* if that is wrong, we have to handle the spurious
* event in epoll_poll.
* if the fd is added again, we try to ADD it, and, if that
* fails, we assume it still has the same eventmask.
*/
if
(
!
nev
)
return
;
oldmask
=
anfds
[
fd
].
emask
;
anfds
[
fd
].
emask
=
nev
;
/* store the generation counter in the upper 32 bits, the fd in the lower 32 bits */
ev
.
data
.
u64
=
(
uint64_t
)(
uint32_t
)
fd
|
((
uint64_t
)(
uint32_t
)
++
anfds
[
fd
].
egen
<<
32
);
ev
.
events
=
(
nev
&
EV_READ
?
EPOLLIN
:
0
)
|
(
nev
&
EV_WRITE
?
EPOLLOUT
:
0
);
if
(
expect_true
(
!
epoll_ctl
(
backend_fd
,
oev
&&
oldmask
!=
nev
?
EPOLL_CTL_MOD
:
EPOLL_CTL_ADD
,
fd
,
&
ev
)))
return
;
if
(
expect_true
(
errno
==
ENOENT
))
{
/* if ENOENT then the fd went away, so try to do the right thing */
if
(
!
nev
)
goto
dec_egen
;
if
(
!
epoll_ctl
(
backend_fd
,
EPOLL_CTL_ADD
,
fd
,
&
ev
))
return
;
}
else
if
(
expect_true
(
errno
==
EEXIST
))
{
/* EEXIST means we ignored a previous DEL, but the fd is still active */
/* if the kernel mask is the same as the new mask, we assume it hasn't changed */
if
(
oldmask
==
nev
)
goto
dec_egen
;
if
(
!
epoll_ctl
(
backend_fd
,
EPOLL_CTL_MOD
,
fd
,
&
ev
))
return
;
}
else
if
(
expect_true
(
errno
==
EPERM
))
{
/* EPERM means the fd is always ready, but epoll is too snobbish */
/* to handle it, unlike select or poll. */
anfds
[
fd
].
emask
=
EV_EMASK_EPERM
;
/* add fd to epoll_eperms, if not already inside */
if
(
!
(
oldmask
&
EV_EMASK_EPERM
))
{
array_needsize
(
int
,
epoll_eperms
,
epoll_epermmax
,
epoll_epermcnt
+
1
,
EMPTY2
);
epoll_eperms
[
epoll_epermcnt
++
]
=
fd
;
}
return
;
}
fd_kill
(
EV_A_
fd
);
dec_egen:
/* we didn't successfully call epoll_ctl, so decrement the generation counter again */
--
anfds
[
fd
].
egen
;
}
static
void
epoll_poll
(
EV_P_
ev_tstamp
timeout
)
{
int
i
;
int
eventcnt
;
if
(
expect_false
(
epoll_epermcnt
))
timeout
=
0
.;
/* epoll wait times cannot be larger than (LONG_MAX - 999UL) / HZ msecs, which is below */
/* the default libev max wait time, however. */
EV_RELEASE_CB
;
eventcnt
=
epoll_wait
(
backend_fd
,
epoll_events
,
epoll_eventmax
,
timeout
*
1e3
);
EV_ACQUIRE_CB
;
if
(
expect_false
(
eventcnt
<
0
))
{
if
(
errno
!=
EINTR
)
ev_syserr
(
"(libev) epoll_wait"
);
return
;
}
for
(
i
=
0
;
i
<
eventcnt
;
++
i
)
{
struct
epoll_event
*
ev
=
epoll_events
+
i
;
int
fd
=
(
uint32_t
)
ev
->
data
.
u64
;
/* mask out the lower 32 bits */
int
want
=
anfds
[
fd
].
events
;
int
got
=
(
ev
->
events
&
(
EPOLLOUT
|
EPOLLERR
|
EPOLLHUP
)
?
EV_WRITE
:
0
)
|
(
ev
->
events
&
(
EPOLLIN
|
EPOLLERR
|
EPOLLHUP
)
?
EV_READ
:
0
);
/*
* check for spurious notification.
* this only finds spurious notifications on egen updates
* other spurious notifications will be found by epoll_ctl, below
* we assume that fd is always in range, as we never shrink the anfds array
*/
if
(
expect_false
((
uint32_t
)
anfds
[
fd
].
egen
!=
(
uint32_t
)(
ev
->
data
.
u64
>>
32
)))
{
/* recreate kernel state */
postfork
=
1
;
continue
;
}
if
(
expect_false
(
got
&
~
want
))
{
anfds
[
fd
].
emask
=
want
;
/*
* we received an event but are not interested in it, try mod or del
* this often happens because we optimistically do not unregister fds
* when we are no longer interested in them, but also when we get spurious
* notifications for fds from another process. this is partially handled
* above with the gencounter check (== our fd is not the event fd), and
* partially here, when epoll_ctl returns an error (== a child has the fd
* but we closed it).
*/
ev
->
events
=
(
want
&
EV_READ
?
EPOLLIN
:
0
)
|
(
want
&
EV_WRITE
?
EPOLLOUT
:
0
);
/* pre-2.6.9 kernels require a non-null pointer with EPOLL_CTL_DEL, */
/* which is fortunately easy to do for us. */
if
(
epoll_ctl
(
backend_fd
,
want
?
EPOLL_CTL_MOD
:
EPOLL_CTL_DEL
,
fd
,
ev
))
{
postfork
=
1
;
/* an error occurred, recreate kernel state */
continue
;
}
}
fd_event
(
EV_A_
fd
,
got
);
}
/* if the receive array was full, increase its size */
if
(
expect_false
(
eventcnt
==
epoll_eventmax
))
{
ev_free
(
epoll_events
);
epoll_eventmax
=
array_nextsize
(
sizeof
(
struct
epoll_event
),
epoll_eventmax
,
epoll_eventmax
+
1
);
epoll_events
=
(
struct
epoll_event
*
)
ev_malloc
(
sizeof
(
struct
epoll_event
)
*
epoll_eventmax
);
}
/* now synthesize events for all fds where epoll fails, while select works... */
for
(
i
=
epoll_epermcnt
;
i
--
;
)
{
int
fd
=
epoll_eperms
[
i
];
unsigned
char
events
=
anfds
[
fd
].
events
&
(
EV_READ
|
EV_WRITE
);
if
(
anfds
[
fd
].
emask
&
EV_EMASK_EPERM
&&
events
)
fd_event
(
EV_A_
fd
,
events
);
else
epoll_eperms
[
i
]
=
epoll_eperms
[
--
epoll_epermcnt
];
}
}
int
inline_size
epoll_init
(
EV_P_
int
flags
)
{
#ifdef EPOLL_CLOEXEC
backend_fd
=
epoll_create1
(
EPOLL_CLOEXEC
);
if
(
backend_fd
<
0
)
#endif
backend_fd
=
epoll_create
(
256
);
if
(
backend_fd
<
0
)
return
0
;
fcntl
(
backend_fd
,
F_SETFD
,
FD_CLOEXEC
);
backend_mintime
=
1e-3
;
/* epoll does sometimes return early, this is just to avoid the worst */
backend_modify
=
epoll_modify
;
backend_poll
=
epoll_poll
;
epoll_eventmax
=
64
;
/* initial number of events receivable per poll */
epoll_events
=
(
struct
epoll_event
*
)
ev_malloc
(
sizeof
(
struct
epoll_event
)
*
epoll_eventmax
);
return
EVBACKEND_EPOLL
;
}
void
inline_size
epoll_destroy
(
EV_P
)
{
ev_free
(
epoll_events
);
array_free
(
epoll_eperm
,
EMPTY
);
}
void
inline_size
epoll_fork
(
EV_P
)
{
close
(
backend_fd
);
while
((
backend_fd
=
epoll_create
(
256
))
<
0
)
ev_syserr
(
"(libev) epoll_create"
);
fcntl
(
backend_fd
,
F_SETFD
,
FD_CLOEXEC
);
fd_rearm_all
(
EV_A
);
}
src/main/jni/libev/ev_kqueue.c
deleted
100644 → 0
View file @
a21d099a
/*
* libev kqueue backend
*
* Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
#include <sys/types.h>
#include <sys/time.h>
#include <sys/event.h>
#include <string.h>
#include <errno.h>
void
inline_speed
kqueue_change
(
EV_P_
int
fd
,
int
filter
,
int
flags
,
int
fflags
)
{
++
kqueue_changecnt
;
array_needsize
(
struct
kevent
,
kqueue_changes
,
kqueue_changemax
,
kqueue_changecnt
,
EMPTY2
);
EV_SET
(
&
kqueue_changes
[
kqueue_changecnt
-
1
],
fd
,
filter
,
flags
,
fflags
,
0
,
0
);
}
/* OS X at least needs this */
#ifndef EV_ENABLE
# define EV_ENABLE 0
#endif
#ifndef NOTE_EOF
# define NOTE_EOF 0
#endif
static
void
kqueue_modify
(
EV_P_
int
fd
,
int
oev
,
int
nev
)
{
if
(
oev
!=
nev
)
{
if
(
oev
&
EV_READ
)
kqueue_change
(
EV_A_
fd
,
EVFILT_READ
,
EV_DELETE
,
0
);
if
(
oev
&
EV_WRITE
)
kqueue_change
(
EV_A_
fd
,
EVFILT_WRITE
,
EV_DELETE
,
0
);
}
/* to detect close/reopen reliably, we have to re-add */
/* event requests even when oev == nev */
if
(
nev
&
EV_READ
)
kqueue_change
(
EV_A_
fd
,
EVFILT_READ
,
EV_ADD
|
EV_ENABLE
,
NOTE_EOF
);
if
(
nev
&
EV_WRITE
)
kqueue_change
(
EV_A_
fd
,
EVFILT_WRITE
,
EV_ADD
|
EV_ENABLE
,
NOTE_EOF
);
}
static
void
kqueue_poll
(
EV_P_
ev_tstamp
timeout
)
{
int
res
,
i
;
struct
timespec
ts
;
/* need to resize so there is enough space for errors */
if
(
kqueue_changecnt
>
kqueue_eventmax
)
{
ev_free
(
kqueue_events
);
kqueue_eventmax
=
array_nextsize
(
sizeof
(
struct
kevent
),
kqueue_eventmax
,
kqueue_changecnt
);
kqueue_events
=
(
struct
kevent
*
)
ev_malloc
(
sizeof
(
struct
kevent
)
*
kqueue_eventmax
);
}
EV_RELEASE_CB
;
EV_TS_SET
(
ts
,
timeout
);
res
=
kevent
(
backend_fd
,
kqueue_changes
,
kqueue_changecnt
,
kqueue_events
,
kqueue_eventmax
,
&
ts
);
EV_ACQUIRE_CB
;
kqueue_changecnt
=
0
;
if
(
expect_false
(
res
<
0
))
{
if
(
errno
!=
EINTR
)
ev_syserr
(
"(libev) kevent"
);
return
;
}
for
(
i
=
0
;
i
<
res
;
++
i
)
{
int
fd
=
kqueue_events
[
i
].
ident
;
if
(
expect_false
(
kqueue_events
[
i
].
flags
&
EV_ERROR
))
{
int
err
=
kqueue_events
[
i
].
data
;
/* we are only interested in errors for fds that we are interested in :) */
if
(
anfds
[
fd
].
events
)
{
if
(
err
==
ENOENT
)
/* resubmit changes on ENOENT */
kqueue_modify
(
EV_A_
fd
,
0
,
anfds
[
fd
].
events
);
else
if
(
err
==
EBADF
)
/* on EBADF, we re-check the fd */
{
if
(
fd_valid
(
fd
))
kqueue_modify
(
EV_A_
fd
,
0
,
anfds
[
fd
].
events
);
else
fd_kill
(
EV_A_
fd
);
}
else
/* on all other errors, we error out on the fd */
fd_kill
(
EV_A_
fd
);
}
}
else
fd_event
(
EV_A_
fd
,
kqueue_events
[
i
].
filter
==
EVFILT_READ
?
EV_READ
:
kqueue_events
[
i
].
filter
==
EVFILT_WRITE
?
EV_WRITE
:
0
);
}
if
(
expect_false
(
res
==
kqueue_eventmax
))
{
ev_free
(
kqueue_events
);
kqueue_eventmax
=
array_nextsize
(
sizeof
(
struct
kevent
),
kqueue_eventmax
,
kqueue_eventmax
+
1
);
kqueue_events
=
(
struct
kevent
*
)
ev_malloc
(
sizeof
(
struct
kevent
)
*
kqueue_eventmax
);
}
}
int
inline_size
kqueue_init
(
EV_P_
int
flags
)
{
/* Initialize the kernel queue */
if
((
backend_fd
=
kqueue
())
<
0
)
return
0
;
fcntl
(
backend_fd
,
F_SETFD
,
FD_CLOEXEC
);
/* not sure if necessary, hopefully doesn't hurt */
backend_mintime
=
1e-9
;
/* apparently, they did the right thing in freebsd */
backend_modify
=
kqueue_modify
;
backend_poll
=
kqueue_poll
;
kqueue_eventmax
=
64
;
/* initial number of events receivable per poll */
kqueue_events
=
(
struct
kevent
*
)
ev_malloc
(
sizeof
(
struct
kevent
)
*
kqueue_eventmax
);
kqueue_changes
=
0
;
kqueue_changemax
=
0
;
kqueue_changecnt
=
0
;
return
EVBACKEND_KQUEUE
;
}
void
inline_size
kqueue_destroy
(
EV_P
)
{
ev_free
(
kqueue_events
);
ev_free
(
kqueue_changes
);
}
void
inline_size
kqueue_fork
(
EV_P
)
{
close
(
backend_fd
);
while
((
backend_fd
=
kqueue
())
<
0
)
ev_syserr
(
"(libev) kqueue"
);
fcntl
(
backend_fd
,
F_SETFD
,
FD_CLOEXEC
);
/* re-register interest in fds */
fd_rearm_all
(
EV_A
);
}
src/main/jni/libev/ev_poll.c
deleted
100644 → 0
View file @
a21d099a
/*
* libev poll fd activity backend
*
* Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
#include <poll.h>
void
inline_size
pollidx_init
(
int
*
base
,
int
count
)
{
/* consider using memset (.., -1, ...), which is practically guaranteed
* to work on all systems implementing poll */
while
(
count
--
)
*
base
++
=
-
1
;
}
static
void
poll_modify
(
EV_P_
int
fd
,
int
oev
,
int
nev
)
{
int
idx
;
if
(
oev
==
nev
)
return
;
array_needsize
(
int
,
pollidxs
,
pollidxmax
,
fd
+
1
,
pollidx_init
);
idx
=
pollidxs
[
fd
];
if
(
idx
<
0
)
/* need to allocate a new pollfd */
{
pollidxs
[
fd
]
=
idx
=
pollcnt
++
;
array_needsize
(
struct
pollfd
,
polls
,
pollmax
,
pollcnt
,
EMPTY2
);
polls
[
idx
].
fd
=
fd
;
}
assert
(
polls
[
idx
].
fd
==
fd
);
if
(
nev
)
polls
[
idx
].
events
=
(
nev
&
EV_READ
?
POLLIN
:
0
)
|
(
nev
&
EV_WRITE
?
POLLOUT
:
0
);
else
/* remove pollfd */
{
pollidxs
[
fd
]
=
-
1
;
if
(
expect_true
(
idx
<
--
pollcnt
))
{
polls
[
idx
]
=
polls
[
pollcnt
];
pollidxs
[
polls
[
idx
].
fd
]
=
idx
;
}
}
}
static
void
poll_poll
(
EV_P_
ev_tstamp
timeout
)
{
struct
pollfd
*
p
;
int
res
;
EV_RELEASE_CB
;
res
=
poll
(
polls
,
pollcnt
,
timeout
*
1e3
);
EV_ACQUIRE_CB
;
if
(
expect_false
(
res
<
0
))
{
if
(
errno
==
EBADF
)
fd_ebadf
(
EV_A
);
else
if
(
errno
==
ENOMEM
&&
!
syserr_cb
)
fd_enomem
(
EV_A
);
else
if
(
errno
!=
EINTR
)
ev_syserr
(
"(libev) poll"
);
}
else
for
(
p
=
polls
;
res
;
++
p
)
{
assert
((
"libev: poll() returned illegal result, broken BSD kernel?"
,
p
<
polls
+
pollcnt
));
if
(
expect_false
(
p
->
revents
))
/* this expect is debatable */
{
--
res
;
if
(
expect_false
(
p
->
revents
&
POLLNVAL
))
fd_kill
(
EV_A_
p
->
fd
);
else
fd_event
(
EV_A_
p
->
fd
,
(
p
->
revents
&
(
POLLOUT
|
POLLERR
|
POLLHUP
)
?
EV_WRITE
:
0
)
|
(
p
->
revents
&
(
POLLIN
|
POLLERR
|
POLLHUP
)
?
EV_READ
:
0
)
);
}
}
}
int
inline_size
poll_init
(
EV_P_
int
flags
)
{
backend_mintime
=
1e-3
;
backend_modify
=
poll_modify
;
backend_poll
=
poll_poll
;
pollidxs
=
0
;
pollidxmax
=
0
;
polls
=
0
;
pollmax
=
0
;
pollcnt
=
0
;
return
EVBACKEND_POLL
;
}
void
inline_size
poll_destroy
(
EV_P
)
{
ev_free
(
pollidxs
);
ev_free
(
polls
);
}
src/main/jni/libev/ev_port.c
deleted
100644 → 0
View file @
a21d099a
/*
* libev solaris event port backend
*
* Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
/* useful reading:
*
* http://bugs.opensolaris.org/view_bug.do?bug_id=6268715 (random results)
* http://bugs.opensolaris.org/view_bug.do?bug_id=6455223 (just totally broken)
* http://bugs.opensolaris.org/view_bug.do?bug_id=6873782 (manpage ETIME)
* http://bugs.opensolaris.org/view_bug.do?bug_id=6874410 (implementation ETIME)
* http://www.mail-archive.com/networking-discuss@opensolaris.org/msg11898.html ETIME vs. nget
* http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/lib/libc/port/gen/event_port.c (libc)
* http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/uts/common/fs/portfs/port.c#1325 (kernel)
*/
#include <sys/types.h>
#include <sys/time.h>
#include <poll.h>
#include <port.h>
#include <string.h>
#include <errno.h>
void
inline_speed
port_associate_and_check
(
EV_P_
int
fd
,
int
ev
)
{
if
(
0
>
port_associate
(
backend_fd
,
PORT_SOURCE_FD
,
fd
,
(
ev
&
EV_READ
?
POLLIN
:
0
)
|
(
ev
&
EV_WRITE
?
POLLOUT
:
0
),
0
)
)
{
if
(
errno
==
EBADFD
)
fd_kill
(
EV_A_
fd
);
else
ev_syserr
(
"(libev) port_associate"
);
}
}
static
void
port_modify
(
EV_P_
int
fd
,
int
oev
,
int
nev
)
{
/* we need to reassociate no matter what, as closes are
* once more silently being discarded.
*/
if
(
!
nev
)
{
if
(
oev
)
port_dissociate
(
backend_fd
,
PORT_SOURCE_FD
,
fd
);
}
else
port_associate_and_check
(
EV_A_
fd
,
nev
);
}
static
void
port_poll
(
EV_P_
ev_tstamp
timeout
)
{
int
res
,
i
;
struct
timespec
ts
;
uint_t
nget
=
1
;
/* we initialise this to something we will skip in the loop, as */
/* port_getn can return with nget unchanged, but no indication */
/* whether it was the original value or has been updated :/ */
port_events
[
0
].
portev_source
=
0
;
EV_RELEASE_CB
;
EV_TS_SET
(
ts
,
timeout
);
res
=
port_getn
(
backend_fd
,
port_events
,
port_eventmax
,
&
nget
,
&
ts
);
EV_ACQUIRE_CB
;
/* port_getn may or may not set nget on error */
/* so we rely on port_events [0].portev_source not being updated */
if
(
res
==
-
1
&&
errno
!=
ETIME
&&
errno
!=
EINTR
)
ev_syserr
(
"(libev) port_getn (see http://bugs.opensolaris.org/view_bug.do?bug_id=6268715, try LIBEV_FLAGS=3 env variable)"
);
for
(
i
=
0
;
i
<
nget
;
++
i
)
{
if
(
port_events
[
i
].
portev_source
==
PORT_SOURCE_FD
)
{
int
fd
=
port_events
[
i
].
portev_object
;
fd_event
(
EV_A_
fd
,
(
port_events
[
i
].
portev_events
&
(
POLLOUT
|
POLLERR
|
POLLHUP
)
?
EV_WRITE
:
0
)
|
(
port_events
[
i
].
portev_events
&
(
POLLIN
|
POLLERR
|
POLLHUP
)
?
EV_READ
:
0
)
);
fd_change
(
EV_A_
fd
,
EV__IOFDSET
);
}
}
if
(
expect_false
(
nget
==
port_eventmax
))
{
ev_free
(
port_events
);
port_eventmax
=
array_nextsize
(
sizeof
(
port_event_t
),
port_eventmax
,
port_eventmax
+
1
);
port_events
=
(
port_event_t
*
)
ev_malloc
(
sizeof
(
port_event_t
)
*
port_eventmax
);
}
}
int
inline_size
port_init
(
EV_P_
int
flags
)
{
/* Initialize the kernel queue */
if
((
backend_fd
=
port_create
())
<
0
)
return
0
;
assert
((
"libev: PORT_SOURCE_FD must not be zero"
,
PORT_SOURCE_FD
));
fcntl
(
backend_fd
,
F_SETFD
,
FD_CLOEXEC
);
/* not sure if necessary, hopefully doesn't hurt */
/* if my reading of the opensolaris kernel sources are correct, then
* opensolaris does something very stupid: it checks if the time has already
* elapsed and doesn't round up if that is the case,m otherwise it DOES round
* up. Since we can't know what the case is, we need to guess by using a
* "large enough" timeout. Normally, 1e-9 would be correct.
*/
backend_mintime
=
1e-3
;
/* needed to compensate for port_getn returning early */
backend_modify
=
port_modify
;
backend_poll
=
port_poll
;
port_eventmax
=
64
;
/* initial number of events receivable per poll */
port_events
=
(
port_event_t
*
)
ev_malloc
(
sizeof
(
port_event_t
)
*
port_eventmax
);
return
EVBACKEND_PORT
;
}
void
inline_size
port_destroy
(
EV_P
)
{
ev_free
(
port_events
);
}
void
inline_size
port_fork
(
EV_P
)
{
close
(
backend_fd
);
while
((
backend_fd
=
port_create
())
<
0
)
ev_syserr
(
"(libev) port"
);
fcntl
(
backend_fd
,
F_SETFD
,
FD_CLOEXEC
);
/* re-register interest in fds */
fd_rearm_all
(
EV_A
);
}
src/main/jni/libev/ev_select.c
deleted
100644 → 0
View file @
a21d099a
/*
* libev select fd activity backend
*
* Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
#ifndef _WIN32
/* for unix systems */
# include <inttypes.h>
# ifndef __hpux
/* for REAL unix systems */
# include <sys/select.h>
# endif
#endif
#ifndef EV_SELECT_USE_FD_SET
# ifdef NFDBITS
# define EV_SELECT_USE_FD_SET 0
# else
# define EV_SELECT_USE_FD_SET 1
# endif
#endif
#if EV_SELECT_IS_WINSOCKET
# undef EV_SELECT_USE_FD_SET
# define EV_SELECT_USE_FD_SET 1
# undef NFDBITS
# define NFDBITS 0
#endif
#if !EV_SELECT_USE_FD_SET
# define NFDBYTES (NFDBITS / 8)
#endif
#ifdef ANDROID
typedef
int
fd_mask
;
#endif
#include <string.h>
static
void
select_modify
(
EV_P_
int
fd
,
int
oev
,
int
nev
)
{
if
(
oev
==
nev
)
return
;
{
#if EV_SELECT_USE_FD_SET
#if EV_SELECT_IS_WINSOCKET
SOCKET
handle
=
anfds
[
fd
].
handle
;
#else
int
handle
=
fd
;
#endif
assert
((
"libev: fd >= FD_SETSIZE passed to fd_set-based select backend"
,
fd
<
FD_SETSIZE
));
/* FD_SET is broken on windows (it adds the fd to a set twice or more,
* which eventually leads to overflows). Need to call it only on changes.
*/
#if EV_SELECT_IS_WINSOCKET
if
((
oev
^
nev
)
&
EV_READ
)
#endif
if
(
nev
&
EV_READ
)
FD_SET
(
handle
,
(
fd_set
*
)
vec_ri
);
else
FD_CLR
(
handle
,
(
fd_set
*
)
vec_ri
);
#if EV_SELECT_IS_WINSOCKET
if
((
oev
^
nev
)
&
EV_WRITE
)
#endif
if
(
nev
&
EV_WRITE
)
FD_SET
(
handle
,
(
fd_set
*
)
vec_wi
);
else
FD_CLR
(
handle
,
(
fd_set
*
)
vec_wi
);
#else
int
word
=
fd
/
NFDBITS
;
fd_mask
mask
=
1UL
<<
(
fd
%
NFDBITS
);
if
(
expect_false
(
vec_max
<=
word
))
{
int
new_max
=
word
+
1
;
vec_ri
=
ev_realloc
(
vec_ri
,
new_max
*
NFDBYTES
);
vec_ro
=
ev_realloc
(
vec_ro
,
new_max
*
NFDBYTES
);
/* could free/malloc */
vec_wi
=
ev_realloc
(
vec_wi
,
new_max
*
NFDBYTES
);
vec_wo
=
ev_realloc
(
vec_wo
,
new_max
*
NFDBYTES
);
/* could free/malloc */
#ifdef _WIN32
vec_eo
=
ev_realloc
(
vec_eo
,
new_max
*
NFDBYTES
);
/* could free/malloc */
#endif
for
(;
vec_max
<
new_max
;
++
vec_max
)
((
fd_mask
*
)
vec_ri
)
[
vec_max
]
=
((
fd_mask
*
)
vec_wi
)
[
vec_max
]
=
0
;
}
((
fd_mask
*
)
vec_ri
)
[
word
]
|=
mask
;
if
(
!
(
nev
&
EV_READ
))
((
fd_mask
*
)
vec_ri
)
[
word
]
&=
~
mask
;
((
fd_mask
*
)
vec_wi
)
[
word
]
|=
mask
;
if
(
!
(
nev
&
EV_WRITE
))
((
fd_mask
*
)
vec_wi
)
[
word
]
&=
~
mask
;
#endif
}
}
static
void
select_poll
(
EV_P_
ev_tstamp
timeout
)
{
struct
timeval
tv
;
int
res
;
int
fd_setsize
;
EV_RELEASE_CB
;
EV_TV_SET
(
tv
,
timeout
);
#if EV_SELECT_USE_FD_SET
fd_setsize
=
sizeof
(
fd_set
);
#else
fd_setsize
=
vec_max
*
NFDBYTES
;
#endif
memcpy
(
vec_ro
,
vec_ri
,
fd_setsize
);
memcpy
(
vec_wo
,
vec_wi
,
fd_setsize
);
#ifdef _WIN32
/* pass in the write set as except set.
* the idea behind this is to work around a windows bug that causes
* errors to be reported as an exception and not by setting
* the writable bit. this is so uncontrollably lame.
*/
memcpy
(
vec_eo
,
vec_wi
,
fd_setsize
);
res
=
select
(
vec_max
*
NFDBITS
,
(
fd_set
*
)
vec_ro
,
(
fd_set
*
)
vec_wo
,
(
fd_set
*
)
vec_eo
,
&
tv
);
#elif EV_SELECT_USE_FD_SET
fd_setsize
=
anfdmax
<
FD_SETSIZE
?
anfdmax
:
FD_SETSIZE
;
res
=
select
(
fd_setsize
,
(
fd_set
*
)
vec_ro
,
(
fd_set
*
)
vec_wo
,
0
,
&
tv
);
#else
res
=
select
(
vec_max
*
NFDBITS
,
(
fd_set
*
)
vec_ro
,
(
fd_set
*
)
vec_wo
,
0
,
&
tv
);
#endif
EV_ACQUIRE_CB
;
if
(
expect_false
(
res
<
0
))
{
#if EV_SELECT_IS_WINSOCKET
errno
=
WSAGetLastError
();
#endif
#ifdef WSABASEERR
/* on windows, select returns incompatible error codes, fix this */
if
(
errno
>=
WSABASEERR
&&
errno
<
WSABASEERR
+
1000
)
if
(
errno
==
WSAENOTSOCK
)
errno
=
EBADF
;
else
errno
-=
WSABASEERR
;
#endif
#ifdef _WIN32
/* select on windows erroneously returns EINVAL when no fd sets have been
* provided (this is documented). what microsoft doesn't tell you that this bug
* exists even when the fd sets _are_ provided, so we have to check for this bug
* here and emulate by sleeping manually.
* we also get EINVAL when the timeout is invalid, but we ignore this case here
* and assume that EINVAL always means: you have to wait manually.
*/
if
(
errno
==
EINVAL
)
{
if
(
timeout
)
{
unsigned
long
ms
=
timeout
*
1e3
;
Sleep
(
ms
?
ms
:
1
);
}
return
;
}
#endif
if
(
errno
==
EBADF
)
fd_ebadf
(
EV_A
);
else
if
(
errno
==
ENOMEM
&&
!
syserr_cb
)
fd_enomem
(
EV_A
);
else
if
(
errno
!=
EINTR
)
ev_syserr
(
"(libev) select"
);
return
;
}
#if EV_SELECT_USE_FD_SET
{
int
fd
;
for
(
fd
=
0
;
fd
<
anfdmax
;
++
fd
)
if
(
anfds
[
fd
].
events
)
{
int
events
=
0
;
#if EV_SELECT_IS_WINSOCKET
SOCKET
handle
=
anfds
[
fd
].
handle
;
#else
int
handle
=
fd
;
#endif
if
(
FD_ISSET
(
handle
,
(
fd_set
*
)
vec_ro
))
events
|=
EV_READ
;
if
(
FD_ISSET
(
handle
,
(
fd_set
*
)
vec_wo
))
events
|=
EV_WRITE
;
#ifdef _WIN32
if
(
FD_ISSET
(
handle
,
(
fd_set
*
)
vec_eo
))
events
|=
EV_WRITE
;
#endif
if
(
expect_true
(
events
))
fd_event
(
EV_A_
fd
,
events
);
}
}
#else
{
int
word
,
bit
;
for
(
word
=
vec_max
;
word
--
;
)
{
fd_mask
word_r
=
((
fd_mask
*
)
vec_ro
)
[
word
];
fd_mask
word_w
=
((
fd_mask
*
)
vec_wo
)
[
word
];
#ifdef _WIN32
word_w
|=
((
fd_mask
*
)
vec_eo
)
[
word
];
#endif
if
(
word_r
||
word_w
)
for
(
bit
=
NFDBITS
;
bit
--
;
)
{
fd_mask
mask
=
1UL
<<
bit
;
int
events
=
0
;
events
|=
word_r
&
mask
?
EV_READ
:
0
;
events
|=
word_w
&
mask
?
EV_WRITE
:
0
;
if
(
expect_true
(
events
))
fd_event
(
EV_A_
word
*
NFDBITS
+
bit
,
events
);
}
}
}
#endif
}
int
inline_size
select_init
(
EV_P_
int
flags
)
{
backend_mintime
=
1e-6
;
backend_modify
=
select_modify
;
backend_poll
=
select_poll
;
#if EV_SELECT_USE_FD_SET
vec_ri
=
ev_malloc
(
sizeof
(
fd_set
));
FD_ZERO
((
fd_set
*
)
vec_ri
);
vec_ro
=
ev_malloc
(
sizeof
(
fd_set
));
vec_wi
=
ev_malloc
(
sizeof
(
fd_set
));
FD_ZERO
((
fd_set
*
)
vec_wi
);
vec_wo
=
ev_malloc
(
sizeof
(
fd_set
));
#ifdef _WIN32
vec_eo
=
ev_malloc
(
sizeof
(
fd_set
));
#endif
#else
vec_max
=
0
;
vec_ri
=
0
;
vec_ro
=
0
;
vec_wi
=
0
;
vec_wo
=
0
;
#ifdef _WIN32
vec_eo
=
0
;
#endif
#endif
return
EVBACKEND_SELECT
;
}
void
inline_size
select_destroy
(
EV_P
)
{
ev_free
(
vec_ri
);
ev_free
(
vec_ro
);
ev_free
(
vec_wi
);
ev_free
(
vec_wo
);
#ifdef _WIN32
ev_free
(
vec_eo
);
#endif
}
src/main/jni/libev/ev_vars.h
deleted
100644 → 0
View file @
a21d099a
/*
* loop member variable declarations
*
* Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
#define VARx(type,name) VAR(name, type name)
VARx
(
ev_tstamp
,
now_floor
)
/* last time we refreshed rt_time */
VARx
(
ev_tstamp
,
mn_now
)
/* monotonic clock "now" */
VARx
(
ev_tstamp
,
rtmn_diff
)
/* difference realtime - monotonic time */
VARx
(
ev_tstamp
,
io_blocktime
)
VARx
(
ev_tstamp
,
timeout_blocktime
)
VARx
(
int
,
backend
)
VARx
(
int
,
activecnt
)
/* total number of active events ("refcount") */
VARx
(
EV_ATOMIC_T
,
loop_done
)
/* signal by ev_break */
VARx
(
int
,
backend_fd
)
VARx
(
ev_tstamp
,
backend_mintime
)
/* assumed typical timer resolution */
VAR
(
backend_modify
,
void
(
*
backend_modify
)(
EV_P_
int
fd
,
int
oev
,
int
nev
))
VAR
(
backend_poll
,
void
(
*
backend_poll
)(
EV_P_
ev_tstamp
timeout
))
VARx
(
ANFD
*
,
anfds
)
VARx
(
int
,
anfdmax
)
VAR
(
pendings
,
ANPENDING
*
pendings
[
NUMPRI
])
VAR
(
pendingmax
,
int
pendingmax
[
NUMPRI
])
VAR
(
pendingcnt
,
int
pendingcnt
[
NUMPRI
])
VARx
(
ev_prepare
,
pending_w
)
/* dummy pending watcher */
/* for reverse feeding of events */
VARx
(
W
*
,
rfeeds
)
VARx
(
int
,
rfeedmax
)
VARx
(
int
,
rfeedcnt
)
#if EV_USE_EVENTFD || EV_GENWRAP
VARx
(
int
,
evfd
)
#endif
VAR
(
evpipe
,
int
evpipe
[
2
])
VARx
(
ev_io
,
pipe_w
)
VARx
(
EV_ATOMIC_T
,
pipe_write_wanted
)
VARx
(
EV_ATOMIC_T
,
pipe_write_skipped
)
#if !defined(_WIN32) || EV_GENWRAP
VARx
(
pid_t
,
curpid
)
#endif
VARx
(
char
,
postfork
)
/* true if we need to recreate kernel state after fork */
#if EV_USE_SELECT || EV_GENWRAP
VARx
(
void
*
,
vec_ri
)
VARx
(
void
*
,
vec_ro
)
VARx
(
void
*
,
vec_wi
)
VARx
(
void
*
,
vec_wo
)
#if defined(_WIN32) || EV_GENWRAP
VARx
(
void
*
,
vec_eo
)
#endif
VARx
(
int
,
vec_max
)
#endif
#if EV_USE_POLL || EV_GENWRAP
VARx
(
struct
pollfd
*
,
polls
)
VARx
(
int
,
pollmax
)
VARx
(
int
,
pollcnt
)
VARx
(
int
*
,
pollidxs
)
/* maps fds into structure indices */
VARx
(
int
,
pollidxmax
)
#endif
#if EV_USE_EPOLL || EV_GENWRAP
VARx
(
struct
epoll_event
*
,
epoll_events
)
VARx
(
int
,
epoll_eventmax
)
VARx
(
int
*
,
epoll_eperms
)
VARx
(
int
,
epoll_epermcnt
)
VARx
(
int
,
epoll_epermmax
)
#endif
#if EV_USE_KQUEUE || EV_GENWRAP
VARx
(
struct
kevent
*
,
kqueue_changes
)
VARx
(
int
,
kqueue_changemax
)
VARx
(
int
,
kqueue_changecnt
)
VARx
(
struct
kevent
*
,
kqueue_events
)
VARx
(
int
,
kqueue_eventmax
)
#endif
#if EV_USE_PORT || EV_GENWRAP
VARx
(
struct
port_event
*
,
port_events
)
VARx
(
int
,
port_eventmax
)
#endif
#if EV_USE_IOCP || EV_GENWRAP
VARx
(
HANDLE
,
iocp
)
#endif
VARx
(
int
*
,
fdchanges
)
VARx
(
int
,
fdchangemax
)
VARx
(
int
,
fdchangecnt
)
VARx
(
ANHE
*
,
timers
)
VARx
(
int
,
timermax
)
VARx
(
int
,
timercnt
)
#if EV_PERIODIC_ENABLE || EV_GENWRAP
VARx
(
ANHE
*
,
periodics
)
VARx
(
int
,
periodicmax
)
VARx
(
int
,
periodiccnt
)
#endif
#if EV_IDLE_ENABLE || EV_GENWRAP
VAR
(
idles
,
ev_idle
**
idles
[
NUMPRI
])
VAR
(
idlemax
,
int
idlemax
[
NUMPRI
])
VAR
(
idlecnt
,
int
idlecnt
[
NUMPRI
])
#endif
VARx
(
int
,
idleall
)
/* total number */
VARx
(
struct
ev_prepare
**
,
prepares
)
VARx
(
int
,
preparemax
)
VARx
(
int
,
preparecnt
)
VARx
(
struct
ev_check
**
,
checks
)
VARx
(
int
,
checkmax
)
VARx
(
int
,
checkcnt
)
#if EV_FORK_ENABLE || EV_GENWRAP
VARx
(
struct
ev_fork
**
,
forks
)
VARx
(
int
,
forkmax
)
VARx
(
int
,
forkcnt
)
#endif
#if EV_CLEANUP_ENABLE || EV_GENWRAP
VARx
(
struct
ev_cleanup
**
,
cleanups
)
VARx
(
int
,
cleanupmax
)
VARx
(
int
,
cleanupcnt
)
#endif
#if EV_ASYNC_ENABLE || EV_GENWRAP
VARx
(
EV_ATOMIC_T
,
async_pending
)
VARx
(
struct
ev_async
**
,
asyncs
)
VARx
(
int
,
asyncmax
)
VARx
(
int
,
asynccnt
)
#endif
#if EV_USE_INOTIFY || EV_GENWRAP
VARx
(
int
,
fs_fd
)
VARx
(
ev_io
,
fs_w
)
VARx
(
char
,
fs_2625
)
/* whether we are running in linux 2.6.25 or newer */
VAR
(
fs_hash
,
ANFS
fs_hash
[
EV_INOTIFY_HASHSIZE
])
#endif
VARx
(
EV_ATOMIC_T
,
sig_pending
)
#if EV_USE_SIGNALFD || EV_GENWRAP
VARx
(
int
,
sigfd
)
VARx
(
ev_io
,
sigfd_w
)
VARx
(
sigset_t
,
sigfd_set
)
#endif
VARx
(
unsigned
int
,
origflags
)
/* original loop flags */
#if EV_FEATURE_API || EV_GENWRAP
VARx
(
unsigned
int
,
loop_count
)
/* total number of loop iterations/blocks */
VARx
(
unsigned
int
,
loop_depth
)
/* #ev_run enters - #ev_run leaves */
VARx
(
void
*
,
userdata
)
VAR
(
release_cb
,
void
(
*
release_cb
)(
EV_P
))
VAR
(
acquire_cb
,
void
(
*
acquire_cb
)(
EV_P
))
VAR
(
invoke_cb
,
void
(
*
invoke_cb
)
(
EV_P
))
#endif
#undef VARx
src/main/jni/libev/ev_win32.c
deleted
100644 → 0
View file @
a21d099a
/*
* libev win32 compatibility cruft (_not_ a backend)
*
* Copyright (c) 2007,2008,2009 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
#ifdef _WIN32
/* timeb.h is actually xsi legacy functionality */
#include <sys/timeb.h>
/* note: the comment below could not be substantiated, but what would I care */
/* MSDN says this is required to handle SIGFPE */
/* my wild guess would be that using something floating-pointy is required */
/* for the crt to do something about it */
volatile
double
SIGFPE_REQ
=
0
.
0
f
;
/* oh, the humanity! */
static
int
ev_pipe
(
int
filedes
[
2
])
{
struct
sockaddr_in
addr
=
{
0
};
int
addr_size
=
sizeof
(
addr
);
struct
sockaddr_in
adr2
;
int
adr2_size
=
sizeof
(
adr2
);
SOCKET
listener
;
SOCKET
sock
[
2
]
=
{
-
1
,
-
1
};
if
((
listener
=
socket
(
AF_INET
,
SOCK_STREAM
,
0
))
==
INVALID_SOCKET
)
return
-
1
;
addr
.
sin_family
=
AF_INET
;
addr
.
sin_addr
.
s_addr
=
htonl
(
INADDR_LOOPBACK
);
addr
.
sin_port
=
0
;
if
(
bind
(
listener
,
(
struct
sockaddr
*
)
&
addr
,
addr_size
))
goto
fail
;
if
(
getsockname
(
listener
,
(
struct
sockaddr
*
)
&
addr
,
&
addr_size
))
goto
fail
;
if
(
listen
(
listener
,
1
))
goto
fail
;
if
((
sock
[
0
]
=
socket
(
AF_INET
,
SOCK_STREAM
,
0
))
==
INVALID_SOCKET
)
goto
fail
;
if
(
connect
(
sock
[
0
],
(
struct
sockaddr
*
)
&
addr
,
addr_size
))
goto
fail
;
if
((
sock
[
1
]
=
accept
(
listener
,
0
,
0
))
<
0
)
goto
fail
;
/* windows vista returns fantasy port numbers for sockets:
* example for two interconnected tcp sockets:
*
* (Socket::unpack_sockaddr_in getsockname $sock0)[0] == 53364
* (Socket::unpack_sockaddr_in getpeername $sock0)[0] == 53363
* (Socket::unpack_sockaddr_in getsockname $sock1)[0] == 53363
* (Socket::unpack_sockaddr_in getpeername $sock1)[0] == 53365
*
* wow! tridirectional sockets!
*
* this way of checking ports seems to work:
*/
if
(
getpeername
(
sock
[
0
],
(
struct
sockaddr
*
)
&
addr
,
&
addr_size
))
goto
fail
;
if
(
getsockname
(
sock
[
1
],
(
struct
sockaddr
*
)
&
adr2
,
&
adr2_size
))
goto
fail
;
errno
=
WSAEINVAL
;
if
(
addr_size
!=
adr2_size
||
addr
.
sin_addr
.
s_addr
!=
adr2
.
sin_addr
.
s_addr
/* just to be sure, I mean, it's windows */
||
addr
.
sin_port
!=
adr2
.
sin_port
)
goto
fail
;
closesocket
(
listener
);
#if EV_SELECT_IS_WINSOCKET
filedes
[
0
]
=
EV_WIN32_HANDLE_TO_FD
(
sock
[
0
]);
filedes
[
1
]
=
EV_WIN32_HANDLE_TO_FD
(
sock
[
1
]);
#else
/* when select isn't winsocket, we also expect socket, connect, accept etc.
* to work on fds */
filedes
[
0
]
=
sock
[
0
];
filedes
[
1
]
=
sock
[
1
];
#endif
return
0
;
fail:
closesocket
(
listener
);
if
(
sock
[
0
]
!=
INVALID_SOCKET
)
closesocket
(
sock
[
0
]);
if
(
sock
[
1
]
!=
INVALID_SOCKET
)
closesocket
(
sock
[
1
]);
return
-
1
;
}
#undef pipe
#define pipe(filedes) ev_pipe (filedes)
#define EV_HAVE_EV_TIME 1
ev_tstamp
ev_time
(
void
)
{
FILETIME
ft
;
ULARGE_INTEGER
ui
;
GetSystemTimeAsFileTime
(
&
ft
);
ui
.
u
.
LowPart
=
ft
.
dwLowDateTime
;
ui
.
u
.
HighPart
=
ft
.
dwHighDateTime
;
/* msvc cannot convert ulonglong to double... yes, it is that sucky */
return
(
LONGLONG
)(
ui
.
QuadPart
-
116444736000000000
)
*
1e-7
;
}
#endif
src/main/jni/libev/ev_wrap.h
deleted
100644 → 0
View file @
a21d099a
/* DO NOT EDIT, automatically generated by update_ev_wrap */
#ifndef EV_WRAP_H
#define EV_WRAP_H
#define now_floor ((loop)->now_floor)
#define mn_now ((loop)->mn_now)
#define rtmn_diff ((loop)->rtmn_diff)
#define io_blocktime ((loop)->io_blocktime)
#define timeout_blocktime ((loop)->timeout_blocktime)
#define backend ((loop)->backend)
#define activecnt ((loop)->activecnt)
#define loop_done ((loop)->loop_done)
#define backend_fd ((loop)->backend_fd)
#define backend_mintime ((loop)->backend_mintime)
#define backend_modify ((loop)->backend_modify)
#define backend_poll ((loop)->backend_poll)
#define anfds ((loop)->anfds)
#define anfdmax ((loop)->anfdmax)
#define pendings ((loop)->pendings)
#define pendingmax ((loop)->pendingmax)
#define pendingcnt ((loop)->pendingcnt)
#define pending_w ((loop)->pending_w)
#define rfeeds ((loop)->rfeeds)
#define rfeedmax ((loop)->rfeedmax)
#define rfeedcnt ((loop)->rfeedcnt)
#define evfd ((loop)->evfd)
#define evpipe ((loop)->evpipe)
#define pipe_w ((loop)->pipe_w)
#define pipe_write_wanted ((loop)->pipe_write_wanted)
#define pipe_write_skipped ((loop)->pipe_write_skipped)
#define curpid ((loop)->curpid)
#define postfork ((loop)->postfork)
#define vec_ri ((loop)->vec_ri)
#define vec_ro ((loop)->vec_ro)
#define vec_wi ((loop)->vec_wi)
#define vec_wo ((loop)->vec_wo)
#define vec_eo ((loop)->vec_eo)
#define vec_max ((loop)->vec_max)
#define polls ((loop)->polls)
#define pollmax ((loop)->pollmax)
#define pollcnt ((loop)->pollcnt)
#define pollidxs ((loop)->pollidxs)
#define pollidxmax ((loop)->pollidxmax)
#define epoll_events ((loop)->epoll_events)
#define epoll_eventmax ((loop)->epoll_eventmax)
#define epoll_eperms ((loop)->epoll_eperms)
#define epoll_epermcnt ((loop)->epoll_epermcnt)
#define epoll_epermmax ((loop)->epoll_epermmax)
#define kqueue_changes ((loop)->kqueue_changes)
#define kqueue_changemax ((loop)->kqueue_changemax)
#define kqueue_changecnt ((loop)->kqueue_changecnt)
#define kqueue_events ((loop)->kqueue_events)
#define kqueue_eventmax ((loop)->kqueue_eventmax)
#define port_events ((loop)->port_events)
#define port_eventmax ((loop)->port_eventmax)
#define iocp ((loop)->iocp)
#define fdchanges ((loop)->fdchanges)
#define fdchangemax ((loop)->fdchangemax)
#define fdchangecnt ((loop)->fdchangecnt)
#define timers ((loop)->timers)
#define timermax ((loop)->timermax)
#define timercnt ((loop)->timercnt)
#define periodics ((loop)->periodics)
#define periodicmax ((loop)->periodicmax)
#define periodiccnt ((loop)->periodiccnt)
#define idles ((loop)->idles)
#define idlemax ((loop)->idlemax)
#define idlecnt ((loop)->idlecnt)
#define idleall ((loop)->idleall)
#define prepares ((loop)->prepares)
#define preparemax ((loop)->preparemax)
#define preparecnt ((loop)->preparecnt)
#define checks ((loop)->checks)
#define checkmax ((loop)->checkmax)
#define checkcnt ((loop)->checkcnt)
#define forks ((loop)->forks)
#define forkmax ((loop)->forkmax)
#define forkcnt ((loop)->forkcnt)
#define cleanups ((loop)->cleanups)
#define cleanupmax ((loop)->cleanupmax)
#define cleanupcnt ((loop)->cleanupcnt)
#define async_pending ((loop)->async_pending)
#define asyncs ((loop)->asyncs)
#define asyncmax ((loop)->asyncmax)
#define asynccnt ((loop)->asynccnt)
#define fs_fd ((loop)->fs_fd)
#define fs_w ((loop)->fs_w)
#define fs_2625 ((loop)->fs_2625)
#define fs_hash ((loop)->fs_hash)
#define sig_pending ((loop)->sig_pending)
#define sigfd ((loop)->sigfd)
#define sigfd_w ((loop)->sigfd_w)
#define sigfd_set ((loop)->sigfd_set)
#define origflags ((loop)->origflags)
#define loop_count ((loop)->loop_count)
#define loop_depth ((loop)->loop_depth)
#define userdata ((loop)->userdata)
#define release_cb ((loop)->release_cb)
#define acquire_cb ((loop)->acquire_cb)
#define invoke_cb ((loop)->invoke_cb)
#else
#undef EV_WRAP_H
#undef now_floor
#undef mn_now
#undef rtmn_diff
#undef io_blocktime
#undef timeout_blocktime
#undef backend
#undef activecnt
#undef loop_done
#undef backend_fd
#undef backend_mintime
#undef backend_modify
#undef backend_poll
#undef anfds
#undef anfdmax
#undef pendings
#undef pendingmax
#undef pendingcnt
#undef pending_w
#undef rfeeds
#undef rfeedmax
#undef rfeedcnt
#undef evfd
#undef evpipe
#undef pipe_w
#undef pipe_write_wanted
#undef pipe_write_skipped
#undef curpid
#undef postfork
#undef vec_ri
#undef vec_ro
#undef vec_wi
#undef vec_wo
#undef vec_eo
#undef vec_max
#undef polls
#undef pollmax
#undef pollcnt
#undef pollidxs
#undef pollidxmax
#undef epoll_events
#undef epoll_eventmax
#undef epoll_eperms
#undef epoll_epermcnt
#undef epoll_epermmax
#undef kqueue_changes
#undef kqueue_changemax
#undef kqueue_changecnt
#undef kqueue_events
#undef kqueue_eventmax
#undef port_events
#undef port_eventmax
#undef iocp
#undef fdchanges
#undef fdchangemax
#undef fdchangecnt
#undef timers
#undef timermax
#undef timercnt
#undef periodics
#undef periodicmax
#undef periodiccnt
#undef idles
#undef idlemax
#undef idlecnt
#undef idleall
#undef prepares
#undef preparemax
#undef preparecnt
#undef checks
#undef checkmax
#undef checkcnt
#undef forks
#undef forkmax
#undef forkcnt
#undef cleanups
#undef cleanupmax
#undef cleanupcnt
#undef async_pending
#undef asyncs
#undef asyncmax
#undef asynccnt
#undef fs_fd
#undef fs_w
#undef fs_2625
#undef fs_hash
#undef sig_pending
#undef sigfd
#undef sigfd_w
#undef sigfd_set
#undef origflags
#undef loop_count
#undef loop_depth
#undef userdata
#undef release_cb
#undef acquire_cb
#undef invoke_cb
#endif
src/main/jni/libev/event.c
deleted
100644 → 0
View file @
a21d099a
/*
* libevent compatibility layer
*
* Copyright (c) 2007,2008,2009,2010 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
#include <stddef.h>
#include <stdlib.h>
#include <assert.h>
#ifdef EV_EVENT_H
# include EV_EVENT_H
#else
# include "event.h"
#endif
#if EV_MULTIPLICITY
# define dLOOPev struct ev_loop *loop = (struct ev_loop *)ev->ev_base
# define dLOOPbase struct ev_loop *loop = (struct ev_loop *)base
#else
# define dLOOPev
# define dLOOPbase
#endif
/* never accessed, will always be cast from/to ev_loop */
struct
event_base
{
int
dummy
;
};
static
struct
event_base
*
ev_x_cur
;
static
ev_tstamp
ev_tv_get
(
struct
timeval
*
tv
)
{
if
(
tv
)
{
ev_tstamp
after
=
tv
->
tv_sec
+
tv
->
tv_usec
*
1e-6
;
return
after
?
after
:
1e-6
;
}
else
return
-
1
.;
}
#define EVENT_STRINGIFY(s) # s
#define EVENT_VERSION(a,b) EVENT_STRINGIFY (a) "." EVENT_STRINGIFY (b)
const
char
*
event_get_version
(
void
)
{
/* returns ABI, not API or library, version */
return
EVENT_VERSION
(
EV_VERSION_MAJOR
,
EV_VERSION_MINOR
);
}
const
char
*
event_get_method
(
void
)
{
return
"libev"
;
}
void
*
event_init
(
void
)
{
#if EV_MULTIPLICITY
if
(
ev_x_cur
)
ev_x_cur
=
(
struct
event_base
*
)
ev_loop_new
(
EVFLAG_AUTO
);
else
ev_x_cur
=
(
struct
event_base
*
)
ev_default_loop
(
EVFLAG_AUTO
);
#else
assert
((
"libev: multiple event bases not supported when not compiled with EV_MULTIPLICITY"
,
!
ev_x_cur
));
ev_x_cur
=
(
struct
event_base
*
)(
long
)
ev_default_loop
(
EVFLAG_AUTO
);
#endif
return
ev_x_cur
;
}
void
event_base_free
(
struct
event_base
*
base
)
{
dLOOPbase
;
#if EV_MULTIPLICITY
if
(
!
ev_is_default_loop
(
loop
))
ev_loop_destroy
(
loop
);
#endif
}
int
event_dispatch
(
void
)
{
return
event_base_dispatch
(
ev_x_cur
);
}
#ifdef EV_STANDALONE
void
event_set_log_callback
(
event_log_cb
cb
)
{
/* nop */
}
#endif
int
event_loop
(
int
flags
)
{
return
event_base_loop
(
ev_x_cur
,
flags
);
}
int
event_loopexit
(
struct
timeval
*
tv
)
{
return
event_base_loopexit
(
ev_x_cur
,
tv
);
}
static
void
ev_x_cb
(
struct
event
*
ev
,
int
revents
)
{
revents
&=
EV_READ
|
EV_WRITE
|
EV_TIMER
|
EV_SIGNAL
;
ev
->
ev_res
=
revents
;
ev
->
ev_callback
(
ev
->
ev_fd
,
(
short
)
revents
,
ev
->
ev_arg
);
}
static
void
ev_x_cb_sig
(
EV_P_
struct
ev_signal
*
w
,
int
revents
)
{
struct
event
*
ev
=
(
struct
event
*
)(((
char
*
)
w
)
-
offsetof
(
struct
event
,
iosig
.
sig
));
if
(
revents
&
EV_ERROR
)
event_del
(
ev
);
ev_x_cb
(
ev
,
revents
);
}
static
void
ev_x_cb_io
(
EV_P_
struct
ev_io
*
w
,
int
revents
)
{
struct
event
*
ev
=
(
struct
event
*
)(((
char
*
)
w
)
-
offsetof
(
struct
event
,
iosig
.
io
));
if
((
revents
&
EV_ERROR
)
||
!
(
ev
->
ev_events
&
EV_PERSIST
))
event_del
(
ev
);
ev_x_cb
(
ev
,
revents
);
}
static
void
ev_x_cb_to
(
EV_P_
struct
ev_timer
*
w
,
int
revents
)
{
struct
event
*
ev
=
(
struct
event
*
)(((
char
*
)
w
)
-
offsetof
(
struct
event
,
to
));
event_del
(
ev
);
ev_x_cb
(
ev
,
revents
);
}
void
event_set
(
struct
event
*
ev
,
int
fd
,
short
events
,
void
(
*
cb
)(
int
,
short
,
void
*
),
void
*
arg
)
{
if
(
events
&
EV_SIGNAL
)
ev_init
(
&
ev
->
iosig
.
sig
,
ev_x_cb_sig
);
else
ev_init
(
&
ev
->
iosig
.
io
,
ev_x_cb_io
);
ev_init
(
&
ev
->
to
,
ev_x_cb_to
);
ev
->
ev_base
=
ev_x_cur
;
/* not threadsafe, but it's how libevent works */
ev
->
ev_fd
=
fd
;
ev
->
ev_events
=
events
;
ev
->
ev_pri
=
0
;
ev
->
ev_callback
=
cb
;
ev
->
ev_arg
=
arg
;
ev
->
ev_res
=
0
;
ev
->
ev_flags
=
EVLIST_INIT
;
}
int
event_once
(
int
fd
,
short
events
,
void
(
*
cb
)(
int
,
short
,
void
*
),
void
*
arg
,
struct
timeval
*
tv
)
{
return
event_base_once
(
ev_x_cur
,
fd
,
events
,
cb
,
arg
,
tv
);
}
int
event_add
(
struct
event
*
ev
,
struct
timeval
*
tv
)
{
dLOOPev
;
if
(
ev
->
ev_events
&
EV_SIGNAL
)
{
if
(
!
ev_is_active
(
&
ev
->
iosig
.
sig
))
{
ev_signal_set
(
&
ev
->
iosig
.
sig
,
ev
->
ev_fd
);
ev_signal_start
(
EV_A_
&
ev
->
iosig
.
sig
);
ev
->
ev_flags
|=
EVLIST_SIGNAL
;
}
}
else
if
(
ev
->
ev_events
&
(
EV_READ
|
EV_WRITE
))
{
if
(
!
ev_is_active
(
&
ev
->
iosig
.
io
))
{
ev_io_set
(
&
ev
->
iosig
.
io
,
ev
->
ev_fd
,
ev
->
ev_events
&
(
EV_READ
|
EV_WRITE
));
ev_io_start
(
EV_A_
&
ev
->
iosig
.
io
);
ev
->
ev_flags
|=
EVLIST_INSERTED
;
}
}
if
(
tv
)
{
ev
->
to
.
repeat
=
ev_tv_get
(
tv
);
ev_timer_again
(
EV_A_
&
ev
->
to
);
ev
->
ev_flags
|=
EVLIST_TIMEOUT
;
}
else
{
ev_timer_stop
(
EV_A_
&
ev
->
to
);
ev
->
ev_flags
&=
~
EVLIST_TIMEOUT
;
}
ev
->
ev_flags
|=
EVLIST_ACTIVE
;
return
0
;
}
int
event_del
(
struct
event
*
ev
)
{
dLOOPev
;
if
(
ev
->
ev_events
&
EV_SIGNAL
)
ev_signal_stop
(
EV_A_
&
ev
->
iosig
.
sig
);
else
if
(
ev
->
ev_events
&
(
EV_READ
|
EV_WRITE
))
ev_io_stop
(
EV_A_
&
ev
->
iosig
.
io
);
if
(
ev_is_active
(
&
ev
->
to
))
ev_timer_stop
(
EV_A_
&
ev
->
to
);
ev
->
ev_flags
=
EVLIST_INIT
;
return
0
;
}
void
event_active
(
struct
event
*
ev
,
int
res
,
short
ncalls
)
{
dLOOPev
;
if
(
res
&
EV_TIMEOUT
)
ev_feed_event
(
EV_A_
&
ev
->
to
,
res
&
EV_TIMEOUT
);
if
(
res
&
EV_SIGNAL
)
ev_feed_event
(
EV_A_
&
ev
->
iosig
.
sig
,
res
&
EV_SIGNAL
);
if
(
res
&
(
EV_READ
|
EV_WRITE
))
ev_feed_event
(
EV_A_
&
ev
->
iosig
.
io
,
res
&
(
EV_READ
|
EV_WRITE
));
}
int
event_pending
(
struct
event
*
ev
,
short
events
,
struct
timeval
*
tv
)
{
short
revents
=
0
;
dLOOPev
;
if
(
ev
->
ev_events
&
EV_SIGNAL
)
{
/* sig */
if
(
ev_is_active
(
&
ev
->
iosig
.
sig
)
||
ev_is_pending
(
&
ev
->
iosig
.
sig
))
revents
|=
EV_SIGNAL
;
}
else
if
(
ev
->
ev_events
&
(
EV_READ
|
EV_WRITE
))
{
/* io */
if
(
ev_is_active
(
&
ev
->
iosig
.
io
)
||
ev_is_pending
(
&
ev
->
iosig
.
io
))
revents
|=
ev
->
ev_events
&
(
EV_READ
|
EV_WRITE
);
}
if
(
ev
->
ev_events
&
EV_TIMEOUT
||
ev_is_active
(
&
ev
->
to
)
||
ev_is_pending
(
&
ev
->
to
))
{
revents
|=
EV_TIMEOUT
;
if
(
tv
)
{
ev_tstamp
at
=
ev_now
(
EV_A
);
tv
->
tv_sec
=
(
long
)
at
;
tv
->
tv_usec
=
(
long
)((
at
-
(
ev_tstamp
)
tv
->
tv_sec
)
*
1e6
);
}
}
return
events
&
revents
;
}
int
event_priority_init
(
int
npri
)
{
return
event_base_priority_init
(
ev_x_cur
,
npri
);
}
int
event_priority_set
(
struct
event
*
ev
,
int
pri
)
{
ev
->
ev_pri
=
pri
;
return
0
;
}
int
event_base_set
(
struct
event_base
*
base
,
struct
event
*
ev
)
{
ev
->
ev_base
=
base
;
return
0
;
}
int
event_base_loop
(
struct
event_base
*
base
,
int
flags
)
{
dLOOPbase
;
ev_run
(
EV_A_
flags
);
return
0
;
}
int
event_base_dispatch
(
struct
event_base
*
base
)
{
return
event_base_loop
(
base
,
0
);
}
static
void
ev_x_loopexit_cb
(
int
revents
,
void
*
base
)
{
dLOOPbase
;
ev_break
(
EV_A_
EVBREAK_ONE
);
}
int
event_base_loopexit
(
struct
event_base
*
base
,
struct
timeval
*
tv
)
{
ev_tstamp
after
=
ev_tv_get
(
tv
);
dLOOPbase
;
ev_once
(
EV_A_
-
1
,
0
,
after
>=
0
.
?
after
:
0
.,
ev_x_loopexit_cb
,
(
void
*
)
base
);
return
0
;
}
struct
ev_x_once
{
int
fd
;
void
(
*
cb
)(
int
,
short
,
void
*
);
void
*
arg
;
};
static
void
ev_x_once_cb
(
int
revents
,
void
*
arg
)
{
struct
ev_x_once
*
once
=
(
struct
ev_x_once
*
)
arg
;
once
->
cb
(
once
->
fd
,
(
short
)
revents
,
once
->
arg
);
free
(
once
);
}
int
event_base_once
(
struct
event_base
*
base
,
int
fd
,
short
events
,
void
(
*
cb
)(
int
,
short
,
void
*
),
void
*
arg
,
struct
timeval
*
tv
)
{
struct
ev_x_once
*
once
=
(
struct
ev_x_once
*
)
malloc
(
sizeof
(
struct
ev_x_once
));
dLOOPbase
;
if
(
!
once
)
return
-
1
;
once
->
fd
=
fd
;
once
->
cb
=
cb
;
once
->
arg
=
arg
;
ev_once
(
EV_A_
fd
,
events
&
(
EV_READ
|
EV_WRITE
),
ev_tv_get
(
tv
),
ev_x_once_cb
,
(
void
*
)
once
);
return
0
;
}
int
event_base_priority_init
(
struct
event_base
*
base
,
int
npri
)
{
/*dLOOPbase;*/
return
0
;
}
src/main/jni/libev/event.h
deleted
100644 → 0
View file @
a21d099a
/*
* libevent compatibility header, only core events supported
*
* Copyright (c) 2007,2008,2010 Marc Alexander Lehmann <libev@schmorp.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modifica-
* tion, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License ("GPL") version 2 or any later version,
* in which case the provisions of the GPL are applicable instead of
* the above. If you wish to allow the use of your version of this file
* only under the terms of the GPL and not to allow others to use your
* version of this file under the BSD license, indicate your decision
* by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file under
* either the BSD or the GPL.
*/
#ifndef EVENT_H_
#define EVENT_H_
#ifdef EV_H
# include EV_H
#else
# include "ev.h"
#endif
#ifndef EVLOOP_NONBLOCK
# define EVLOOP_NONBLOCK EVRUN_NOWAIT
#endif
#ifndef EVLOOP_ONESHOT
# define EVLOOP_ONESHOT EVRUN_ONCE
#endif
#ifndef EV_TIMEOUT
# define EV_TIMEOUT EV_TIMER
#endif
#ifdef __cplusplus
extern
"C"
{
#endif
/* we need sys/time.h for struct timeval only */
#if !defined (WIN32) || defined (__MINGW32__)
# include <time.h>
/* mingw seems to need this, for whatever reason */
# include <sys/time.h>
#endif
struct
event_base
;
#define EVLIST_TIMEOUT 0x01
#define EVLIST_INSERTED 0x02
#define EVLIST_SIGNAL 0x04
#define EVLIST_ACTIVE 0x08
#define EVLIST_INTERNAL 0x10
#define EVLIST_INIT 0x80
struct
event
{
/* libev watchers we map onto */
union
{
struct
ev_io
io
;
struct
ev_signal
sig
;
}
iosig
;
struct
ev_timer
to
;
/* compatibility slots */
struct
event_base
*
ev_base
;
void
(
*
ev_callback
)(
int
,
short
,
void
*
arg
);
void
*
ev_arg
;
int
ev_fd
;
int
ev_pri
;
int
ev_res
;
int
ev_flags
;
short
ev_events
;
};
#define EV_READ EV_READ
#define EV_WRITE EV_WRITE
#define EV_PERSIST 0x10
#define EVENT_SIGNAL(ev) ((int) (ev)->ev_fd)
#define EVENT_FD(ev) ((int) (ev)->ev_fd)
#define event_initialized(ev) ((ev)->ev_flags & EVLIST_INIT)
#define evtimer_add(ev,tv) event_add (ev, tv)
#define evtimer_set(ev,cb,data) event_set (ev, -1, 0, cb, data)
#define evtimer_del(ev) event_del (ev)
#define evtimer_pending(ev,tv) event_pending (ev, EV_TIMEOUT, tv)
#define evtimer_initialized(ev) event_initialized (ev)
#define timeout_add(ev,tv) evtimer_add (ev, tv)
#define timeout_set(ev,cb,data) evtimer_set (ev, cb, data)
#define timeout_del(ev) evtimer_del (ev)
#define timeout_pending(ev,tv) evtimer_pending (ev, tv)
#define timeout_initialized(ev) evtimer_initialized (ev)
#define signal_add(ev,tv) event_add (ev, tv)
#define signal_set(ev,sig,cb,data) event_set (ev, sig, EV_SIGNAL | EV_PERSIST, cb, data)
#define signal_del(ev) event_del (ev)
#define signal_pending(ev,tv) event_pending (ev, EV_SIGNAL, tv)
#define signal_initialized(ev) event_initialized (ev)
const
char
*
event_get_version
(
void
);
const
char
*
event_get_method
(
void
);
void
*
event_init
(
void
);
void
event_base_free
(
struct
event_base
*
base
);
#define EVLOOP_ONCE EVLOOP_ONESHOT
int
event_loop
(
int
);
int
event_loopexit
(
struct
timeval
*
tv
);
int
event_dispatch
(
void
);
#define _EVENT_LOG_DEBUG 0
#define _EVENT_LOG_MSG 1
#define _EVENT_LOG_WARN 2
#define _EVENT_LOG_ERR 3
typedef
void
(
*
event_log_cb
)(
int
severity
,
const
char
*
msg
);
void
event_set_log_callback
(
event_log_cb
cb
);
void
event_set
(
struct
event
*
ev
,
int
fd
,
short
events
,
void
(
*
cb
)(
int
,
short
,
void
*
),
void
*
arg
);
int
event_once
(
int
fd
,
short
events
,
void
(
*
cb
)(
int
,
short
,
void
*
),
void
*
arg
,
struct
timeval
*
tv
);
int
event_add
(
struct
event
*
ev
,
struct
timeval
*
tv
);
int
event_del
(
struct
event
*
ev
);
void
event_active
(
struct
event
*
ev
,
int
res
,
short
ncalls
);
/* ncalls is being ignored */
int
event_pending
(
struct
event
*
ev
,
short
,
struct
timeval
*
tv
);
int
event_priority_init
(
int
npri
);
int
event_priority_set
(
struct
event
*
ev
,
int
pri
);
int
event_base_set
(
struct
event_base
*
base
,
struct
event
*
ev
);
int
event_base_loop
(
struct
event_base
*
base
,
int
);
int
event_base_loopexit
(
struct
event_base
*
base
,
struct
timeval
*
tv
);
int
event_base_dispatch
(
struct
event_base
*
base
);
int
event_base_once
(
struct
event_base
*
base
,
int
fd
,
short
events
,
void
(
*
cb
)(
int
,
short
,
void
*
),
void
*
arg
,
struct
timeval
*
tv
);
int
event_base_priority_init
(
struct
event_base
*
base
,
int
fd
);
/* next line is different in the libevent+libev version */
/*libevent-include*/
#ifdef __cplusplus
}
#endif
#endif
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment