int main() {
int r;
id = 0;
loop = uv_default_loop();
struct sockaddr_in bind_addr;
r = uv_ip4_addr("0.0.0.0", PORT, &bind_addr);
CHECK(r, "get bind addr");
r = uv_tcp_init(loop, &server);
CHECK(r, "init server");
r = uv_tcp_bind(&server, (const struct sockaddr*) &bind_addr);
CHECK(r, "bind");
r = uv_listen((uv_stream_t*) &server, BACKLOG, on_connect);
CHECK(r, "listen");
log_info("listening on http://localhost:%d", PORT);
uv_run(loop, UV_RUN_DEFAULT);
return 0;
}
static void make_many_connections(void) {
tcp_conn* conn;
struct sockaddr_in addr;
int r, i;
for (i = 0; i < CONN_COUNT; i++) {
conn = malloc(sizeof(*conn));
ASSERT(conn);
r = uv_tcp_init(uv_default_loop(), &conn->conn);
ASSERT(r == 0);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_connect(&conn->conn_req,
(uv_tcp_t*) &conn->conn,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
conn->conn.data = conn;
}
}
static void repeat_2_cb(uv_timer_t* handle, int status) {
ASSERT(handle == &repeat_2);
ASSERT(status == 0);
ASSERT(repeat_2_cb_allowed);
LOGF("repeat_2_cb called after %ld ms\n",
(long int)(uv_now(uv_default_loop()) - start_time));
repeat_2_cb_called++;
if (uv_timer_get_repeat(&repeat_2) == 0) {
ASSERT(0 == uv_is_active((uv_handle_t*) handle));
uv_close((uv_handle_t*)handle, close_cb);
return;
}
LOGF("uv_timer_get_repeat %ld ms\n",
(long int)uv_timer_get_repeat(&repeat_2));
ASSERT(uv_timer_get_repeat(&repeat_2) == 100);
/* This shouldn't take effect immediately. */
uv_timer_set_repeat(&repeat_2, 0);
}
int main() {
int r = 0;
uv_loop_t *loop = uv_default_loop();
r = uv_tcp_init(loop, &tcp_server);
CHECK(r, "uv_tcp_init");
struct sockaddr_in addr;
r = uv_ip4_addr(HOST, PORT, &addr);
CHECK(r, "uv_ip4_addr");
r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
CHECK(r, "uv_tcp_bind");
r = uv_listen((uv_stream_t*) &tcp_server, SOMAXCONN, onconnection);
CHECK(r, "uv_listen");
log_info("Listening on %s:%d", HOST, PORT);
uv_run(loop, UV_RUN_DEFAULT);
MAKE_VALGRIND_HAPPY();
return 0;
}
int main()
{
struct addrinfo hints;
uv_getaddrinfo_t resolver;
int r;
loop = uv_default_loop();
hints.ai_family = PF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = 0;
fprintf(stderr, "irc.freenode.net is... ");
r = uv_getaddrinfo(loop, &resolver, on_resolved, "irc.freenode.net", "6667", &hints);
if (r)
{
fprintf(stderr, "getaddrinfo call error %s\n", uv_err_name(r));
return 1;
}
return uv_run(loop, UV_RUN_DEFAULT);
}
static void repeat_1_cb(uv_timer_t* handle) {
int r;
ASSERT(handle == &repeat_1);
ASSERT(uv_timer_get_repeat((uv_timer_t*)handle) == 50);
fprintf(stderr, "repeat_1_cb called after %ld ms\n",
(long int)(uv_now(uv_default_loop()) - start_time));
fflush(stderr);
repeat_1_cb_called++;
r = uv_timer_again(&repeat_2);
ASSERT(r == 0);
if (repeat_1_cb_called == 10) {
uv_close((uv_handle_t*)handle, close_cb);
/* We're not calling uv_timer_again on repeat_2 any more, so after this */
/* timer_2_cb is expected. */
repeat_2_cb_allowed = 1;
return;
}
}
/* same ping-pong test, but using IPv6 connection */
static void tcp_pinger_v6_new() {
int r;
struct sockaddr_in6 server_addr = uv_ip6_addr("::1", TEST_PORT);
pinger_t *pinger;
pinger = (pinger_t*)malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;
/* Try to connec to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);
pinger->stream.tcp.data = pinger;
ASSERT(!r);
/* We are never doing multiple reads/connects at a time anyway. */
/* so these handles can be pre-initialized. */
r = uv_tcp_connect6(&pinger->connect_req, &pinger->stream.tcp, server_addr,
pinger_on_connect);
ASSERT(!r);
/* Synchronous connect callbacks are not allowed. */
ASSERT(pinger_on_connect_count == 0);
}
void TCPServer::IncomingConnection(uv_stream_t * listener, int status)
{
LogTrace(LOG_NETWORKING, "Incoming connection");
if (status < 0)
{
LogError(LOG_NETWORKING, "Incoming connection - failure, reason: %s", uv_err_name(status));
return;
}
uv_tcp_t * client = (uv_tcp_t *) malloc(sizeof(uv_tcp_t));
uv_tcp_init(uv_default_loop(), client);
if (uv_accept(listener, (uv_stream_t *) client) == 0)
{
LogTrace(LOG_NETWORKING, "Incoming connection - success");
uv_read_start((uv_stream_t *) client, AllocBuffer, IncomingData);
}
else
{
LogError(LOG_NETWORKING, "Incoming connection - failure, reason: %s", uv_err_name(status));
uv_close((uv_handle_t *) client, NULL);
}
}
int main() {
uv_loop_t *loop = uv_default_loop();
int port = 8000, r = 0;
evt_ctx_t ctx;
struct sockaddr_in bind_local;
evt_ctx_init_ex(&ctx, "server-cert.pem", "server-key.pem");
evt_ctx_set_nio(&ctx, NULL, uv_tls_writer);
uv_tcp_t listener_local;
uv_tcp_init(loop, &listener_local);
listener_local.data = &ctx;
uv_ip4_addr("127.0.0.1", port, &bind_local);
if ((r = uv_tcp_bind(&listener_local, (struct sockaddr*)&bind_local, 0)))
fprintf( stderr, "bind: %s\n", uv_strerror(r));
if ((r = uv_listen((uv_stream_t*)&listener_local, 128, on_connect_cb)))
fprintf( stderr, "listen: %s\n", uv_strerror(r));
printf("Listening on %d\n", port);
uv_run(loop, UV_RUN_DEFAULT);
evt_ctx_free(&ctx);
return 0;
}
static int lmz_reader_init(lua_State* L) {
const char* path = luaL_checkstring(L, 1);
mz_uint32 flags = luaL_optint(L, 2, 0);
mz_uint64 size;
lmz_file_t* zip = lua_newuserdata(L, sizeof(*zip));
mz_zip_archive* archive = &(zip->archive);
luaL_getmetatable(L, "miniz_reader");
lua_setmetatable(L, -2);
memset(archive, 0, sizeof(*archive));
zip->loop = uv_default_loop();
zip->fd = uv_fs_open(zip->loop, &(zip->req), path, O_RDONLY, 0644, NULL);
uv_fs_fstat(zip->loop, &(zip->req), zip->fd, NULL);
size = zip->req.statbuf.st_size;
archive->m_pRead = lmz_file_read;
archive->m_pIO_opaque = zip;
if (!mz_zip_reader_init(archive, size, flags)) {
lua_pushnil(L);
lua_pushfstring(L, "read %s fail because of %s", path,
mz_zip_get_error_string(mz_zip_get_last_error(archive)));
return 2;
}
return 1;
}
jl_module_t *jl_new_module(jl_sym_t *name)
{
jl_module_t *m = (jl_module_t*)jl_gc_allocobj(sizeof(jl_module_t));
jl_set_typeof(m, jl_module_type);
JL_GC_PUSH1(&m);
assert(jl_is_symbol(name));
m->name = name;
m->parent = NULL;
m->constant_table = NULL;
m->call_func = NULL;
m->istopmod = 0;
m->uuid = uv_now(uv_default_loop());
htable_new(&m->bindings, 0);
arraylist_new(&m->usings, 0);
if (jl_core_module) {
jl_module_using(m, jl_core_module);
}
// export own name, so "using Foo" makes "Foo" itself visible
jl_set_const(m, name, (jl_value_t*)m);
jl_module_export(m, name);
JL_GC_POP();
return m;
}
static void on_cm_event_read(uv_pipe_t* cm, ssize_t nread, uv_buf_t buf, uv_handle_type pending) {
printf("on_cm_event_read\n");
write_req_t* write_req;
int r;
uv_err_t err = uv_last_error(uv_default_loop());
assert(nread > 0 || err.code == UV_EOF);
printf("nread = %ld\n", nread);
if (nread > 0) {
output_used += nread;
if (output_used == 12) {
assert(memcmp("hello world\n", output, 12) == 0);
write_req = (write_req_t*)malloc(sizeof(*write_req));
write_req->buf = uv_buf_init(output, output_used);
r = uv_write(&write_req->req, (uv_stream_t*)&in, &write_req->buf, 1, after_write);
assert(r == 0);
}
}
on_read_cb_called++;
}
static int pipe_echo_start(char* pipeName) {
int r;
#ifndef _WIN32
{
uv_fs_t req;
uv_fs_unlink(uv_default_loop(), &req, pipeName, NULL);
uv_fs_req_cleanup(&req);
}
#endif
server = (uv_handle_t*)&pipeServer;
serverType = PIPE;
r = uv_pipe_init(loop, &pipeServer, 0);
if (r) {
fprintf(stderr, "uv_pipe_init: %s\n",
uv_strerror(uv_last_error(loop)));
return 1;
}
r = uv_pipe_bind(&pipeServer, pipeName);
if (r) {
fprintf(stderr, "uv_pipe_bind: %s\n",
uv_strerror(uv_last_error(loop)));
return 1;
}
r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
if (r) {
fprintf(stderr, "uv_pipe_listen: %s\n",
uv_strerror(uv_last_error(loop)));
return 1;
}
return 0;
}
v8::Handle<v8::Value> Write(const v8::Arguments& args) {
v8::HandleScope scope;
// file descriptor
if(!args[0]->IsInt32()) {
return scope.Close(v8::ThrowException(v8::Exception::TypeError(v8::String::New("First argument must be an int"))));
}
int fd = args[0]->ToInt32()->Int32Value();
// buffer
if(!args[1]->IsObject() || !node::Buffer::HasInstance(args[1])) {
return scope.Close(v8::ThrowException(v8::Exception::TypeError(v8::String::New("Second argument must be a buffer"))));
}
v8::Persistent<v8::Object> buffer = v8::Persistent<v8::Object>::New(args[1]->ToObject());
char* bufferData = node::Buffer::Data(buffer);
size_t bufferLength = node::Buffer::Length(buffer);
// callback
if(!args[2]->IsFunction()) {
return scope.Close(v8::ThrowException(v8::Exception::TypeError(v8::String::New("Third argument must be a function"))));
}
v8::Local<v8::Value> callback = args[2];
WriteBaton* baton = new WriteBaton();
memset(baton, 0, sizeof(WriteBaton));
baton->fd = fd;
baton->buffer = buffer;
baton->bufferData = bufferData;
baton->bufferLength = bufferLength;
baton->callback = v8::Persistent<v8::Value>::New(callback);
uv_work_t* req = new uv_work_t();
req->data = baton;
uv_queue_work(uv_default_loop(), req, EIO_Write, EIO_AfterWrite);
return scope.Close(v8::Undefined());
}
int DirWatcher::init(std::string dir, dirwatch_on_rename_callback cb, void* usr) {
int r = 0;
directory = dir;
if (NULL != loop) {
RX_ERROR("Looks like we're already initialize, call shutdown() first.");
return -1;
}
if (false == rx_is_dir(directory)) {
RX_ERROR("Not a directory: %s", directory.c_str());
return -2;
}
loop = uv_default_loop();
r = uv_fs_event_init(loop, &fs_event);
if (0 != r) {
RX_ERROR("Cannot initialize the fs event: %s", uv_strerror(r));
loop = NULL;
return -3;
}
r = uv_fs_event_start(&fs_event, on_dir_change, directory.c_str(), 0);
if (0 != r) {
RX_ERROR("Cannot start the fs event: %s", uv_strerror(r));
loop = NULL;
return -4;
}
fs_event.data = this;
on_rename = cb;
user = usr;
return 0;
}
void signal_init(void)
{
uv_signal_init(uv_default_loop(), &sint);
uv_signal_init(uv_default_loop(), &spipe);
uv_signal_init(uv_default_loop(), &shup);
uv_signal_init(uv_default_loop(), &squit);
uv_signal_init(uv_default_loop(), &sterm);
uv_signal_init(uv_default_loop(), &swinch);
uv_signal_start(&sint, signal_cb, SIGINT);
uv_signal_start(&spipe, signal_cb, SIGPIPE);
uv_signal_start(&shup, signal_cb, SIGHUP);
uv_signal_start(&squit, signal_cb, SIGQUIT);
uv_signal_start(&sterm, signal_cb, SIGTERM);
if (!embedded_mode) {
// TODO(tarruda): There must be an API function for resizing window
uv_signal_start(&swinch, signal_cb, SIGWINCH);
}
#ifdef SIGPWR
uv_signal_init(uv_default_loop(), &spwr);
uv_signal_start(&spwr, signal_cb, SIGPWR);
#endif
}
int spawn_tcp_server_helper(void) {
uv_tcp_t tcp;
uv_os_sock_t handle;
int r;
r = uv_tcp_init(uv_default_loop(), &tcp);
ASSERT(r == 0);
#ifdef _WIN32
handle = _get_osfhandle(3);
#else
handle = 3;
#endif
r = uv_tcp_open(&tcp, handle);
ASSERT(r == 0);
/* Make sure that we can listen on a socket that was
* passed down from the parent process
*/
r = uv_listen((uv_stream_t*)&tcp, SOMAXCONN, NULL);
ASSERT(r == 0);
return 1;
}
int Start(int argc, char** argv) {
InitDebugSettings();
// Initalize JerryScript engine.
if (!InitJerry()) {
DLOG("InitJerry failed");
return 1;
}
// Create environtment.
Environment* env = Environment::GetEnv();
// Init environment with argument and uv loop.
env->Init(argc, argv, uv_default_loop());
// Start IoT.js
if (!StartIoTjs(env)) {
DLOG("StartIoTJs failed");
return 1;
}
// close uv loop.
//uv_stop(env->loop());
uv_walk(env->loop(), UvWalkToCloseCallback, NULL);
uv_run(env->loop(), UV_RUN_DEFAULT);
int res = uv_loop_close(env->loop());
IOTJS_ASSERT(res == 0);
// Release JerryScript engine.
ReleaseJerry();
ReleaseDebugSettings();
return 0;
}
/**
* @details This is an asynchronous factory method creating a new `Map`
* instance from a mapserver mapfile.
*
* `args` should contain the following parameters:
*
* @param mapfile A string representing the mapfile path.
*
* @param callback A function that is called on error or when the map has been
* created. It should have the signature `callback(err, map)`.
*/
Handle<Value> Map::FromFileAsync(const Arguments& args) {
HandleScope scope;
if (args.Length() != 2) {
THROW_CSTR_ERROR(Error, "usage: Map.FromFile(mapfile, callback)");
}
REQ_STR_ARG(0, mapfile);
REQ_FUN_ARG(1, callback);
MapfileBaton *baton = new MapfileBaton();
baton->request.data = baton;
baton->map = NULL;
baton->callback = Persistent<Function>::New(callback);
baton->error = NULL;
baton->mapfile = *mapfile;
uv_queue_work(uv_default_loop(),
&baton->request,
FromFileWork,
(uv_after_work_cb) FromFileAfter);
return Undefined();
}
int
uvm_start_client(uvm_read_callback_t cb,
char* host, int port, void* data){
struct sockaddr_in sin;
uv_tcp_t* sock = malloc(sizeof(uv_tcp_t));
uv_connect_t* connect_req = malloc(sizeof(uv_connect_t));
connection_request_t* req = malloc(sizeof(connection_request_t));
if(!req){
/* FIXME: set error here */
return -1;
}
connect_req->data = req;
req->cb = cb;
req->data = data;
/* Resolve name */
sin = uv_ip4_addr(host,port);
/* Init connection state */
uv_tcp_init(uv_default_loop(), sock);
/* Enqueue connection request */
return uv_tcp_connect(connect_req, sock, sin, cb_connect);
}
static v8::Handle<v8::Value> call(v8::Arguments const& args)
{
typedef Worker Instance::* member_ptr_t;
v8::HandleScope scope;
// get member pointer
uint32_t member_ptr_value = args.Data()->NumberValue();
member_ptr_t member_ptr = *reinterpret_cast<member_ptr_t *>(&member_ptr_value);
// get instance
Instance & instance = get_wrapped_object<Instance>(args);
// get derived worker ref
Worker & worker = instance.*member_ptr;
// get the work request
uv_work_t * work_req = worker.get_work_request();
if (!work_req)
{
// error in arguments, return undefined
return scope.Close(v8::Undefined());
}
// store the arguments
worker.store_arguments(args);
// queue work function
work_req->data = &worker;
uv_queue_work(uv_default_loop(),
work_req,
&worker_base::process_impl<Instance, Worker>,
&worker_base::after_impl<Instance, Worker>);
return scope.Close(v8::Undefined());
}
void main(int argc, char** argv) {
loop = uv_default_loop();
if(argc > 1) {
bench = atoi(argv[1]);
}
if(argc > 2) {
interval = atoi(argv[2]); // Seconds
}
// init log client
uvx_log_init(&xlog, loop, "127.0.0.1", 8004, "xlog-test");
// some small tests
test_shorten_path();
test_serialize_log();
// start a timer
uv_timer_t timer;
uv_timer_init(loop, &timer);
uv_timer_start(&timer, on_timer, 0, interval/*seconds*/ * 1000);
uv_run(loop, UV_RUN_DEFAULT);
}
static void do_newuser(MyMSG* msg, CMsgSocket* s)
{
printf("received new user: id: %d; room: %d\n", msg->body.userinfo.userid, msg->body.userinfo.roomid);
s->dis_connect();
cnt++;
if (cnt > 6){
s1->dis_connect();
s2->dis_connect();
return;
}
CMsgSocket* s11 = dynamic_cast<CMsgSocket*>(CResourcePool::GetInstance()->Get(e_rsc_msgsocket));
if (s == s1) s1 = s11;
else s2 = s11;
cc_userinfo_t userinfo = { 0 };
userinfo.roomid = msg->body.userinfo.roomid;
userinfo.userid = !msg->body.userinfo.userid;
s11->set_local_user(&userinfo);
s11->on_received(s11, on_msg);
s11->on_received_frame(s11, on_frame);
uv_work_t* req = (uv_work_t*)malloc(sizeof(uv_work_t));
req->data = s11;
int ret = uv_queue_work(uv_default_loop(), req, do_nothing, reconn);
printf("queue reconn return %d\n", ret);
}
uni::CallbackType OracleClient::Connect(const uni::FunctionCallbackInfo& args) {
UNI_SCOPE(scope);
REQ_OBJECT_ARG(0, settings);
REQ_FUN_ARG(1, callback);
OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This());
ConnectBaton* baton = new ConnectBaton(client, client->m_environment, &callback);
OBJ_GET_STRING(settings, "hostname", baton->hostname);
OBJ_GET_STRING(settings, "user", baton->user);
OBJ_GET_STRING(settings, "password", baton->password);
OBJ_GET_STRING(settings, "database", baton->database);
OBJ_GET_NUMBER(settings, "port", baton->port, 1521);
OBJ_GET_STRING(settings, "tns", baton->tns);
client->Ref();
uv_work_t* req = new uv_work_t();
req->data = baton;
uv_queue_work(uv_default_loop(), req, EIO_Connect, (uv_after_work_cb)EIO_AfterConnect);
UNI_RETURN(scope, args, NanUndefined());
}
cspider_t *init_cspider() {
cspider_t *spider = (cspider_t *)malloc(sizeof(cspider_t));
PANIC(spider);
//init task queue
spider->task_queue = initTaskQueue();
PANIC(spider->task_queue);
spider->task_queue_doing = initTaskQueue();
PANIC(spider->task_queue_doing);
//init data queue
spider->data_queue = initDataQueue();
PANIC(spider->data_queue);
spider->data_queue_doing = initDataQueue();
PANIC(spider->data_queue_doing);
spider->threadpool_size = 4;
spider->process = NULL;
spider->save = NULL;
spider->process_user_data = NULL;
spider->save_user_data = NULL;
spider->loop = uv_default_loop();
spider->idler = (uv_idle_t*)malloc(sizeof(uv_idle_t));
spider->lock = (uv_rwlock_t*)malloc(sizeof(uv_rwlock_t));
uv_rwlock_init(spider->lock);
spider->save_lock = (uv_rwlock_t*)malloc(sizeof(uv_rwlock_t));
uv_rwlock_init(spider->save_lock);
spider->idler->data = spider;
spider->site = (site_t*)malloc(sizeof(site_t));
spider->site->user_agent = NULL;
spider->site->proxy = NULL;
spider->site->cookie = NULL;
spider->site->timeout = 0;
spider->log = NULL;
spider->bloom = init_Bloom();
return spider;
}
int
main(int argc, char *argv[])
{
serverstate_set_event_loop(uv_default_loop());
config_init();
listener_init();
client_init();
module_init();
server_init();
command_init();
connection_init();
process_commandline(argv, argc);
config_load();
listener_start_listeners();
module_load_all_modules();
connection_init_tls();
uv_run(serverstate_get_event_loop(), UV_RUN_DEFAULT);
return 0;
}
Handle<Value> OracleClient::Connect(const Arguments& args) {
HandleScope scope;
REQ_OBJECT_ARG(0, settings);
REQ_FUN_ARG(1, callback);
OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This());
ConnectBaton* baton = new ConnectBaton(client, client->m_environment, &callback);
OBJ_GET_STRING(settings, "hostname", baton->hostname);
OBJ_GET_STRING(settings, "user", baton->user);
OBJ_GET_STRING(settings, "password", baton->password);
OBJ_GET_STRING(settings, "database", baton->database);
OBJ_GET_NUMBER(settings, "port", baton->port, 1521);
OBJ_GET_STRING(settings, "tns", baton->tns);
client->Ref();
uv_work_t* req = new uv_work_t();
req->data = baton;
uv_queue_work(uv_default_loop(), req, EIO_Connect, (uv_after_work_cb)EIO_AfterConnect);
return scope.Close(Undefined());
}
//call client signal callback
static void
signal_cb (std::string subscriber_name,
std::string quiddity_name,
std::string signal_name,
std::vector<std::string> params,
void *user_data)
{
if (g_strcmp0 (signal_name.c_str (), "on-quiddity-created") == 0
&& switcher_is_loading == false)
g_thread_create (set_runtime_invoker,
g_strdup (params[0].c_str ()),
FALSE,
NULL);
async_req_signal *req = new async_req_signal ();
req->req.data = req;
req->quiddity_name = quiddity_name;
req->signal_name = signal_name;
req->params = params;
uv_queue_work (uv_default_loop(),
&req->req,
DoNothingAsync,
(uv_after_work_cb)NotifySignal);
}
static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
ssize_t i;
pinger_t* pinger;
pinger = (pinger_t*)stream->data;
if (nread < 0) {
ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
puts("got EOF");
if (buf.base) {
free(buf.base);
}
uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);
return;
}
/* Now we count the pings */
for (i = 0; i < nread; i++) {
ASSERT(buf.base[i] == PING[pinger->state]);
pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);
if (pinger->state == 0) {
printf("PONG %d\n", pinger->pongs);
pinger->pongs++;
if (pinger->pongs < NUM_PINGS) {
pinger_write_ping(pinger);
} else {
uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);
return;
}
}
}
}
int main(int argc, char *argv[]){
sockaddr_in addr;
int r;
resbuf.base = RESPONSE;
resbuf.len = sizeof(RESPONSE);
uv_loop = uv_default_loop();
addr = uv_ip4_addr("127.0.0.1", 8089);
r = uv_tcp_init(uv_loop, &tcp_server);
assert(r == 0);
r = uv_tcp_bind(&tcp_server, addr);
assert(r == 0);
r = uv_listen((uv_stream_t*)&tcp_server, 128, connection_cb);
assert(r == 0);
printf("start\n");
r = uv_run(uv_loop);
assert(0 && "Blackhole server dropped out of event loop.");
}
