static void
salt_pcb_free(nif_heap_t *hp, void *obj)
{
struct salt_pcb *sc = obj;
struct salt_msg *sm;
struct salt_msg *tmp;
/* Signal termination request, join worker thread, release all resources. */
enif_mutex_lock(sc->sc_lock);
sc->sc_exit_flag = true;
enif_cond_signal(sc->sc_cond);
enif_mutex_unlock(sc->sc_lock);
(void)enif_thread_join(sc->sc_thread, NULL);
sm = sc->sc_req_first;
loop:
if (sm == NULL)
goto done;
tmp = sm->msg_next;
enif_free_env(sm->msg_heap);
enif_free(sm);
sm = tmp;
goto loop;
done:
enif_mutex_destroy(sc->sc_lock);
enif_cond_destroy(sc->sc_cond);
/* Done, PCB itself released by ERTS. */
return ;
}
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 send_list_seq(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifPid to;
ERL_NIF_TERM msg;
ErlNifEnv* msg_env;
int i, res;
if (!enif_get_int(env, argv[0], &i)) {
return enif_make_badarg(env);
}
if (argv[1] == atom_self) {
enif_self(env, &to);
}
else if (!enif_get_local_pid(env, argv[1], &to)) {
return enif_make_badarg(env);
}
msg_env = enif_alloc_env();
msg = enif_make_list(msg_env,0);
for ( ; i>0 ; i--) {
msg = enif_make_list_cell(msg_env, enif_make_int(msg_env, i), msg);
}
res = enif_send(env, &to, msg_env, msg);
enif_free_env(msg_env);
return enif_make_tuple2(env, atom_ok, enif_make_int(env,res));
}
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 void
layer_destroy(ErlNifEnv *env, void *obj)
{
// Layer is owned by OGRDataSource, should not be deleted
EnvLayer_t **layer = (EnvLayer_t**)obj;
enif_free_env((**layer).env);
enif_free(*layer);
}
void
job_destroy(void* obj)
{
job_ptr job = (job_ptr) obj;
if(job->script.data != NULL) enif_release_binary(&job->script);
if(job->env != NULL) enif_free_env(job->env);
enif_free(job);
}
static void
feature_destroy(ErlNifEnv *env, void *obj)
{
// Feature is owned by the caller
EnvFeature_t **feature = (EnvFeature_t**)obj;
OGR_F_Destroy((**feature).obj);
enif_free_env((**feature).env);
enif_free(*feature);
}
static void
field_defn_destroy(ErlNifEnv *env, void *obj)
{
// OGRFieldDefn should not be freed by the application
EnvFieldDefn_t **field_defn = (EnvFieldDefn_t**)obj;
//OGR_Fld_Destroy(*field_defn);
enif_free_env((**field_defn).env);
enif_free(*field_defn);
}
static void msgenv_dtor(ErlNifEnv* env, void* obj)
{
struct make_term_info* mti = (struct make_term_info*) obj;
if (mti->dst_env != NULL) {
enif_free_env(mti->dst_env);
}
enif_mutex_destroy(mti->mtx);
enif_cond_destroy(mti->cond);
}
static void
command_destroy(void *obj)
{
esqlite_command *cmd = (esqlite_command *) obj;
if(cmd->env != NULL)
enif_free_env(cmd->env);
enif_free(cmd);
}
static void
feature_defn_destroy(ErlNifEnv *env, void *obj)
{
// OGRFeatureDefn is owned by the OGRLayer,
// and should not be modified or freed by the application
EnvFeatureDefn_t **feature_defn = (EnvFeatureDefn_t**)obj;
//OGR_FD_Destroy((**feature_defn).obj);
enif_free_env((**feature_defn).env);
enif_free(*feature_defn);
}
void
cleanup_task(task_t **task)
{
if ((*task)->env != NULL) {
enif_free_env((*task)->env);
}
enif_free(*task);
*task = NULL;
}
static void
release_ecsv_parser(UNUSED(ErlNifEnv * env), void *obj)
{
//enif_fprintf(stderr, "Releasing parser resource\n");
ecsv_parser_t *parser = (ecsv_parser_t *)obj;
enif_free_env(parser->env);
if (parser->current_line.fields) enif_free(parser->current_line.fields);
csv_free(&parser->p);
//enif_fprintf(stderr, "Released parser resource\n");
}
void msg_destroy(void *obj)
{
msg_t *msg = (msg_t *) obj;
if(msg->env != NULL){
// fix
enif_free_env(msg->env);
}
enif_free(msg);
}
void
ewpcap_cleanup(ErlNifEnv *env, void *obj)
{
EWPCAP_STATE *ep = obj;
if (ep->p == NULL)
return;
pcap_breakloop(ep->p);
pcap_close(ep->p);
if (ep->env)
enif_free_env(ep->env);
if (ep->term_env)
enif_free_env(ep->term_env);
(void)memset(ep, 0, sizeof(EWPCAP_STATE));
}
static void DestroyCall(ErlCall *erlCall) {
enif_mutex_lock(callsMutex);
HASH_DEL(calls, erlCall);
enif_clear_env(erlCall->env);
enif_free_env(erlCall->env);
enif_mutex_destroy(erlCall->mutex);
enif_cond_destroy(erlCall->cond);
free(erlCall);
enif_mutex_unlock(callsMutex);
}
void* nif_main_thread(void* obj)
{
ErlNifEnv* env = enif_alloc_env();
nif_thread_state* st = (nif_thread_state*)obj;
nif_thread_message* msg;
while (nif_thread_receive(st, &msg))
nif_thread_handle(env, st, msg);
enif_free_env(env);
return NULL;
}
static void
geometry_destroy(ErlNifEnv *env, void *obj)
{
// If env is NULL then is GeometryRef else is Geometry
// GeometryRef should not be freed by the application
EnvGeometry_t **geometry = (EnvGeometry_t**)obj;
if ((**geometry).env == NULL) {
OGR_G_DestroyGeometry((**geometry).obj);
} else {
enif_free_env((**geometry).env);
}
enif_free(*geometry);
}
static ERL_NIF_TERM send_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifEnv* menv;
ErlNifPid pid;
int ret;
if (!enif_get_local_pid(env, argv[0], &pid)) {
return enif_make_badarg(env);
}
menv = enif_alloc_env();
ret = enif_send(env, &pid, menv, enif_make_copy(menv, argv[1]));
enif_free_env(menv);
return enif_make_int(env, ret);
}
static nif_term_t
salt_enqueue_req(nif_heap_t *hp, struct salt_pcb *sc, nif_pid_t pid, nif_term_t ref, uint_t type, uint_t aux)
{
struct salt_msg *sm;
const char *err;
/* Prepare async request for worker thread. */
sm = enif_alloc(sizeof(*sm));
if (sm == NULL)
return (BADARG);
sm->msg_heap = enif_alloc_env();
assert(sm->msg_heap != NULL);
sm->msg_next = NULL;
sm->msg_from = pid; /* struct copy */
sm->msg_mref = enif_make_copy(sm->msg_heap, ref);
sm->msg_type = type;
sm->msg_aux = aux;
/* Enqueue request checking for failure scenarios. */
enif_mutex_lock(sc->sc_lock);
if (sc->sc_req_npend >= 128) {
err = "congested";
goto fail;
}
if (sc->sc_exit_flag) {
/* XXX This should not even be possible, no? */
err = "exiting";
goto fail;
}
*sc->sc_req_lastp = sm;
sc->sc_req_lastp = &sm->msg_next;
sc->sc_req_npend += 1;
enif_cond_signal(sc->sc_cond);
enif_mutex_unlock(sc->sc_lock);
return (enif_make_atom(hp, "enqueued"));
/* Failure treatment. */
fail:
enif_mutex_unlock(sc->sc_lock);
enif_free_env(sm->msg_heap);
enif_free(sm);
return (enif_make_atom(hp, err));
}
static int lua_ref_gc (lua_State *lua)
{
const int top = lua_gettop(lua);
const erlref_ptr erlref = (erlref_ptr) luaL_checkudata(lua, 1, TYPE_ERL_REF);
luaL_argcheck( lua, erlref, 1, "lua reference expected");
assert(NULL != erlref->env);
enif_free_env(erlref->env);
node_free(erlref);
assert(lua_gettop(lua) == top);
return 0;
}
void nif_write(couchfile_modify_request *rq, couchfile_pointer_info *dst, nif_writerq* wrq, ssize_t size)
{
dst->writerq_resource = wrq;
dst->pointer = 0;
wrq->ptr = dst;
ErlNifEnv* msg_env = enif_alloc_env();
ERL_NIF_TERM msg_term = enif_make_tuple4(msg_env,
get_atom(msg_env, "append_bin_btnif"),
get_atom(msg_env, "snappy"), //COMPRESSION TYPE
enif_make_resource(msg_env, wrq),
enif_make_resource_binary(msg_env, wrq, &wrq->buf, size));
enif_send(rq->caller_env, &rq->writer, msg_env, msg_term);
enif_free_env(msg_env);
enif_release_resource(wrq);
}
static ERL_NIF_TERM send_new_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifPid to;
ERL_NIF_TERM msg, copy;
ErlNifEnv* msg_env;
int res;
if (!enif_get_local_pid(env, argv[0], &to)) {
return enif_make_badarg(env);
}
msg_env = enif_alloc_env();
msg = make_blob(env,msg_env, argv[1]);
copy = make_blob(env,env, argv[1]);
res = enif_send(env, &to, msg_env, msg);
enif_free_env(msg_env);
return enif_make_tuple3(env, atom_ok, enif_make_int(env,res), copy);
}
void queue_destroy(queue *q)
{
int i;
qitem *buf = (qitem*)(q->buf + q->mapbytes*2);
#ifndef _TESTAPP_
for (i = 0; i < q->npages; i++)
{
if (buf[i].env != NULL)
enif_free_env(buf[i].env);
if (buf[i].cmd != NULL)
enif_free(buf[i].cmd);
}
#endif
free(q->buf);
free(q);
}
void
queue_destroy(queue *queue)
{
ErlNifMutex *lock;
ErlNifCond *cond;
int length;
qitem *blocks = NULL;
enif_mutex_lock(queue->lock);
lock = queue->lock;
cond = queue->cond;
length = queue->length;
queue->lock = NULL;
queue->cond = NULL;
queue->head = NULL;
queue->tail = NULL;
queue->length = -1;
while(queue->reuseq != NULL)
{
qitem *tmp = queue->reuseq->next;
if(tmp != NULL && tmp->env != NULL)
enif_free_env(tmp->env);
if (tmp != NULL && tmp->cmd != NULL)
enif_free(tmp->cmd);
if (queue->reuseq->blockStart)
{
queue->reuseq->next = blocks;
blocks = queue->reuseq;
}
queue->reuseq = tmp;
}
while (blocks != NULL)
{
qitem *tmp = blocks->next;
enif_free(blocks);
blocks = tmp;
}
enif_mutex_unlock(lock);
assert(length == 0 && "Attempting to destroy a non-empty queue.");
enif_cond_destroy(cond);
enif_mutex_destroy(lock);
enif_free(queue);
}
static void *
salt_worker_loop(void *arg)
{
struct salt_pcb *sc = arg;
struct salt_msg *sm;
struct salt_msg *tmp;
/* XXX initialization of libsodium */
/* XXX send readiness indication to owner */
/* Pick up next batch of work, react promptly to termination requests. */
loop:
enif_mutex_lock(sc->sc_lock);
wait:
if (sc->sc_exit_flag) {
enif_mutex_unlock(sc->sc_lock);
return (NULL);
}
if (sc->sc_req_first == NULL) {
enif_cond_wait(sc->sc_cond, sc->sc_lock);
goto wait;
}
sm = sc->sc_req_first;
sc->sc_req_first = NULL;
sc->sc_req_lastp = &sc->sc_req_first;
sc->sc_req_npend = 0;
enif_mutex_unlock(sc->sc_lock);
/* Handle all requests, release when done. */
next:
salt_handle_req(sc, sm);
tmp = sm->msg_next;
enif_free_env(sm->msg_heap);
enif_free(sm);
if (tmp == NULL)
goto loop;
sm = tmp;
goto next;
}
void queue_intq_destroy(intq *q)
{
qitem *it;
if (q == NULL)
return;
while ((it = qpop(q)))
{
#ifndef _TESTAPP_
if (it->env)
enif_free_env(it->env);
#endif
if (it->blockStart)
free(it);
}
if (q->head)
{
if (q->head->blockStart)
free(q->head);
}
free(q);
}
static msg_t *msg_create() {
ErlNifEnv *env;
msg_t *msg;
env = enif_alloc_env();
if(env == NULL) {
return NULL;
}
msg = (msg_t *) enif_alloc(sizeof(msg_t));
if(msg == NULL) {
enif_free_env(env);
return NULL;
}
msg->env = env;
msg->type = msg_unknown;
msg->ref = 0;
return msg;
}
job_ptr
job_create()
{
job_ptr ret = (job_ptr) enif_alloc(sizeof(struct job_t));
if(ret == NULL) return NULL;
ret->type = job_unknown;
ret->env = enif_alloc_env();
if(ret->env == NULL) goto error;
ret->ref = 0;
ret->script.data = NULL;
ret->script.size = 0;
ret->error = 0;
return ret;
error:
if(ret->env != NULL) enif_free_env(ret->env);
enif_free(ret);
return NULL;
}
static ERL_NIF_TERM
send(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifEnv* cp_env = enif_alloc_env();
ErlNifPid dst;
ERL_NIF_TERM msg;
ERL_NIF_TERM ret;
if(argc == 1) {
if(!enif_self(env, &dst)) {
ret = enif_make_badarg(env);
goto done;
}
msg = argv[0];
} else if(argc == 2) {
if(!enif_get_local_pid(env, argv[0], &dst)) {
ret = enif_make_badarg(env);
goto done;
}
msg = argv[1];
} else {
ret = enif_make_badarg(env);
goto done;
}
msg = enif_make_copy(cp_env, msg);
if(!enif_send(env, &dst, cp_env, msg)) {
ret = enif_make_badarg(env);
goto done;
}
ret = enif_make_atom(env, "ok");
done:
enif_free_env(cp_env);
return ret;
}
