コード例 #1
0
ファイル: esqlite3_nif.c プロジェクト: alepharchives/esqlite
/*
 * Bind a variable to a prepared statement
 */
static ERL_NIF_TERM 
esqlite_bind(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    esqlite_statement *stmt;
    esqlite_command *cmd = NULL;
    ErlNifPid pid;

    if(argc != 4) 
	    return enif_make_badarg(env);
    if(!enif_get_resource(env, argv[0], esqlite_statement_type, (void **) &stmt))
	    return enif_make_badarg(env);
    if(!enif_is_ref(env, argv[1])) 
	    return make_error_tuple(env, "invalid_ref");
    if(!enif_get_local_pid(env, argv[2], &pid)) 
	    return make_error_tuple(env, "invalid_pid"); 

    cmd = command_create();
    if(!cmd) 
	    return make_error_tuple(env, "command_create_failed");

    cmd->type = cmd_bind;
    cmd->ref = enif_make_copy(cmd->env, argv[1]);
    cmd->pid = pid;
    cmd->stmt = stmt->statement;
    cmd->arg = enif_make_copy(cmd->env, argv[3]);

    if(!stmt->connection) 
	    return make_error_tuple(env, "no_connection");
    if(!stmt->connection->commands)
	    return make_error_tuple(env, "no_command_queue");

    return push_command(env, stmt->connection, cmd);
}
コード例 #2
0
ファイル: esqlite3_nif.c プロジェクト: alepharchives/esqlite
/*
 * Prepare the sql statement
 */
static ERL_NIF_TERM 
esqlite_prepare(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    esqlite_connection *conn;
    esqlite_command *cmd = NULL;
    ErlNifPid pid;

    if(argc != 4) 
	    return enif_make_badarg(env);
    if(!enif_get_resource(env, argv[0], esqlite_connection_type, (void **) &conn))
	    return enif_make_badarg(env);
    if(!enif_is_ref(env, argv[1])) 
	    return make_error_tuple(env, "invalid_ref");
    if(!enif_get_local_pid(env, argv[2], &pid)) 
	    return make_error_tuple(env, "invalid_pid"); 

    cmd = command_create();
    if(!cmd) 
	    return make_error_tuple(env, "command_create_failed");

    cmd->type = cmd_prepare;
    cmd->ref = enif_make_copy(cmd->env, argv[1]);
    cmd->pid = pid;
    cmd->arg = enif_make_copy(cmd->env, argv[3]);

    return push_command(env, conn, cmd);
}
コード例 #3
0
ファイル: esnappy_nif.cpp プロジェクト: fdmanana/esnappy
task_t*
init_task(task_type_t type, ERL_NIF_TERM ref, ErlNifPid pid,
    ERL_NIF_TERM orig_term)
{
    ERL_NIF_TERM  term;
    task_t       *task;

    task = init_empty_task(type);

    task->pid = pid;
    task->env = enif_alloc_env();

    if (task->env == NULL) {
        cleanup_task(&task);
        goto done;
    }

    term = enif_make_copy(task->env, orig_term);

    if (!enif_inspect_binary(task->env, term, &task->data)) {
        cleanup_task(&task);
        goto done;
    }

    task->ref = enif_make_copy(task->env, ref);

done:
    return task;
}
コード例 #4
0
ファイル: esqlite3_nif.c プロジェクト: alepharchives/esqlite
/* 
 * Open the database
 */
