// A client socket wants to connect to this server. // Parameters: // * uv_stream_t* handle - server handle // * int status - status code static void OnConnection(uv_stream_t* handle, int status) { // Server tcp wrapper. iotjs_tcpwrap_t* tcp_wrap = iotjs_tcpwrap_from_handle((uv_tcp_t*)handle); // Tcp object jerry_value_t jtcp = iotjs_tcpwrap_jobject(tcp_wrap); // `onconnection` callback. jerry_value_t jonconnection = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_ONCONNECTION); IOTJS_ASSERT(jerry_value_is_function(jonconnection)); // The callback takes two parameter // [0] status // [1] client tcp object iotjs_jargs_t args = iotjs_jargs_create(2); iotjs_jargs_append_number(&args, status); if (status == 0) { // Create client socket handle wrapper. jerry_value_t jcreate_tcp = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_CREATETCP); IOTJS_ASSERT(jerry_value_is_function(jcreate_tcp)); jerry_value_t jclient_tcp = iotjs_jhelper_call_ok(jcreate_tcp, jerry_create_undefined(), iotjs_jargs_get_empty()); IOTJS_ASSERT(jerry_value_is_object(jclient_tcp)); iotjs_tcpwrap_t* tcp_wrap_client = (iotjs_tcpwrap_t*)(iotjs_jval_get_object_native_handle(jclient_tcp)); uv_stream_t* client_handle = (uv_stream_t*)(iotjs_tcpwrap_tcp_handle(tcp_wrap_client)); int err = uv_accept(handle, client_handle); if (err) { iotjs_jargs_destroy(&args); return; } iotjs_jargs_append_jval(&args, jclient_tcp); jerry_release_value(jcreate_tcp); jerry_release_value(jclient_tcp); } iotjs_make_callback(jonconnection, jtcp, &args); jerry_release_value(jonconnection); iotjs_jargs_destroy(&args); }
void OnRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { iotjs_tcpwrap_t* tcp_wrap = iotjs_tcpwrap_from_handle((uv_tcp_t*)handle); // tcp handle jerry_value_t jtcp = iotjs_tcpwrap_jobject(tcp_wrap); // socket object jerry_value_t jsocket = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_OWNER); IOTJS_ASSERT(jerry_value_is_object(jsocket)); // onread callback jerry_value_t jonread = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_ONREAD); IOTJS_ASSERT(jerry_value_is_function(jonread)); iotjs_jargs_t jargs = iotjs_jargs_create(4); iotjs_jargs_append_jval(&jargs, jsocket); iotjs_jargs_append_number(&jargs, nread); iotjs_jargs_append_bool(&jargs, false); if (nread <= 0) { if (buf->base != NULL) { iotjs_buffer_release(buf->base); } if (nread < 0) { if (nread == UV__EOF) { iotjs_jargs_replace(&jargs, 2, jerry_create_boolean(true)); } iotjs_make_callback(jonread, jerry_create_undefined(), &jargs); } } else { jerry_value_t jbuffer = iotjs_bufferwrap_create_buffer((size_t)nread); iotjs_bufferwrap_t* buffer_wrap = iotjs_bufferwrap_from_jbuffer(jbuffer); iotjs_bufferwrap_copy(buffer_wrap, buf->base, (size_t)nread); iotjs_jargs_append_jval(&jargs, jbuffer); iotjs_make_callback(jonread, jerry_create_undefined(), &jargs); jerry_release_value(jbuffer); iotjs_buffer_release(buf->base); } iotjs_jargs_destroy(&jargs); jerry_release_value(jonread); jerry_release_value(jsocket); }
static void iotjs_adc_after_work(uv_work_t* work_req, int status) { iotjs_adc_reqwrap_t* req_wrap = iotjs_adc_reqwrap_from_request(work_req); iotjs_adc_reqdata_t* req_data = iotjs_adc_reqwrap_data(req_wrap); iotjs_jargs_t jargs = iotjs_jargs_create(2); bool result = req_data->result; if (status) { iotjs_jval_t error = iotjs_jval_create_error("System error"); iotjs_jargs_append_jval(&jargs, &error); iotjs_jval_destroy(&error); } else { switch (req_data->op) { case kAdcOpOpen: if (!result) { iotjs_jargs_append_error(&jargs, "Failed to open ADC device"); } else { iotjs_jargs_append_null(&jargs); } break; case kAdcOpRead: if (!result) { iotjs_jargs_append_error(&jargs, "Cannot read from ADC device"); } else { iotjs_jargs_append_null(&jargs); iotjs_jargs_append_number(&jargs, req_data->value); } break; case kAdcOpClose: if (!result) { iotjs_jargs_append_error(&jargs, "Cannot close ADC device"); } else { iotjs_jargs_append_null(&jargs); } break; default: { IOTJS_ASSERT(!"Unreachable"); break; } } } const iotjs_jval_t* jcallback = iotjs_adc_reqwrap_jcallback(req_wrap); iotjs_make_callback(jcallback, iotjs_jval_get_undefined(), &jargs); iotjs_jargs_destroy(&jargs); iotjs_adc_reqwrap_dispatched(req_wrap); }
iotjs_jval_t iotjs_bufferwrap_create_buffer(size_t len) { iotjs_jval_t* jglobal = iotjs_jval_get_global_object(); iotjs_jval_t jbuffer = iotjs_jval_get_property(jglobal, IOTJS_MAGIC_STRING_BUFFER); IOTJS_ASSERT(iotjs_jval_is_function(&jbuffer)); iotjs_jargs_t jargs = iotjs_jargs_create(1); iotjs_jargs_append_number(&jargs, len); iotjs_jval_t jres = iotjs_jhelper_call_ok(&jbuffer, iotjs_jval_get_undefined(), &jargs); IOTJS_ASSERT(iotjs_jval_is_object(&jres)); iotjs_jargs_destroy(&jargs); iotjs_jval_destroy(&jbuffer); return jres; }
static void AfterShutdown(uv_shutdown_t* req, int status) { iotjs_shutdown_reqwrap_t* req_wrap = (iotjs_shutdown_reqwrap_t*)(req->data); iotjs_tcpwrap_t* tcp_wrap = (iotjs_tcpwrap_t*)(req->handle->data); IOTJS_ASSERT(req_wrap != NULL); IOTJS_ASSERT(tcp_wrap != NULL); // function onShutdown(status) jerry_value_t jonshutdown = iotjs_shutdown_reqwrap_jcallback(req_wrap); IOTJS_ASSERT(jerry_value_is_function(jonshutdown)); iotjs_jargs_t args = iotjs_jargs_create(1); iotjs_jargs_append_number(&args, status); iotjs_make_callback(jonshutdown, jerry_create_undefined(), &args); iotjs_jargs_destroy(&args); iotjs_shutdown_reqwrap_dispatched(req_wrap); }
void iotjs_process_emit_exit(int code) { const iotjs_jval_t* process = iotjs_module_get(MODULE_PROCESS); iotjs_jval_t jexit = iotjs_jval_get_property(process, IOTJS_MAGIC_STRING_EMITEXIT); IOTJS_ASSERT(iotjs_jval_is_function(&jexit)); iotjs_jargs_t jargs = iotjs_jargs_create(1); iotjs_jargs_append_number(&jargs, code); bool throws; iotjs_jval_t jres = iotjs_jhelper_call(&jexit, process, &jargs, &throws); iotjs_jargs_destroy(&jargs); iotjs_jval_destroy(&jres); iotjs_jval_destroy(&jexit); if (throws) { exit(2); } }
void AfterWrite(uv_write_t* req, int status) { iotjs_write_reqwrap_t* req_wrap = (iotjs_write_reqwrap_t*)(req->data); iotjs_tcpwrap_t* tcp_wrap = (iotjs_tcpwrap_t*)(req->handle->data); IOTJS_ASSERT(req_wrap != NULL); IOTJS_ASSERT(tcp_wrap != NULL); // Take callback function object. jerry_value_t jcallback = iotjs_write_reqwrap_jcallback(req_wrap); // Only parameter is status code. iotjs_jargs_t args = iotjs_jargs_create(1); iotjs_jargs_append_number(&args, status); // Make callback. iotjs_make_callback(jcallback, jerry_create_undefined(), &args); // Destroy args iotjs_jargs_destroy(&args); // Release request wrapper. iotjs_write_reqwrap_dispatched(req_wrap); }
// Connection request result handler. static void AfterConnect(uv_connect_t* req, int status) { iotjs_connect_reqwrap_t* req_wrap = (iotjs_connect_reqwrap_t*)(req->data); IOTJS_ASSERT(req_wrap != NULL); // Take callback function object. // function afterConnect(status) jerry_value_t jcallback = iotjs_connect_reqwrap_jcallback(req_wrap); IOTJS_ASSERT(jerry_value_is_function(jcallback)); // Only parameter is status code. iotjs_jargs_t args = iotjs_jargs_create(1); iotjs_jargs_append_number(&args, status); // Make callback. iotjs_make_callback(jcallback, jerry_create_undefined(), &args); // Destroy args iotjs_jargs_destroy(&args); // Release request wrapper. iotjs_connect_reqwrap_dispatched(req_wrap); }
static void AfterAsync(uv_fs_t* req) { iotjs_fs_reqwrap_t* req_wrap = (iotjs_fs_reqwrap_t*)(req->data); IOTJS_ASSERT(req_wrap != NULL); IOTJS_ASSERT(&req_wrap->req == req); const jerry_value_t cb = iotjs_reqwrap_jcallback(&req_wrap->reqwrap); IOTJS_ASSERT(jerry_value_is_function(cb)); iotjs_jargs_t jarg = iotjs_jargs_create(2); if (req->result < 0) { jerry_value_t jerror = iotjs_create_uv_exception(req->result, "open"); iotjs_jargs_append_jval(&jarg, jerror); jerry_release_value(jerror); } else { iotjs_jargs_append_null(&jarg); switch (req->fs_type) { case UV_FS_CLOSE: { break; } case UV_FS_OPEN: case UV_FS_READ: case UV_FS_WRITE: { iotjs_jargs_append_number(&jarg, (double)req->result); break; } case UV_FS_SCANDIR: { int r; uv_dirent_t ent; uint32_t idx = 0; jerry_value_t ret = jerry_create_array(0); while ((r = uv_fs_scandir_next(req, &ent)) != UV_EOF) { jerry_value_t name = jerry_create_string((const jerry_char_t*)ent.name); iotjs_jval_set_property_by_index(ret, idx, name); jerry_release_value(name); idx++; } iotjs_jargs_append_jval(&jarg, ret); jerry_release_value(ret); break; } case UV_FS_FSTAT: case UV_FS_STAT: { uv_stat_t s = (req->statbuf); jerry_value_t ret = MakeStatObject(&s); iotjs_jargs_append_jval(&jarg, ret); jerry_release_value(ret); break; } default: { iotjs_jargs_append_null(&jarg); break; } } } iotjs_make_callback(cb, jerry_create_undefined(), &jarg); iotjs_jargs_destroy(&jarg); iotjs_fs_reqwrap_destroy(req_wrap); }