static ERL_NIF_TERM dirty_sleeper(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifPid pid; ErlNifEnv* msg_env = NULL; assert(ERL_NIF_THR_DIRTY_CPU_SCHEDULER == enif_thread_type() || ERL_NIF_THR_DIRTY_IO_SCHEDULER == enif_thread_type()); /* If we get a pid argument, it indicates a process involved in the test wants a message from us. Prior to the sleep we send a 'ready' message, and then after the sleep, send a 'done' message. */ if (argc == 1 && enif_get_local_pid(env, argv[0], &pid)) enif_send(env, &pid, NULL, enif_make_atom(env, "ready")); #ifdef __WIN32__ Sleep(2000); #else sleep(2); #endif if (argc == 1) enif_send(env, &pid, NULL, enif_make_atom(env, "done")); return enif_make_atom(env, "ok"); }
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 nif_term_t salt_random_bytes(nif_heap_t *hp, int argc, const nif_term_t argv[]) { /* salt_random_bytes(Pcb, From_pid, From_ref, Cnt) -> enqueued | congested | exiting. */ struct salt_pcb *sc; nif_pid_t pid; nif_term_t ref; uint_t cnt; if (argc != 4) return (BADARG); /* Unpack arguments, check types. */ if (! enif_get_resource(hp, argv[0], salt_pcb_type, (void **)&sc)) return (BADARG); if (! enif_get_local_pid(hp, argv[1], &pid)) return (BADARG); if (! enif_is_ref(hp, argv[2])) return (BADARG); ref = argv[2]; /* Get requested size, make sure it's in bounds. */ if (! enif_get_uint(hp, argv[3], &cnt)) return (BADARG); if (cnt < 1 || cnt > SALT_MAX_MESSAGE_SIZE) return (BADARG); return (salt_enqueue_req(hp, sc, pid, ref, SALT_MSG_RANDOMBYTES_REQ, cnt)); }
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 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); }
static ERL_NIF_TERM _listener (ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { CAN_handle* handle; ErlNifPid pid = { 0 }; // NOTE: breaking opaque type! enif_get_resource(env, argv[0], CAN_handle_type, (void**) &handle); if (handle->threaded) // there is a thread already and some pid! { pid = handle->receiver; } if (!enif_get_local_pid(env, argv[1], &handle->receiver)) // NOTE: use lock if pid type is structural! { handle->threaded = 0; return enif_make_badarg(env); } else { enif_get_uint(env, argv[2], &handle->chunk_size); enif_get_long(env, argv[3], &handle->timeout); if (!handle->threaded) // a thread was not created already { if (enif_thread_create("can_reading_thread", &handle->tid, _reading_thread, handle, 0)) { handle->threaded = 0; return enif_make_int(env, -1004); } } } return pid.pid ? enif_make_pid(env, &pid) : enif_make_int(env, 0); }
/* * 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); }
/* * Step to a prepared statement */ static ERL_NIF_TERM esqlite_column_names(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite_statement *stmt; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 3) 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"); 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_column_names; cmd->ref = enif_make_copy(cmd->env, argv[1]); cmd->pid = pid; cmd->stmt = stmt->statement; 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); }
/* * 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); }
static ERL_NIF_TERM SetPid(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { TRACE("SetPid\n"); if(enif_get_local_pid(env, argv[0], &server)) { return enif_make_atom(env, "ok"); } else { return enif_make_badarg(env); } }
static int load(ErlNifEnv *env, void** priv_data, ERL_NIF_TERM prim_file_pid) { ErlNifResourceTypeInit callbacks; if(!enif_get_local_pid(env, prim_file_pid, &erts_prim_file_pid)) { ASSERT(!"bad pid passed to prim_file_nif"); } am_close = enif_make_atom(env, "close"); am_ok = enif_make_atom(env, "ok"); am_error = enif_make_atom(env, "error"); am_continue = enif_make_atom(env, "continue"); am_read = enif_make_atom(env, "read"); am_write = enif_make_atom(env, "write"); am_exclusive = enif_make_atom(env, "exclusive"); am_append = enif_make_atom(env, "append"); am_sync = enif_make_atom(env, "sync"); am_skip_type_check = enif_make_atom(env, "skip_type_check"); am_read_write = enif_make_atom(env, "read_write"); am_none = enif_make_atom(env, "none"); am_normal = enif_make_atom(env, "normal"); am_random = enif_make_atom(env, "random"); am_sequential = enif_make_atom(env, "sequential"); am_will_need = enif_make_atom(env, "will_need"); am_dont_need = enif_make_atom(env, "dont_need"); am_no_reuse = enif_make_atom(env, "no_reuse"); am_device = enif_make_atom(env, "device"); am_directory = enif_make_atom(env, "directory"); am_regular = enif_make_atom(env, "regular"); am_symlink = enif_make_atom(env, "symlink"); am_other = enif_make_atom(env, "other"); am_file_info = enif_make_atom(env, "file_info"); am_bof = enif_make_atom(env, "bof"); am_cur = enif_make_atom(env, "cur"); am_eof = enif_make_atom(env, "eof"); callbacks.down = owner_death_callback; callbacks.dtor = NULL; callbacks.stop = NULL; efile_resource_type = enif_open_resource_type_x(env, "efile", &callbacks, ERL_NIF_RT_CREATE, NULL); *priv_data = NULL; return 0; }
static ERL_NIF_TERM do_set_update_hook(ErlNifEnv *env, esqlite_connection *db, const ERL_NIF_TERM arg) { if(!enif_get_local_pid(env, arg, &db->notification_pid)) return make_error_tuple(env, "invalid_pid"); sqlite3_update_hook(db->db, NULL, NULL); if(sqlite3_update_hook(db->db, update_callback, db) != SQLITE_OK) return make_error_tuple(env, "sqlite3_update_hook_fail"); return make_atom(env, "ok"); }
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 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 send_to_pid(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { state_t* state = (state_t*) enif_priv_data(env); ErlNifPid* pid = (ErlNifPid*) enif_alloc(sizeof(ErlNifPid)); if(!enif_get_local_pid(env, argv[0], pid)) { return enif_make_badarg(env); } queue_push(state->queue, pid); return state->atom_ok; }
static void push_nif_pid(lua_State* lua, ERL_NIF_TERM message, ErlNifEnv* env) { const int top = lua_gettop(lua); luaL_checkstack(lua, 2, ERROR_STACK_MESSAGE); ErlNifPid *pid = (ErlNifPid *)lua_newuserdata(lua, sizeof(ErlNifPid)); if(enif_get_local_pid(env, message, pid)) { luaL_getmetatable(lua, TYPE_ERL_PID); lua_setmetatable(lua, -2); } assert(lua_gettop(lua) == top+1); }
static ERL_NIF_TERM send_from_dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM result; ErlNifPid pid; int res; if (!enif_get_local_pid(env, argv[0], &pid)) return enif_make_badarg(env); result = enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_pid(env, &pid)); res = enif_send(env, &pid, NULL, result); if (!res) return enif_make_badarg(env); else return result; }
ERL_NIF_TERM snappy_decompress_impl(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ctx_t *ctx; task_t *task; ErlNifPid pid; if (argc != 4) { return enif_make_badarg(env); } if (!enif_get_resource(env, argv[0], res_type, reinterpret_cast<void**>(&ctx))) { return enif_make_badarg(env); } if (!enif_is_ref(env, argv[1])) { return enif_make_tuple2(env, atom_error, enif_make_string(env, "Second arg. is not a reference", ERL_NIF_LATIN1)); } if (!enif_get_local_pid(env, argv[2], &pid)) { return enif_make_tuple2(env, atom_error, enif_make_string(env, "Third arg. is not a pid of local process", ERL_NIF_LATIN1)); } if (!enif_is_binary(env, argv[3])) { return enif_make_tuple2(env, atom_error, enif_make_string(env, "Forth arg. is not a binary", ERL_NIF_LATIN1)); } task = init_task(DECOMPRESS, argv[1], pid, argv[3]); if (!task) { return enif_make_tuple2(env, atom_error, enif_make_string(env, "Failed to create a task", ERL_NIF_LATIN1)); } async_queue_push(ctx->queue, static_cast<void*>(task)); return atom_ok; }
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"); }
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); }
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); }
static ERL_NIF_TERM cqueue_deposit(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { cqueue_handle* handle = NULL; int list_id = get_list_id(enif_thread_self()); ErlNifPid pid; if (list_id == -1) return enif_make_badarg(env); if (enif_get_resource(env, argv[0], cqueue_RESOURCE, (void**)&handle) == 0) { return enif_make_badarg(env); } if (enif_get_local_pid(env, argv[1], &pid) == 0) { return enif_make_badarg(env); } handle->queue->Deposit(pid, list_id); return enif_make_atom(env, "ok"); }
/* * 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); }
static ERL_NIF_TERM trace(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int state_arity; ErlNifPid self, to; ERL_NIF_TERM *tuple, msg; const ERL_NIF_TERM *state_tuple; ASSERT(argc == 5); enif_get_tuple(env, argv[1], &state_arity, &state_tuple); tuple = enif_alloc(sizeof(ERL_NIF_TERM)*(argc)); memcpy(tuple,argv,sizeof(ERL_NIF_TERM)*argc); msg = enif_make_tuple_from_array(env, tuple, argc); enif_get_local_pid(env, state_tuple[1], &to); enif_send(env, &to, NULL, msg); enif_free(tuple); return atom_ok; }
static ERL_NIF_TERM cpool_join(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { cpool_handle* handle = NULL; cpool_node_handle* node; ErlNifPid pid; ERL_NIF_TERM result; if (enif_get_resource(env, argv[0], cpool_RESOURCE, (void**)&handle) == 0) { return enif_make_badarg(env); } if (enif_get_local_pid(env, argv[1], &pid) == 0) { return enif_make_badarg(env); } node = (cpool_node_handle*)enif_alloc_resource(cpool_node_RESOURCE, sizeof(cpool_node_handle)); node->node = handle->pool->Join(pid); result = enif_make_resource(env, (void*)node); enif_release_resource((void*)node); return result; }
static ERL_NIF_TERM dirty_call_while_terminated_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifPid self; ERL_NIF_TERM result, self_term; ErlNifPid to; ErlNifEnv* menv; int res; if (!enif_get_local_pid(env, argv[0], &to)) return enif_make_badarg(env); if (!enif_self(env, &self)) return enif_make_badarg(env); self_term = enif_make_pid(env, &self); menv = enif_alloc_env(); result = enif_make_tuple2(menv, enif_make_atom(menv, "dirty_alive"), self_term); res = enif_send(env, &to, menv, result); enif_free_env(menv); if (!res) return enif_make_badarg(env); /* Wait until we have been killed */ while (enif_is_process_alive(env, &self)) ; result = enif_make_tuple2(env, enif_make_atom(env, "dirty_dead"), self_term); res = enif_send(env, &to, NULL, result); #ifdef __WIN32__ Sleep(1000); #else sleep(1); #endif return enif_make_atom(env, "ok"); }
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; }
static ERL_NIF_TERM trace(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int state_arity; ErlNifPid self, to; ERL_NIF_TERM *tuple, msg; ASSERT(argc == 5); tuple = enif_alloc(sizeof(ERL_NIF_TERM)*(argc+1)); memcpy(tuple+1,argv,sizeof(ERL_NIF_TERM)*argc); if (enif_self(env, &self)) { tuple[0] = enif_make_pid(env, &self); } else { tuple[0] = enif_make_atom(env, "undefined"); } msg = enif_make_tuple_from_array(env, tuple, argc + 1); enif_get_local_pid(env, argv[1], &to); enif_send(env, &to, NULL, msg); enif_free(tuple); return atom_ok; }
static nif_term_t salt_sign_keypair(nif_heap_t *hp, int argc, const nif_term_t argv[]) { /* salt_sign_keypair(Pcb, From_pid, From_ref) -> enqueued | congested | exiting. */ struct salt_pcb *sc; nif_pid_t pid; nif_term_t ref; if (argc != 3) return (BADARG); /* Unpack arguments, check types. */ if (! enif_get_resource(hp, argv[0], salt_pcb_type, (void **)&sc)) return (BADARG); if (! enif_get_local_pid(hp, argv[1], &pid)) return (BADARG); if (! enif_is_ref(hp, argv[2])) return (BADARG); ref = argv[2]; return (salt_enqueue_req(hp, sc, pid, ref, SALT_MSG_SIGNKEYPAIR_REQ, 0)); }
static ERL_NIF_TERM nif_scheduler_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary frameworkInfo_binary; ErlNifBinary credentials_binary; char masterUrl[MAXBUFLEN]; state_ptr state = (state_ptr) enif_priv_data(env); if(state->initilised == 1) { return enif_make_tuple2(env, enif_make_atom(env, "state_error"), enif_make_atom(env, "scheduler_already_inited")); } ErlNifPid* pid = (ErlNifPid*) enif_alloc(sizeof(ErlNifPid)); if(!enif_get_local_pid(env, argv[0], pid)) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "pid")); } if (!enif_inspect_binary(env, argv[1], &frameworkInfo_binary)) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "framework_info")); } if(!enif_get_string(env, argv[2], masterUrl , 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, "master_info")); } if(argc == 4 ) { if(!enif_inspect_binary(env,argv[3], &credentials_binary)) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "credential")); } state->scheduler_state = scheduler_init(pid, &frameworkInfo_binary, masterUrl, 1, &credentials_binary); } else { state->scheduler_state = scheduler_init(pid, &frameworkInfo_binary, masterUrl, 0, &credentials_binary); } state->initilised = 1; return enif_make_atom(env, "ok"); }