static ERL_NIF_TERM
esqlite_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    esqlite_connection *db;
    esqlite_command *cmd = NULL;
    ErlNifPid pid;
     
    if(argc != 4) 
	    return enif_make_badarg(env);     
    if(!enif_get_resource(env, argv[0], esqlite_connection_type, (void **) &db))
	    return enif_make_badarg(env);
    if(!enif_is_ref(env, argv[1])) 
	    return make_error_tuple(env, "invalid_ref");
    if(!enif_get_local_pid(env, argv[2], &pid)) 
	    return make_error_tuple(env, "invalid_pid");

    /* Note, no check is made for the type of the argument */
    cmd = command_create();
    if(!cmd) 
	    return make_error_tuple(env, "command_create_failed");

    cmd->type = cmd_open;
    cmd->ref = enif_make_copy(cmd->env, argv[1]);
    cmd->pid = pid;
    cmd->arg = enif_make_copy(cmd->env, argv[3]);

    return push_command(env, db, cmd);
}
コード例 #5
0
ファイル: brine_nif.c プロジェクト: monkeygroover/brine
static void generate_keypair_from_seed(brine_task_s *task) {
  ErlNifEnv *env = task->env;
  ERL_NIF_TERM result;
  brine_keypair_s *keypair = (brine_keypair_s *) enif_alloc_resource(brine_keypair_resource, sizeof(brine_keypair_s));
  ErlNifBinary seed;

  if (!keypair) {
    result = BRINE_ERROR_NO_MEMORY;
  }
  else {
    if (!enif_inspect_binary(env, task->options.generate.seed, &seed)) {
      result = BRINE_ATOM_ERROR;
    }
    else {
      if (!brine_init_keypair_from_seed(keypair, seed.data, seed.size)) {
        result = BRINE_ATOM_ERROR;
      }
      else {
        result = enif_make_tuple2(env, enif_make_copy(env, BRINE_ATOM_OK), make_keypair_record(env, keypair));
      }
    }
    enif_release_resource(keypair);
  }
  enif_send(NULL, &task->owner, task->env, enif_make_tuple2(env, task->ref, result));
}
コード例 #6
0
ファイル: elibart.c プロジェクト: Leapsight/elibart
static int prefix_cb(void *data, const unsigned char *k, uint32_t k_len, void *val) 
{
    callback_data *cb_data = data;
    art_elem_struct *elem = val;
    ErlNifBinary key, value;

    enif_alloc_binary(k_len - 1, &key);
    memcpy(key.data, k, k_len - 1);

    enif_alloc_binary(elem->size, &value);
    memcpy(value.data, elem->data, elem->size);

    ErlNifEnv *msg_env = enif_alloc_env();

    if(msg_env == NULL)
        return mk_error(cb_data->env, "env_alloc_error");;

    ERL_NIF_TERM caller_ref = enif_make_copy(msg_env, cb_data->caller_ref);

    ERL_NIF_TERM res = enif_make_tuple2(msg_env, 
        caller_ref,
        enif_make_tuple2(msg_env, 
            enif_make_binary(msg_env, &key), enif_make_binary(msg_env, &value)));
    
    if(!enif_send(cb_data->env, &cb_data->pid, msg_env, res))
    {
        enif_free(msg_env);

        return -1;
    }

    enif_free(msg_env);    

    return 0;
}
コード例 #7
0
ファイル: nif_SUITE.c プロジェクト: cristiangreco/otp
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);
    }
}
コード例 #8
0
ファイル: elua.c プロジェクト: indie21/elua
static ERL_NIF_TERM
elua_newstate_async(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    msg_t *msg;
    ErlNifPid pid;

    if(argc != 2) {
        return enif_make_badarg(env);
    }

    // ref
    if(!enif_is_ref(env, argv[0])){
        return make_error_tuple(env, "invalid_ref");
    }

    // dest pid
    if(!enif_get_local_pid(env, argv[1], &pid)) {
        return make_error_tuple(env, "invalid_pid");
    }

    msg = msg_create();
    if(!msg) {
        return make_error_tuple(env, "command_create_failed");
    }

    msg->type = msg_newstate;
    msg->ref = enif_make_copy(msg->env, argv[0]);
    msg->pid = pid;
    msg->hold_env = env;
    msg->res=NULL;

    return push_command(env, NULL, msg);
}
コード例 #9
0
ファイル: lgeo_ogr.c プロジェクト: namjae/lgeo
/* OGRFeatureDefnH OGR_L_GetLayerDefn(OGRLayerH hLayer)

{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
{ok, Layer} = lgeo_ogr:ds_get_layer(DataSource, 0),
{ok, FeatureDefn} = lgeo_ogr:l_get_layer_defn(Layer).

*/
static ERL_NIF_TERM
l_get_layer_defn(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    EnvLayer_t **layer;
    ERL_NIF_TERM eterm;

    if (argc != 1) {
        return enif_make_badarg(env);
    }

    if(!enif_get_resource(env, argv[0], OGR_L_RESOURCE, (void**)&layer)) {
        return enif_make_badarg(env);
    }

    OGRFeatureDefnH feat_defn = OGR_L_GetLayerDefn((**layer).obj);

    EnvFeatureDefn_t **feature_defn = \
        enif_alloc_resource(OGR_FD_RESOURCE, sizeof(EnvFeatureDefn_t*));

    ErlNifEnv *feature_defn_env = enif_alloc_env();

    *feature_defn = (EnvFeatureDefn_t*) enif_alloc(sizeof(EnvFeatureDefn_t));
    (**feature_defn).env = feature_defn_env;
    (**feature_defn).obj = feat_defn;

    // Save copy of layer so is not garbage collected
    enif_make_copy(feature_defn_env, argv[0]);

    eterm = enif_make_resource(env, feature_defn);
    enif_release_resource(feature_defn);
    return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
コード例 #10
0
ファイル: lgeo_ogr.c プロジェクト: namjae/lgeo
/* OGRGeometryH OGR_F_GetGeometryRef(OGRFeatureH hFeat)

{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
{ok, Layer} = lgeo_ogr:ds_get_layer(DataSource, 0),
{ok, Feature} = lgeo_ogr:l_get_feature(Layer, 0),
{ok, Geometry} = lgeo_ogr:f_get_geometry_ref(Feature).

*/
static ERL_NIF_TERM
f_get_geometry_ref(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    EnvFeature_t **feature;
    ERL_NIF_TERM eterm;

    if (argc != 1) {
        return enif_make_badarg(env);
    }

    if(!enif_get_resource(env, argv[0], OGR_F_RESOURCE, (void**)&feature)) {
        return enif_make_badarg(env);
    }

    OGRGeometryH geom = OGR_F_GetGeometryRef((**feature).obj);
    if(geom == NULL) {
        return enif_make_atom(env, "undefined");
    }

    EnvGeometry_t **geometry = \
        enif_alloc_resource(OGR_G_RESOURCE, sizeof(EnvGeometry_t*));

    ErlNifEnv *geometry_env = enif_alloc_env();

    *geometry = (EnvGeometry_t*) enif_alloc(sizeof(EnvGeometry_t));
    (**geometry).env = geometry_env;
    (**geometry).obj = geom;

    // Save copy of feature so is not garbage collected
    enif_make_copy(geometry_env, argv[0]);

    eterm = enif_make_resource(env, geometry);
    enif_release_resource(geometry);
    return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
コード例 #11
0
ファイル: ewpcap.c プロジェクト: hfeeki/ewpcap
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);
}
コード例 #12
0
ファイル: i18n_string.cpp プロジェクト: alepharchives/i18n
ERL_NIF_TERM iterator_locales(ErlNifEnv* env, int argc, const
    ERL_NIF_TERM /*argv*/[])
{
    if (argc != 0)
        return enif_make_badarg(env);

    return enif_make_copy(env, available_locales);
}
コード例 #13
0
ファイル: nif_SUITE.c プロジェクト: cristiangreco/otp
static ERL_NIF_TERM copy_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    union { void* vp; struct make_term_info* p; }mti;
    if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)) {
	return enif_make_badarg(env);
    }
    return enif_make_copy(env, mti.p->blob);
}
コード例 #14
0
ファイル: i18n_date.cpp プロジェクト: alepharchives/i18n
ERL_NIF_TERM timezone_ids(ErlNifEnv* env, int argc, 
    const ERL_NIF_TERM /*argv*/[])
{
    if (argc != 0)
        return enif_make_badarg(env);

    return enif_make_copy(env, available_timezones);
}
コード例 #15
0
ファイル: brine_nif.c プロジェクト: monkeygroover/brine
static ERL_NIF_TERM make_keypair_record(ErlNifEnv *env, brine_keypair_s *keypair) {
  return enif_make_tuple4(env, enif_make_copy(env, BRINE_ATOM_KEYPAIR),
                          enif_make_resource(env, (void *) keypair),
                          // private key
                          enif_make_resource_binary(env, (void *) keypair, (void *) keypair->private_key, BRINE_PRIVKEY_SZ),
                          // public key
                          enif_make_resource_binary(env, (void *) keypair, (void *) keypair->public_key, BRINE_PUBKEY_SZ));
}
コード例 #16
0
ファイル: elua.c プロジェクト: indie21/elua
static ERL_NIF_TERM
elua_gencall_async(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    elua_t *res;
    msg_t *msg;
    ErlNifPid pid;

    if(argc != 6) {
        return enif_make_badarg(env);
    }

    // first arg: ref
    if(!enif_get_resource(env, argv[0], RES_SYNC, (void**) &res)) {
        return enif_make_badarg(env);
    }

    // ref
    if(!enif_is_ref(env, argv[1])) {
        return make_error_tuple(env, "invalid_ref");
    }

    // dest pid
    if(!enif_get_local_pid(env, argv[2], &pid)) {
        return make_error_tuple(env, "invalid_pid");
    }

    // fourth arg: list of input args
    if(!enif_is_list(env, argv[5])) {
        return enif_make_badarg(env);
    }

    msg = msg_create();
    if(!msg) {
        return make_error_tuple(env, "command_create_failed");
    }

    msg->type = msg_gencall;
    msg->ref = enif_make_copy(msg->env, argv[1]);
    msg->pid = pid;
    msg->arg1 = enif_make_copy(msg->env, argv[3]);
    msg->arg2 = enif_make_copy(msg->env, argv[4]);
    msg->arg3 = enif_make_copy(msg->env, argv[5]);
    msg->res = res;

    return push_command(env, res, msg);
}
コード例 #17
0
ファイル: vm.c プロジェクト: alepharchives/emonk
int
vm_add_call(vm_ptr vm, ENTERM ref, ENPID pid, ENTERM name, ENTERM args)
{
    job_ptr job = job_create();
    if(job == NULL) goto error;

    job->type = job_call;
    job->ref = enif_make_copy(job->env, ref);
    job->pid = pid;
    job->name = enif_make_copy(job->env, name);
    job->args = enif_make_copy(job->env, args);

    if(!queue_push(vm->jobs, job)) goto error;

    return 1;
error:
    if(job != NULL) job_destroy(job);
    return 0;
}
コード例 #18
0
ファイル: robin_q.cpp プロジェクト: AnakinSong/robin_q
    void do_set(robin_q_handle *handle, ERL_NIF_TERM value) {
        const ERL_NIF_TERM *elements_tuple;
        int elements_size;
        ERL_NIF_TERM elements_term = enif_make_copy(handle->env, value);
        enif_get_tuple(handle->env, elements_term, &elements_size, &elements_tuple);

        handle->size        = elements_size;
        handle->elements    = elements_tuple;
        handle->index       = 0;
    }
