// 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);
}
