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