コード例 #19
0
ファイル: c_soc.c プロジェクト: et4te/paraphrase
// c_soc:op_alloc(ParentKey, Tuple, Arity) => ok
static ERL_NIF_TERM op_alloc(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
  soc::State* st = (soc::State*) enif_priv_data(env);

  int                 parentKey;
  int                 parentKeyInt;
  ERL_NIF_TERM*       tuple;
  ERL_NIF_TERM*       tupleInt;
  int                 tupleArity;
  int                 tupleArityInt;
  int                 arity;
  int                 arityInt;

  if (enif_get_int(env, argv[0], &parentKey) == 0) {
    printf("[op_alloc] error: failed to get parentKey\n");
    return -1;
  }

  parentKeyInt = enif_make_copy(st->GetEnv(), parentKey);
  
  if (enif_get_tuple(env, argv[1], &tupleArity, &tuple) == 0) {
    printf("[op_alloc] error: failed to get tuple\n");
    return -1;
  }

  (*tupleInt) = enif_make_copy(st->GetEnv(), (*tuple));
  tupleArityInt = enif_make_copy(st->GetEnv(), tupleArity);

  if (enif_get_int(env, argv[2], &arity) == 0) {
    printf("[op_alloc] error: failed to initialize arity\n");
    return -1;
  } 

  arityInt = enif_make_copy(st->GetEnv(), arity);

  printf("operation start\n");
  soc::Operation* op = new soc::Operation(parentKeyInt, tupleInt, tupleArityInt, arityInt);
  int currentIndex = st->Insert(op);
  int currentIndexExt = enif_make_copy(env, currentIndex);
  printf("operation index: %d end\n", currentIndexExt);

  return enif_make_int(env, currentIndexExt);
}
コード例 #20
0
ファイル: esqlite3_nif.c プロジェクト: mmzeeman/esqlite
/*
 * Multi step to a prepared statement
 */
