static int
basic_test_cleanup(const struct testcase_t *testcase, void *ptr)
{
struct basic_test_data *data = ptr;
if (testcase->flags & TT_NO_LOGS)
event_set_log_callback(NULL);
if (testcase->flags & TT_NEED_SOCKETPAIR) {
if (data->pair[0] != -1)
evutil_closesocket(data->pair[0]);
if (data->pair[1] != -1)
evutil_closesocket(data->pair[1]);
}
if (testcase->flags & TT_NEED_DNS) {
evdns_shutdown(0);
}
if (testcase->flags & TT_NEED_BASE) {
if (data->base) {
event_base_assert_ok_(data->base);
event_base_free(data->base);
}
}
if (testcase->flags & TT_FORK)
libevent_global_shutdown();
free(data);
return 1;
}
void cNetworkSingleton::Terminate(void)
{
ASSERT(!m_HasTerminated);
// Wait for the lookup thread to stop
m_LookupThread.Stop();
// Wait for the LibEvent event loop to terminate:
event_base_loopbreak(m_EventBase);
m_EventLoopThread.join();
// Remove all objects:
{
cCSLock Lock(m_CS);
m_Connections.clear();
m_Servers.clear();
}
// Free the underlying LibEvent objects:
event_base_free(m_EventBase);
libevent_global_shutdown();
// Set the HasTerminated flag:
// (Only set the flag after everything has been removed, to avoid the random failures in the Google-test, caused by links terminating after this flag was set)
m_HasTerminated = true;
}
void endsocket(void)
{
if(isconnected())
shutdown(sock->socket,2);
closesocket(sock->socket);
if(sock->buf != NULL)
bufferevent_free(sock->buf);
event_base_loopbreak(sock->base);
_sleep(500); //wait for libevent loop to break before unloading base.
event_base_free(sock->base);
libevent_global_shutdown();
WSACleanup();
free(sock);
}
int
main(int argc, const char **argv)
{
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
(void) WSAStartup(wVersionRequested, &wsaData);
#endif
#ifndef _WIN32
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
return 1;
#endif
#ifdef _WIN32
tinytest_skip(testgroups, "http/connection_retry");
tinytest_skip(testgroups, "http/https_connection_retry");
#endif
#ifndef EVENT__DISABLE_THREAD_SUPPORT
if (!getenv("EVENT_NO_DEBUG_LOCKS"))
evthread_enable_lock_debugging();
#endif
if (getenv("EVENT_DEBUG_MODE")) {
event_enable_debug_mode();
libevent_tests_running_in_debug_mode = 1;
}
if (getenv("EVENT_DEBUG_LOGGING_ALL")) {
event_enable_debug_logging(EVENT_DBG_ALL);
}
tinytest_set_aliases(testaliases);
evutil_weakrand_seed_(&test_weakrand_state, 0);
if (tinytest_main(argc,argv,testgroups))
return 1;
libevent_global_shutdown();
return 0;
}
void
lgtd_cleanup(void)
{
lgtd_lifx_discovery_close();
lgtd_listen_close_all();
lgtd_command_pipe_close_all();
lgtd_client_close_all();
lgtd_lifx_broadcast_close();
lgtd_lifx_gateway_close_all();
lgtd_timer_stop_all();
lgtd_close_signal_handling();
event_base_free(lgtd_ev_base);
#if LIBEVENT_VERSION_NUMBER >= 0x02010100
libevent_global_shutdown();
#endif
if (lgtd_opts.pidfile) {
unlink(lgtd_opts.pidfile);
}
}
int main(){
int fd = socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in addr;
memset(&addr,0,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(5000);
addr.sin_addr.s_addr = INADDR_ANY;
int ret = bind(fd,(struct sockaddr*)&addr,sizeof(addr));
assert(ret!=-1);
ret = listen(fd,5);
assert(ret!=-1);
struct event_base* base = event_base_new();
struct event* ev = event_new(base,fd,EV_READ|EV_PERSIST,on_accept,base);
//struct event* ev = event_new(base,fd,EV_READ,on_accept,base);
event_add(ev,NULL);
event_base_dispatch(base);
event_free(ev);
event_base_free(base);
libevent_global_shutdown();
return 0;
}
int
main(int argc, char **argv)
{
struct event *evfifo;
struct event_base* base;
#ifdef _WIN32
HANDLE socket;
/* Open a file. */
socket = CreateFileA("test.txt", /* open File */
GENERIC_READ, /* open for reading */
0, /* do not share */
NULL, /* no security */
OPEN_EXISTING, /* existing file only */
FILE_ATTRIBUTE_NORMAL, /* normal file */
NULL); /* no attr. template */
if (socket == INVALID_HANDLE_VALUE)
return 1;
#else
struct event *signal_int;
struct stat st;
const char *fifo = "event.fifo";
int socket;
if (lstat(fifo, &st) == 0) {
if ((st.st_mode & S_IFMT) == S_IFREG) {
errno = EEXIST;
perror("lstat");
exit(1);
}
}
unlink(fifo);
if (mkfifo(fifo, 0600) == -1) {
perror("mkfifo");
exit(1);
}
socket = open(fifo, O_RDONLY | O_NONBLOCK, 0);
if (socket == -1) {
perror("open");
exit(1);
}
fprintf(stderr, "Write data to %s\n", fifo);
#endif
/* Initalize the event library */
base = event_base_new();
/* Initalize one event */
#ifdef _WIN32
evfifo = event_new(base, (evutil_socket_t)socket, EV_READ|EV_PERSIST, fifo_read,
event_self_cbarg());
#else
/* catch SIGINT so that event.fifo can be cleaned up */
//如果收到SIGINT,则退出eventloop循环
signal_int = evsignal_new(base, SIGINT, signal_cb, base);
event_add(signal_int, NULL);//将事件加入
//处理socket的收事件
evfifo = event_new(base, socket, EV_READ|EV_PERSIST, fifo_read,
event_self_cbarg());
#endif
/* Add it to the active events, without a timeout */
event_add(evfifo, NULL);//将此读事件加入
event_base_dispatch(base);//事件循环
//开始销毁
event_base_free(base);
#ifdef _WIN32
CloseHandle(socket);
#else
close(socket);
unlink(fifo);
#endif
libevent_global_shutdown();
return (0);
}
int main(int argc, char * * argv)
{
struct sigaction sa;
upnpc_t upnp;
char * multicast_if = NULL;
if(argc > 1) {
multicast_if = argv[1];
}
memset(&sa, 0, sizeof(struct sigaction));
sa.sa_handler = sighandler;
if(sigaction(SIGINT, &sa, NULL) < 0) {
perror("sigaction");
}
if(find_local_address() < 0) {
fprintf(stderr, "failed to get local address\n");
return 1;
}
#ifdef DEBUG
event_enable_debug_mode();
#if LIBEVENT_VERSION_NUMBER >= 0x02010100
event_enable_debug_logging(EVENT_DBG_ALL); /* Libevent 2.1.1 */
#endif /* LIBEVENT_VERSION_NUMBER >= 0x02010100 */
#endif /* DEBUG */
printf("Using libevent %s\n", event_get_version());
if(LIBEVENT_VERSION_NUMBER != event_get_version_number()) {
fprintf(stderr, "WARNING build using libevent %s", LIBEVENT_VERSION);
}
base = event_base_new();
if(base == NULL) {
fprintf(stderr, "event_base_new() failed\n");
return 1;
}
#ifdef DEBUG
printf("Using Libevent with backend method %s.\n",
event_base_get_method(base));
#endif /* DEBUG */
if(upnpc_init(&upnp, base, multicast_if, ready, soap, &upnp) != UPNPC_OK) {
fprintf(stderr, "upnpc_init() failed\n");
return 1;
}
upnpc_set_local_address(&upnp, local_address, 50000);
#ifdef ENABLE_UPNP_EVENTS
upnpc_set_event_callback(&upnp, event_callback);
#endif /* ENABLE_UPNP_EVENTS */
if(upnpc_start(&upnp) != UPNPC_OK) {
fprintf(stderr, "upnp_start() failed\n");
return 1;
}
event_base_dispatch(base); /* TODO : check return value */
printf("finishing...\n");
upnpc_finalize(&upnp);
event_base_free(base);
#if LIBEVENT_VERSION_NUMBER >= 0x02010100
libevent_global_shutdown(); /* Libevent 2.1.1 */
#endif
return 0;
}
int main(int argc, char **argv)
{
natsConnection *conn = NULL;
natsOptions *opts = NULL;
natsSubscription *sub = NULL;
natsStatus s = NATS_OK;
struct event_base *evLoop= NULL;
nats_Open(-1);
opts = parseArgs(argc, argv, usage);
printf("Listening on '%s'.\n", subj);
// One time initialization of things that we need.
natsLibevent_Init();
// Create a loop.
evLoop = event_base_new();
if (evLoop == NULL)
s = NATS_ERR;
// Indicate which loop and callbacks to use once connected.
if (s == NATS_OK)
s = natsOptions_SetEventLoop(opts, (void*) evLoop,
natsLibevent_Attach,
natsLibevent_Read,
natsLibevent_Write,
natsLibevent_Detach);
if (s == NATS_OK)
s = natsConnection_Connect(&conn, opts);
if (s == NATS_OK)
s = natsConnection_Subscribe(&sub, conn, subj, onMsg, NULL);
// For maximum performance, set no limit on the number of pending messages.
if (s == NATS_OK)
s = natsSubscription_SetPendingLimits(sub, -1, -1);
// Run the event loop.
// This call will return when the connection is closed (either after
// receiving all messages, or disconnected and unable to reconnect).
if (s == NATS_OK)
event_base_dispatch(evLoop);
if (s == NATS_OK)
{
printPerf("Received", count, start, elapsed);
}
else
{
printf("Error: %d - %s\n", s, natsStatus_GetText(s));
nats_PrintLastErrorStack(stderr);
}
// Destroy all our objects to avoid report of memory leak
natsSubscription_Destroy(sub);
natsConnection_Destroy(conn);
natsOptions_Destroy(opts);
if (evLoop != NULL)
event_base_free(evLoop);
// To silence reports of memory still in used with valgrind
nats_Close();
libevent_global_shutdown();
return 0;
}
void General::shutdown()
{
libevent_global_shutdown();
}
int main (int argc, char **argv)
{
int i, j;
const char *s1, *s2;
evthread_use_windows_threads ();
s1 = evutil_socket_error_to_string (WSAEINTR);
for (i = 0; i < 3; i++) {
printf ("\niteration %d:\n\n", i);
E(WSAEINTR);
E(WSAEACCES);
E(WSAEFAULT);
E(WSAEINVAL);
E(WSAEMFILE);
E(WSAEWOULDBLOCK);
E(WSAEINPROGRESS);
E(WSAEALREADY);
E(WSAENOTSOCK);
E(WSAEDESTADDRREQ);
E(WSAEMSGSIZE);
E(WSAEPROTOTYPE);
E(WSAENOPROTOOPT);
E(WSAEPROTONOSUPPORT);
E(WSAESOCKTNOSUPPORT);
E(WSAEOPNOTSUPP);
E(WSAEPFNOSUPPORT);
E(WSAEAFNOSUPPORT);
E(WSAEADDRINUSE);
E(WSAEADDRNOTAVAIL);
E(WSAENETDOWN);
E(WSAENETUNREACH);
E(WSAENETRESET);
E(WSAECONNABORTED);
E(WSAECONNRESET);
E(WSAENOBUFS);
E(WSAEISCONN);
E(WSAENOTCONN);
E(WSAESHUTDOWN);
E(WSAETIMEDOUT);
E(WSAECONNREFUSED);
E(WSAEHOSTDOWN);
E(WSAEHOSTUNREACH);
E(WSAEPROCLIM);
E(WSASYSNOTREADY);
E(WSAVERNOTSUPPORTED);
E(WSANOTINITIALISED);
E(WSAEDISCON);
E(WSATYPE_NOT_FOUND);
E(WSAHOST_NOT_FOUND);
E(WSATRY_AGAIN);
E(WSANO_RECOVERY);
E(WSANO_DATA);
E(0xdeadbeef); /* test the case where no message is available */
/* fill up the hash table a bit to make sure it grows properly */
for (j = 0; j < 50; j++) {
int err;
evutil_secure_rng_get_bytes(&err, sizeof(err));
evutil_socket_error_to_string(err);
}
}
s2 = evutil_socket_error_to_string (WSAEINTR);
if (s1 != s2)
printf ("caching failed!\n");
libevent_global_shutdown ();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
natsConnection *conn = NULL;
natsOptions *opts = NULL;
natsSubscription *sub = NULL;
natsStatus s = NATS_OK;
struct event_base *evLoop= NULL;
THREAD_T pub;
threadInfo info;
nats_Open(-1);
opts = parseArgs(argc, argv, usage);
printf("Sending %" PRId64 " messages to subject '%s'\n", total, subj);
// One time initialization of things that we need.
natsLibevent_Init();
// Create a loop.
evLoop = event_base_new();
if (evLoop == NULL)
s = NATS_ERR;
// Indicate which loop and callbacks to use once connected.
if (s == NATS_OK)
s = natsOptions_SetEventLoop(opts, (void*) evLoop,
natsLibevent_Attach,
natsLibevent_Read,
natsLibevent_Write,
natsLibevent_Detach);
if (s == NATS_OK)
s = natsConnection_Connect(&conn, opts);
if (s == NATS_OK)
start = nats_Now();
if (s == NATS_OK)
{
info.conn = conn;
info.status = NATS_OK;
THREAD_START(pub, pubThread, (void*) &info);
}
if (s == NATS_OK)
{
event_base_dispatch(evLoop);
THREAD_JOIN(pub);
s = info.status;
}
if (s == NATS_OK)
{
printPerf("Sent", count, start, elapsed);
}
else
{
printf("Error: %d - %s\n", s, natsStatus_GetText(s));
nats_PrintLastErrorStack(stderr);
}
// Destroy all our objects to avoid report of memory leak
natsSubscription_Destroy(sub);
natsConnection_Destroy(conn);
natsOptions_Destroy(opts);
if (evLoop != NULL)
event_base_free(evLoop);
// To silence reports of memory still in used with valgrind
nats_Close();
libevent_global_shutdown();
return 0;
}