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."); }