static ERL_NIF_TERM
utc_to_datetime(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(argc != 1) {
return enif_make_badarg(env);
}
unsigned int utc;
if(!enif_get_uint(env, argv[0], &utc)) {
return enif_make_badarg(env);
}
time_t now = utc;
struct tm result;
gmtime_r(&now, &result);
return enif_make_tuple2(env,
enif_make_tuple3(env,
enif_make_int(env, result.tm_year + 1900),
enif_make_int(env, result.tm_mon + 1),
enif_make_int(env, result.tm_mday)
),
enif_make_tuple3(env,
enif_make_int(env, result.tm_hour),
enif_make_int(env, result.tm_min),
enif_make_int(env, result.tm_sec)
)
);
}
static ERL_NIF_TERM
nif_scheduler_declineOffer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
ErlNifBinary offerId_binary;
ErlNifBinary filters_binary;
state_ptr state = (state_ptr) enif_priv_data(env);
if(state->initilised == 0 )
{
return enif_make_tuple2(env,
enif_make_atom(env, "state_error"),
enif_make_atom(env, "scheduler_not_inited"));
}
if (!enif_inspect_binary(env, argv[0], &offerId_binary))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "offer_id"));
}
if (!enif_inspect_binary(env, argv[1], &filters_binary))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "filters"));
}
SchedulerDriverStatus status = scheduler_declineOffer( state->scheduler_state, &offerId_binary, &filters_binary );
return get_return_value_from_status(env, status);
}
static ERL_NIF_TERM send_blob_thread(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
union { void* vp; struct make_term_info* p; }mti;
ERL_NIF_TERM copy;
if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)
|| !enif_get_local_pid(env,argv[1], &mti.p->to_pid)) {
return enif_make_badarg(env);
}
copy = enif_make_copy(env, mti.p->blob);
mti.p->send_it = enif_is_identical(argv[2],atom_join);
if (enif_thread_create("nif_SUITE:send_from_thread", &mti.p->tid,
threaded_sender, mti.p, NULL) != 0) {
return enif_make_badarg(env);
}
if (enif_is_identical(argv[2],atom_join)) {
int err = enif_thread_join(mti.p->tid, NULL);
assert(err == 0);
return enif_make_tuple3(env, atom_ok, enif_make_int(env, mti.p->send_res), copy);
}
else {
enif_keep_resource(mti.vp);
return enif_make_tuple2(env, atom_ok, copy);
}
}
static ERL_NIF_TERM
nif_sendmsg(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int s = -1;
ErlNifBinary msg = {0};
int flags = 0;
ssize_t n = 0;
if (!enif_get_int(env, argv[0], &s))
return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[1], &msg))
return enif_make_badarg(env);
if (!enif_get_int(env, argv[2], &flags))
return enif_make_badarg(env);
if (msg.size != sizeof(struct msghdr))
return enif_make_badarg(env);
/* Make the binary mutable */
if (!enif_realloc_binary(&msg, msg.size))
return error_tuple(env, ENOMEM);
n = sendmsg(s, (const struct msghdr *)msg.data, flags);
if (n < 0)
return error_tuple(env, errno);
return enif_make_tuple3(env,
atom_ok,
enif_make_ulong(env, n),
enif_make_binary(env, &msg));
}
void
update_callback(void *arg, int sqlite_operation_type, char const *sqlite_database, char const *sqlite_table, sqlite3_int64 sqlite_rowid)
{
esqlite_connection *db = (esqlite_connection *)arg;
esqlite_command *cmd = NULL;
ERL_NIF_TERM type, table, rowid;
cmd = command_create();
if(db == NULL)
return;
if(!cmd)
return;
rowid = enif_make_int64(cmd->env, sqlite_rowid);
table = enif_make_string(cmd->env, sqlite_table, ERL_NIF_LATIN1);
switch(sqlite_operation_type) {
case SQLITE_INSERT:
type = make_atom(cmd->env, "insert");
break;
case SQLITE_DELETE:
type = make_atom(cmd->env, "delete");
break;
case SQLITE_UPDATE:
type = make_atom(cmd->env, "update");
break;
default:
return;
}
cmd->type = cmd_notification;
cmd->arg = enif_make_tuple3(cmd->env, type, table, rowid);
push_command(cmd->env, db, cmd);
}
static struct zdoor_result *
zdoor_cb(struct zdoor_cookie *cookie, char *argp, size_t argp_sz)
{
struct door *d;
struct req *r;
ErlNifEnv *env = enif_alloc_env();
/* we kept the struct door in the biscuit */
d = (struct door *)cookie->zdc_biscuit;
/* this request */
r = req_alloc();
/* take the rlist lock first, then the req lock */
enif_rwlock_rwlock(d->rlock);
enif_mutex_lock(r->lock);
req_insert(d, r);
enif_rwlock_rwunlock(d->rlock);
/* make the request into a binary term to put it into enif_send() */
ErlNifBinary bin;
enif_alloc_binary(argp_sz, &bin);
memcpy(bin.data, argp, argp_sz);
ERL_NIF_TERM binTerm = enif_make_binary(env, &bin);
/* send a message back to the session owner */
enif_send(NULL, &d->owner, env,
enif_make_tuple3(env,
enif_make_atom(env, "zdoor"),
enif_make_resource(env, r),
binTerm));
/* now wait until the request has been replied to */
enif_cond_wait(r->cond, r->lock);
/* convert the reply into a zdoor_result */
/* we have to use naked malloc() since libzdoor will use free() */
struct zdoor_result *res = malloc(sizeof(struct zdoor_result));
res->zdr_size = r->replen;
res->zdr_data = r->rep;
r->rep = NULL;
r->replen = 0;
/* yes, we have to unlock and re-lock to avoid lock inversion here */
enif_mutex_unlock(r->lock);
/* remove and free the struct req */
enif_rwlock_rwlock(d->rlock);
enif_mutex_lock(r->lock);
req_remove(d, r);
enif_rwlock_rwunlock(d->rlock);
req_free(r);
enif_free_env(env);
return res;
}
static ERL_NIF_TERM pwrite_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
ErlNifIOVec vec, *input = &vec;
Sint64 bytes_written, offset;
ERL_NIF_TERM tail;
if(argc != 2 || !enif_is_number(env, argv[0])
|| !enif_inspect_iovec(env, 64, argv[1], &tail, &input)) {
return enif_make_badarg(env);
}
if(!enif_get_int64(env, argv[0], &offset) || offset < 0) {
return posix_error_to_tuple(env, EINVAL);
}
bytes_written = efile_pwritev(d, offset, input->iov, input->iovcnt);
if(bytes_written < 0) {
return posix_error_to_tuple(env, d->posix_errno);
}
if(!enif_is_empty_list(env, tail)) {
ASSERT(bytes_written > 0);
return enif_make_tuple3(env, am_continue,
enif_make_int64(env, bytes_written), tail);
}
return am_ok;
}
void
ewpcap_error(EWPCAP_STATE *ep, char *msg)
{
int rv = 0;
if (ep->p == NULL)
return;
/* {ewpcap_error, Ref, Error} */
rv = enif_send(
NULL,
&ep->pid,
ep->env,
enif_make_tuple3(ep->env,
atom_ewpcap_error,
enif_make_copy(ep->env, ep->ref),
enif_make_string(ep->env, msg, ERL_NIF_LATIN1)
)
);
if (!rv)
pcap_breakloop(ep->p);
enif_clear_env(ep->env);
}
static void*
_reading_thread (void* arg)
{
CAN_handle* handle = arg;
ErlNifEnv* env = enif_alloc_env();
//ERL_NIF_TERM device = enif_make_int(env, handle->device);
handle->threaded = 1;
while (handle->threaded)
{
int status;
ERL_NIF_TERM msg = _receive_can_messages(env, handle, handle->chunk_size, handle->timeout);
if (!enif_get_int(env, msg, &status))
{
enif_send(env, &handle->receiver, env, enif_make_tuple3(env, can_atom, handle->devpath_bin, msg));
enif_clear_env(env);
}
else if (status == 0)
{
enif_clear_env(env);
}
else break;
}
enif_free_env(env);
return 0;
}
static ERL_NIF_TERM macros(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
const ERL_NIF_TERM* a;
ERL_NIF_TERM lists, tuples;
int arity;
if (!enif_get_tuple(env, argv[0], &arity, &a) || arity != 9) {
return enif_make_badarg(env);
}
lists = enif_make_list(env,9,
enif_make_list1(env,a[0]),
enif_make_list2(env,a[0],a[1]),
enif_make_list3(env,a[0],a[1],a[2]),
enif_make_list4(env,a[0],a[1],a[2],a[3]),
enif_make_list5(env,a[0],a[1],a[2],a[3],a[4]),
enif_make_list6(env,a[0],a[1],a[2],a[3],a[4],a[5]),
enif_make_list7(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6]),
enif_make_list8(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]),
enif_make_list9(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]));
tuples = enif_make_list(env,9,
enif_make_tuple1(env,a[0]),
enif_make_tuple2(env,a[0],a[1]),
enif_make_tuple3(env,a[0],a[1],a[2]),
enif_make_tuple4(env,a[0],a[1],a[2],a[3]),
enif_make_tuple5(env,a[0],a[1],a[2],a[3],a[4]),
enif_make_tuple6(env,a[0],a[1],a[2],a[3],a[4],a[5]),
enif_make_tuple7(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6]),
enif_make_tuple8(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]),
enif_make_tuple9(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]));
return enif_make_tuple2(env,lists,tuples);
}
//key, incr, ttl, timestamp
static ERL_NIF_TERM update(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
int ttl=0, timestamp=0, incr=0, next=0;
CHECK(enif_get_string(env, argv[0], keybuff, KEY_MAX_LEN, ERL_NIF_LATIN1));
CHECK(enif_get_int(env, argv[1], &incr));
CHECK(enif_get_int(env, argv[2], &ttl));
CHECK(enif_get_int(env, argv[3], ×tamp));
metronome_item * item = find_in_hash(keybuff, timestamp);
item->ttl = ttl;
if(item->timestamp + ttl > timestamp) {
item->value += incr;
next = item->timestamp + ttl - timestamp;
} else {
item->value = incr;
item->timestamp = timestamp;
next = ttl;
}
//
return enif_make_tuple3(env,
enif_make_atom(env, "ok"),
enif_make_int(env, item->value),
enif_make_int(env, next)
);
}
static ERL_NIF_TERM
nif_scheduler_reconcileTasks(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
unsigned int length ;
state_ptr state = (state_ptr) enif_priv_data(env);
if(state->initilised == 0 )
{
return enif_make_tuple2(env,
enif_make_atom(env, "state_error"),
enif_make_atom(env, "scheduler_not_inited"));
}
if(!enif_is_list(env, argv[0]))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "task_status_array"));
};
if(!enif_get_list_length(env, argv[0], &length))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "task_status_array"));
}
ErlNifBinary binary_arr[length];
if(!inspect_array_of_binary_objects(env, argv[0], &binary_arr ))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "task_status_array"));
}
BinaryNifArray binaryNifArrayHolder ;
binaryNifArrayHolder.length = length;
binaryNifArrayHolder.obj = &binary_arr[0];
SchedulerDriverStatus status = scheduler_reconcileTasks( state->scheduler_state, &binaryNifArrayHolder);
return get_return_value_from_status(env, status);
}
static ERL_NIF_TERM _load(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
UNUSED(argc);
ErlNifBinary in,out;
struct jpeg_decompress_struct cinfo;
struct error_mgr jerr;
unsigned int width, height;
enif_inspect_binary(env,argv[0],&in);
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = error_exit;
if (setjmp(jerr.setjmp_buffer)) {
jpeg_destroy_decompress(&cinfo);
return -1;
}
jpeg_create_decompress(&cinfo);
jpeg_mem_src(&cinfo, in.data, in.size);
jpeg_read_header (&cinfo, TRUE);
width = cinfo.image_width;
height = cinfo.image_height;
enif_alloc_binary(width*height*3,&out);
cinfo.do_block_smoothing = TRUE;
cinfo.do_fancy_upsampling = TRUE;
cinfo.out_color_space = JCS_RGB;
jpeg_start_decompress(&cinfo);
JSAMPROW rowp[1];
unsigned long location = 0;
rowp[0] = (unsigned char*) malloc(cinfo.output_width*cinfo.num_components);
unsigned int i = 0;
while (cinfo.output_scanline < cinfo.output_height){
jpeg_read_scanlines(&cinfo, rowp, 1);
for( i=0; i<cinfo.image_width*cinfo.num_components;i++)
out.data[location++] = rowp[0][i];
}
free(rowp[0]);
jpeg_finish_decompress (&cinfo);
jpeg_destroy_decompress (&cinfo);
return enif_make_tuple2(env,
enif_make_atom(env,"ok"),
enif_make_tuple3(env,
enif_make_int(env,width),
enif_make_int(env,height),
enif_make_binary(env, &out)
)
);
}
static ERL_NIF_TERM make_term_tuple(struct make_term_info* mti, int n)
{
ERL_NIF_TERM t[3];
t[0] = pull_term(mti);
t[1] = pull_term(mti);
t[2] = pull_term(mti);
return enif_make_tuple3(mti->dst_env, t[0], t[1], t[2]);
}
ERL_NIF_TERM geef_library_version(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int major, minor, rev;
git_libgit2_version(&major, &minor, &rev);
return enif_make_tuple3(env, enif_make_int(env, major), enif_make_int(env, minor), enif_make_int(env, rev));
}
/*-----------------------------------------------------------------------------------------------------------------------*/
static ERL_NIF_TERM binary_to_msg(ErlNifEnv* env, int32_t argc, ERL_NIF_TERM const argv[])
{
ERL_NIF_TERM parser_res;
ParserRes* parser = NULL;
ERL_NIF_TERM res = get_parser(env, argv[0], &parser_res, &parser);
if (res != ok_atom)
{
return res;
}
int32_t delimiter = 0;
if (!enif_get_int(env, argv[1], &delimiter) || delimiter <= 0 || delimiter >= 255)
{
return make_error(env, FIX_FAILED, "Wrong delimiter.");
}
ErlNifBinary bin;
if (!enif_inspect_binary(env, argv[2], &bin))
{
return make_error(env, FIX_FAILED, "Wrong binary.");
}
char const* stop = NULL;
FIXError* error = NULL;
pthread_rwlock_wrlock(&parser->lock);
FIXMsg* fix_msg = fix_parser_str_to_msg(parser->ptr, (char const*)bin.data, bin.size, delimiter, &stop, &error);
pthread_rwlock_unlock(&parser->lock);
if (!fix_msg)
{
ERL_NIF_TERM ret = make_parser_error(env, fix_error_get_code(error), fix_error_get_text(error));
fix_error_free(error);
return ret;
}
MsgRes* msg_res = (MsgRes*)enif_alloc_resource(message_res, sizeof(MsgRes));
msg_res->msg = fix_msg;
msg_res->lock = &parser->lock;
ERL_NIF_TERM msg_term = enif_make_resource(env, msg_res);
enif_release_resource(msg_res);
uint32_t pos = stop - (char const*)bin.data + 1;
char const* msgType = fix_msg_get_type(fix_msg);
return enif_make_tuple3(
env,
ok_atom,
enif_make_tuple3(env,
msg_atom,
enif_make_string(env, msgType, ERL_NIF_LATIN1),
enif_make_tuple2(env, parser_res, msg_term)),
enif_make_sub_binary(env, argv[2], pos, bin.size - pos));
}
/*-----------------------------------------------------------------------------------------------------------------------*/
static ERL_NIF_TERM make_error(ErlNifEnv* env, int32_t errCode, char const* errorMsg, ...)
{
va_list ap;
va_start(ap, errorMsg);
char text[1024];
vsnprintf(text, sizeof(text), errorMsg, ap);
return enif_make_tuple3(env, error_atom, enif_make_int(env, errCode), enif_make_string(env, text, ERL_NIF_LATIN1));
}
static ERL_NIF_TERM
_receive_can_messages (ErlNifEnv* env,
CAN_handle* handle,
unsigned int chunk_size,
long timeout)
{
int length = 0,
i = 0,
chunks = 0;
ERL_NIF_TERM *list, result;
canmsg_t buffer[sizeof(canmsg_t) * BUFFER_LIMIT];
do {
int status = _wait_for_input(handle, timeout);
if (status == 0) break;
if (status == -1)
{
result = enif_make_int(env, errno);
goto end;
}
length = read(handle->device, &buffer[chunks], sizeof(canmsg_t) * chunk_size);
if (length < 0) break;
chunks += length / sizeof(canmsg_t) ;
} while (length > 0 && chunks <= BUFFER_LIMIT && chunks < chunk_size);
if (chunks > 0)
{
if (handle->raw)
{
void* data = enif_make_new_binary(env, chunks * sizeof(canmsg_t), &result);
memcpy(data, buffer, chunks * sizeof(canmsg_t));
}
else
{
list = enif_alloc(sizeof(ERL_NIF_TERM) * chunks);
// rewrite canmsgs to list of tuples
for (i = 0; i < chunks; i++)
{
canmsg_t* can_msg = buffer + i;
ERL_NIF_TERM bin;
void* data = enif_make_new_binary(env, can_msg->length, &bin);
memcpy(data, can_msg->data, can_msg->length);
list[i] = enif_make_tuple3(env,
enif_make_int(env, can_msg->id),
enif_make_tuple2(env,
enif_make_long(env, can_msg->timestamp.tv_sec),
enif_make_long(env, can_msg->timestamp.tv_usec)),
bin);
}
result = enif_make_list_from_array(env, list, chunks);
enif_free(list);
}
}
else if (length == 0)
result = enif_make_int(env, 0);
else
result = enif_make_int(env, errno);
end:
return result;
}
static ERL_NIF_TERM
nif_scheduler_sendFrameworkMessage(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
ErlNifBinary executorId_binary;
ErlNifBinary slaveId_binary;
char data[MAXBUFLEN];
state_ptr state = (state_ptr) enif_priv_data(env);
if(state->initilised == 0 )
{
return enif_make_tuple2(env,
enif_make_atom(env, "state_error"),
enif_make_atom(env, "scheduler_not_inited"));
}
if (!enif_inspect_binary(env, argv[0], &executorId_binary))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "executor_id"));
}
if (!enif_inspect_binary(env, argv[1], &slaveId_binary))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "slave_id"));
}
//REVIEW : buffer length
if(!enif_get_string(env, argv[2], data , MAXBUFLEN, ERL_NIF_LATIN1 ))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "data"));
}
SchedulerDriverStatus status = scheduler_sendFrameworkMessage( state->scheduler_state ,
&executorId_binary,
&slaveId_binary,
data);
return get_return_value_from_status(env, status);
}
void
vm_set_error(vm_ptr vm, ENBINARY mesg, ENBINARY src, unsigned int line)
{
ENTERM tmesg = enif_make_binary(vm->curr_job->env, &mesg);
ENTERM tsrc = enif_make_binary(vm->curr_job->env, &src);
ENTERM tline = enif_make_int(vm->curr_job->env, line);
vm->curr_job->error = enif_make_tuple3(
vm->curr_job->env, tmesg, tsrc, tline
);
}
static ERL_NIF_TERM
nif_scheduler_stop(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
int failover;
state_ptr state = (state_ptr) enif_priv_data(env);
if(state->initilised == 0 )
{
return enif_make_tuple2(env,
enif_make_atom(env, "state_error"),
enif_make_atom(env, "sheduler_not_inited"));
}
if(!enif_get_int( env, argv[0], &failover))
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "failover"));
}
if(failover < 0 || failover > 1)
{
return enif_make_tuple3(env,
enif_make_atom(env, "argument_error"),
enif_make_atom(env, "invalid_or_corrupted_parameter"),
enif_make_atom(env, "failover"));
}
SchedulerDriverStatus status = scheduler_stop( state->scheduler_state, failover );
if(status == 4){ // driver_stopped
return enif_make_tuple2(env,
enif_make_atom(env, "ok"),
get_atom_from_status(env, status));
}else{
return enif_make_tuple2(env,
enif_make_atom(env, "error"),
get_atom_from_status(env, status));
}
}
ERL_NIF_TERM return_value(ErlNifEnv* env, void * cookie) {
struct libcouchbase_callback *cb;
cb = (struct libcouchbase_callback *)cookie;
ErlNifBinary value_binary;
ERL_NIF_TERM term;
enif_alloc_binary(cb->size, &value_binary);
memcpy(value_binary.data, cb->data, cb->size);
term = enif_make_tuple3(env, enif_make_int(env, cb->cas),
enif_make_int(env, cb->flag),
enif_make_binary(env, &value_binary));
free(cb->data);
return term;
}
/**
* Convert an UErrorCode to an atom.
*/
ERL_NIF_TERM parse_error(ErlNifEnv* env, UErrorCode status,
UParseError* e) {
return build_error(env,
enif_make_tuple3(env,
enif_make_atom(env, u_errorName(status)),
enif_make_tuple2(env,
enif_make_atom(env, "line"),
enif_make_int(env, (int) e->line)),
enif_make_tuple2(env,
enif_make_atom(env, "offset"),
enif_make_int(env, (int) e->offset))
));
}
/**
* An element it the list has a bad type.
* Used by i18n_message.
*/
ERL_NIF_TERM list_element_error(ErlNifEnv* env,
const ERL_NIF_TERM list, int32_t num) {
return build_error(env,
enif_make_tuple3(env,
enif_make_atom(env, "bad_element"),
enif_make_tuple2(env,
enif_make_atom(env, "list"),
list),
enif_make_tuple2(env,
enif_make_atom(env, "index"),
enif_make_int(env, (int) num))
));
}
static ERL_NIF_TERM send_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
union { void* vp; struct make_term_info* p; }mti;
ErlNifPid to;
ERL_NIF_TERM copy;
int res;
if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)
|| !enif_get_local_pid(env, argv[1], &to)) {
return enif_make_badarg(env);
}
copy = enif_make_copy(env, mti.p->blob);
res = enif_send(env, &to, mti.p->dst_env, mti.p->blob);
return enif_make_tuple3(env, atom_ok, enif_make_int(env,res), copy);
}
static ERL_NIF_TERM mark_to_term(ErlNifEnv *env, yaml_mark_t *mark)
{
if(mark)
{
return enif_make_tuple3(env,
enif_make_ulong(env, mark->index),
enif_make_ulong(env, mark->line),
enif_make_ulong(env, mark->column));
}
else
{
return enif_make_atom(env, "null");
}
}
static ERL_NIF_TERM make_token(ErlNifEnv* env,token_t* t)
{
ERL_NIF_TERM r;
switch(t->type) {
case ';':
// {';',<line-number>> }
r = enif_make_tuple2(env, atm_semi,
enif_make_int(env,t->line));
return r;
case '{':
// {'{',<line-number>> }
r = enif_make_tuple2(env, atm_curl_left,
enif_make_int(env, t->line));
return r;
case '}':
// {'}',<line-number>> }
r = enif_make_tuple2(env, atm_curl_right,
enif_make_int(env, t->line));
return r;
case TOKEN_WORD:
// {word, <linenumber>, binary() }
r = enif_make_tuple3(env, atm_word,
enif_make_int(env, t->line),
enif_make_binary(env, &t->bin));
return r;
case TOKEN_STRING:
// {string, <linenumber>, binary() }
r = enif_make_tuple3(env, atm_string,
enif_make_int(env, t->line),
enif_make_binary(env, &t->bin));
return r;
default:
return enif_make_badarg(env);
}
}
/* 0: socket, 1: length, 2: flags, 3: struct sockaddr length */
static ERL_NIF_TERM
nif_recvfrom(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int sockfd = -1;
unsigned long len = 0;
unsigned long salen = 0;
int flags = 0;
ErlNifBinary buf = {0};
ErlNifBinary sa = {0};
ssize_t bufsz = 0;
if (!enif_get_int(env, argv[0], &sockfd))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &len))
return enif_make_badarg(env);
if (!enif_get_int(env, argv[2], &flags))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[3], &salen))
return enif_make_badarg(env);
if (!enif_alloc_binary(len, &buf))
return error_tuple(env, ENOMEM);
if (!enif_alloc_binary(salen, &sa))
return error_tuple(env, ENOMEM);
if ( (bufsz = recvfrom(sockfd, buf.data, buf.size, flags,
(sa.size == 0 ? NULL : (struct sockaddr *)sa.data),
(socklen_t *)&salen)) == -1) {
enif_release_binary(&buf);
enif_release_binary(&sa);
switch (errno) {
case EAGAIN:
case EINTR:
return enif_make_tuple2(env, atom_error, atom_eagain);
default:
return error_tuple(env, errno);
}
}
PROCKET_REALLOC(buf, bufsz);
PROCKET_REALLOC(sa, salen);
return enif_make_tuple3(env, atom_ok, enif_make_binary(env, &buf),
enif_make_binary(env, &sa));
}
// Retrieves dataspace dimension size and maximum size.
ERL_NIF_TERM h5sget_simple_extent_dims(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
hid_t dataspace_id;
hsize_t *dims = NULL;
hsize_t *maxdims = NULL;
int status;
ERL_NIF_TERM dims_list;
ERL_NIF_TERM maxdims_list;
ERL_NIF_TERM* dims_arr;
ERL_NIF_TERM* maxdims_arr;
int rank;
// parse arguments
check(argc == 2, "Incorrent number of arguments");
check(enif_get_int(env, argv[0], &dataspace_id), "Can't get resource from argv");
check(enif_get_int(env, argv[1], &rank), "Can't get rank from argv");
// allocate space for dims array to store a number of dimensions
dims = malloc(rank * sizeof(hsize_t));
maxdims = malloc(rank * sizeof(hsize_t));
// get a number of dims from dataspace
status = H5Sget_simple_extent_dims(dataspace_id, dims, maxdims);
check(status > 0, "Failed to get dims.");
// allocate mem for arrays of ERL_NIF_TERM so we could convert
dims_arr = (ERL_NIF_TERM*)enif_alloc(sizeof(ERL_NIF_TERM) * rank);
maxdims_arr = (ERL_NIF_TERM*)enif_alloc(sizeof(ERL_NIF_TERM) * rank);
// convert arrays into array of ERL_NIF_TERM
check(!convert_array_to_nif_array(env, rank, dims, dims_arr), "can't convert array");
check(!convert_array_to_nif_array(env, rank, maxdims, maxdims_arr), "can't convert array");
// convert arrays to list
dims_list = enif_make_list_from_array(env, dims_arr, rank);
maxdims_list = enif_make_list_from_array(env, maxdims_arr, rank);
// cleanup
free(dims);
free(maxdims);
return enif_make_tuple3(env, ATOM_OK, dims_list, maxdims_list);
error:
if(dims) free(dims);
if(maxdims) free(maxdims);
return error_tuple(env, "Can not get dims");
};
static ERL_NIF_TERM nacl_box_keypair(ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[])
{
ErlNifBinary pk, sk;
if (!enif_alloc_binary(crypto_box_PUBLICKEYBYTES, &pk))
return nacl_error_tuple(env, "alloc_failed");
if (!enif_alloc_binary(crypto_box_SECRETKEYBYTES, &sk))
return nacl_error_tuple(env, "alloc_failed");
crypto_box_keypair(pk.data, sk.data);
return enif_make_tuple3(env,
enif_make_atom(env, "nacl_box_keypair"),
enif_make_binary(env, &pk),
enif_make_binary(env, &sk));
}