static ERL_NIF_TERM
esqlite_multi_step(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    esqlite_connection *conn;
    esqlite_statement *stmt;
    esqlite_command *cmd = NULL;
    ErlNifPid pid;
    int chunk_size = 0;

    if(argc != 5)
        return enif_make_badarg(env);

    if(!enif_get_resource(env, argv[0], esqlite_connection_type, (void **) &conn))
        return enif_make_badarg(env);

    if(!enif_get_resource(env, argv[1], esqlite_statement_type, (void **) &stmt))
        return enif_make_badarg(env);

    if(!enif_get_int(env, argv[2], &chunk_size))
        return make_error_tuple(env, "invalid_chunk_size");

    if(!enif_is_ref(env, argv[3]))
        return make_error_tuple(env, "invalid_ref");

    if(!enif_get_local_pid(env, argv[4], &pid))
        return make_error_tuple(env, "invalid_pid");

    if(!stmt->statement)
        return make_error_tuple(env, "no_prepared_statement");

    cmd = command_create();
    if(!cmd)
        return make_error_tuple(env, "command_create_failed");

    cmd->type = cmd_multi_step;
    cmd->ref = enif_make_copy(cmd->env, argv[3]);
    cmd->pid = pid;
    cmd->stmt = enif_make_copy(cmd->env, argv[1]);
    cmd->arg = enif_make_copy(cmd->env, argv[2]);

    return push_command(env, conn, cmd);
}
コード例 #21
0
ファイル: erlcl_drv.c プロジェクト: chromaticbum/erlcl
static ErlCall *CreateCall(ERL_NIF_TERM fun, ERL_NIF_TERM args) {
  enif_mutex_lock(callsMutex);

  ErlCall *erlCall = (ErlCall *)malloc(sizeof(ErlCall));
  erlCall->id = id++;
  erlCall->env = enif_alloc_env();
  ERL_NIF_TERM msgFun = enif_make_copy(erlCall->env, fun);
  ERL_NIF_TERM msgArgs = enif_make_copy(erlCall->env, args);
  ERL_NIF_TERM msgId = enif_make_int(erlCall->env, erlCall->id);
  erlCall->msg = enif_make_tuple3(erlCall->env, msgId, msgFun, msgArgs);
  erlCall->cond = enif_cond_create("erlcl_cond");
  erlCall->mutex = enif_mutex_create("erlcl_mutex");
  erlCall->complete = 0;

  HASH_ADD_INT(calls, id, erlCall);

  enif_mutex_unlock(callsMutex);

  return erlCall;
}
コード例 #22
0
ファイル: dirty_nif_SUITE.c プロジェクト: HansN/otp
static ERL_NIF_TERM dirty_heap_access_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    ERL_NIF_TERM res = enif_make_list(env, 0);
    int i;
    assert(ERL_NIF_THR_DIRTY_CPU_SCHEDULER == enif_thread_type()
	   || ERL_NIF_THR_DIRTY_IO_SCHEDULER == enif_thread_type());
    for (i = 0; i < 1000; i++)
	res = enif_make_list_cell(env, enif_make_copy(env, argv[0]), res);

    return res;
}
コード例 #23
0
ファイル: nif_SUITE.c プロジェクト: cristiangreco/otp
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);
}
コード例 #24
0
ファイル: ecsv_parser.c プロジェクト: aadimurthy/ecsv
static ErlNifEnv *
copy_current_line(ErlNifEnv *env, ecsv_parser_t *parser)
{
    ErlNifEnv *old = parser->env;
    line_t *line = &parser->current_line;

    parser->env = env;
    for (size_t i=0; i < line->pos; i++) {
        line->fields[i] = enif_make_copy(env, line->fields[i]);
    }

    return old;
}
コード例 #25
0
ファイル: nif_SUITE.c プロジェクト: cristiangreco/otp
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);
}
コード例 #26
0
ファイル: salt_nif.c プロジェクト: AnsonSmith/salt
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));
}
コード例 #27
0
ファイル: erlcl_drv.c プロジェクト: chromaticbum/erlcl
static ERL_NIF_TERM ErlangCall(ErlNifEnv *env, ERL_NIF_TERM fun, ERL_NIF_TERM args) {
  ErlCall *erlCall = CreateCall(fun, args);

  enif_mutex_lock(erlCall->mutex);
  enif_send(env, &server, erlCall->env, erlCall->msg);
  while(!erlCall->complete) {
    enif_cond_wait(erlCall->cond, erlCall->mutex);
  }
  enif_mutex_unlock(erlCall->mutex);

  ERL_NIF_TERM result = enif_make_copy(env, erlCall->result);
  DestroyCall(erlCall);

  return result;
}
コード例 #28
0
ファイル: vm.c プロジェクト: alepharchives/emonk
int
vm_send(vm_ptr vm, ENTERM data)
{
    job_ptr job = job_create();
    if(job == NULL) goto error;
    
    job->type = job_response;
    job->args = enif_make_copy(job->env, data);
    
    if(!queue_send(vm->jobs, job)) goto error;
    
    return 1;
error:
    if(job != NULL) job_destroy(job);
    return 0;
}
コード例 #29
0
ファイル: elibart.c プロジェクト: Leapsight/elibart
static ERL_NIF_TERM elibart_prefix_search(ErlNifEnv* env, int argc,
                                          const ERL_NIF_TERM argv[])
{
    art_tree* t;
    ErlNifBinary key;
    callback_data cb_data;

    // extract arguments atr_tree, key
    if (argc != 4)
        return enif_make_badarg(env);
    if(!enif_get_resource(env, argv[0], elibart_RESOURCE, (void**) &t))
        return enif_make_badarg(env);
    if (!enif_inspect_binary(env, argv[1], &key))
        return enif_make_badarg(env);

    cb_data.env = env;
    if(!enif_is_pid(env, argv[3]))
        return mk_error(env, "not_a_pid");

    if(!enif_get_local_pid(env, argv[3], &cb_data.pid))
        return mk_error(env, "not_a_local_pid");

    cb_data.caller_ref = argv[2];
   
    // TODO this should be a worker thread since it's a long opearation (?)
    if (art_iter_prefix(t, key.data, key.size, prefix_cb, &cb_data))
        return mk_error(env, "art_prefix_search");

    ErlNifEnv *msg_env = enif_alloc_env();

    if(msg_env == NULL)
        return mk_error(env, "env_alloc_error");;

    ERL_NIF_TERM caller_ref = enif_make_copy(msg_env, argv[2]);
    ERL_NIF_TERM res = enif_make_tuple2(msg_env, caller_ref, mk_atom(msg_env, "ok"));

    if (!enif_send(env, &cb_data.pid, msg_env, res))
    {
        enif_free(msg_env);

        return mk_error(env, "art_prefix_search");
    }

    enif_free(msg_env);

    return mk_atom(env, "ok");
}
コード例 #30
0
ファイル: brine_nif.c プロジェクト: monkeygroover/brine
static void keypair_to_binary(brine_task_s *task) {
  ErlNifEnv *env = task->env;
  brine_keypair_s *keypair = task->options.signature.keys;
  ErlNifBinary blob;
  ERL_NIF_TERM result;

  if (!enif_alloc_binary(BRINE_BLOB_SZ, &blob)) {
    result = BRINE_ERROR_NO_MEMORY;
  }
  else {
    brine_serialize_keypair(keypair, blob.data, blob.size);
    result = enif_make_tuple2(env, enif_make_copy(env, BRINE_ATOM_OK), enif_make_binary(env, &blob));
    enif_release_binary(&blob);
  }
  enif_release_resource((void *) keypair);
  enif_send(NULL, &task->owner, task->env, enif_make_tuple2(env, task->ref, result));
}