/*
* 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);
}
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
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);
}
/*
* 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);
}
/*
* 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);
}
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
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);
}
/*
* argv[0] an atom
* argv[1] a binary
* argv[2] a ref
* argv[3] 'ok'
* argv[4] a fun
* argv[5] a pid
* argv[6] a port
* argv[7] an empty list
* argv[8] a non-empty list
* argv[9] a tuple
*/
static ERL_NIF_TERM check_is(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ERL_NIF_TERM ok_atom = enif_make_atom(env, "ok");
if (!enif_is_atom(env, argv[0])) return enif_make_badarg(env);
if (!enif_is_binary(env, argv[1])) return enif_make_badarg(env);
if (!enif_is_ref(env, argv[2])) return enif_make_badarg(env);
if (!enif_is_identical(argv[3], ok_atom)) return enif_make_badarg(env);
if (!enif_is_fun(env, argv[4])) return enif_make_badarg(env);
if (!enif_is_pid(env, argv[5])) return enif_make_badarg(env);
if (!enif_is_port(env, argv[6])) return enif_make_badarg(env);
if (!enif_is_empty_list(env, argv[7])) return enif_make_badarg(env);
if (!enif_is_list(env, argv[7])) return enif_make_badarg(env);
if (!enif_is_list(env, argv[8])) return enif_make_badarg(env);
if (!enif_is_tuple(env, argv[9])) return enif_make_badarg(env);
return ok_atom;
}
/*
* 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 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 void push_nif_term(lua_State* lua, ERL_NIF_TERM message, ErlNifEnv* env, ErlNifResourceType* resource_type)
{
const int top = lua_gettop(lua);
if(enif_is_atom(env, message))
{
push_nif_atom(lua, message, env);
}
else if(enif_is_binary(env, message))
{
// TODO @@@ binary also seems to be the custom types
// that erlang makes. This may be OK, but maybe we should
// think about putting a special type for them in lua
push_nif_binary(lua, message, env);
}
else if(enif_is_list(env, message))
{
if(enif_is_empty_list(env, message))
{
luaL_checkstack(lua, 1, ERROR_STACK_MESSAGE);
lua_newtable(lua);
}
else
{
// TODO @@@ try to send it as an IO list first and
// if that fails send it as a regular list
push_nif_list(lua, message, env, resource_type);
}
}
else if(enif_is_tuple(env, message))
{
push_nif_tuple(lua, message, env, resource_type);
}
else if(enif_is_pid(env, message))
{
push_nif_pid(lua, message, env);
}
else if(enif_is_ref(env, message))
{
push_nif_ref(lua, message, env);
}
else if(enif_is_exception(env, message))
{
//printf("#exception\n");
luaL_checkstack(lua, 1, ERROR_STACK_MESSAGE);
lua_pushliteral(lua, "sending an exception is not supported");
}
else if(enif_is_fun(env, message))
{
//printf("#fun\n");
luaL_checkstack(lua, 1, ERROR_STACK_MESSAGE);
lua_pushliteral(lua, "sending a function reference is not supported");
}
else if(enif_is_port(env, message))
{
//printf("#port\n");
luaL_checkstack(lua, 1, ERROR_STACK_MESSAGE);
lua_pushliteral(lua, "sending a port is not supported");
}
else
{
// thank you r14 -- must be a number
push_nif_number(lua, message, env);
}
assert(lua_gettop(lua) == top+1);
}
static ERL_NIF_TERM type_test(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
int i;
int sint;
unsigned uint;
long slong;
unsigned long ulong;
ErlNifSInt64 sint64;
ErlNifUInt64 uint64;
double d;
ERL_NIF_TERM atom, ref1, ref2;
sint = INT_MIN;
do {
if (!test_int(env,sint)) {
goto error;
}
sint += ~sint / 3 + 1;
} while (sint < 0);
sint = INT_MAX;
do {
if (!test_int(env,sint)) {
goto error;
}
sint -= sint / 3 + 1;
} while (sint >= 0);
slong = LONG_MIN;
do {
if (!test_long(env,slong)) {
goto error;
}
slong += ~slong / 3 + 1;
} while (slong < 0);
slong = LONG_MAX;
do {
if (!test_long(env,slong)) {
goto error;
}
slong -= slong / 3 + 1;
} while (slong >= 0);
sint64 = ((ErlNifSInt64)1 << 63); /* INT64_MIN */
do {
if (!test_int64(env,sint64)) {
goto error;
}
sint64 += ~sint64 / 3 + 1;
} while (sint64 < 0);
sint64 = ((ErlNifUInt64)1 << 63) - 1; /* INT64_MAX */
do {
if (!test_int64(env,sint64)) {
goto error;
}
sint64 -= sint64 / 3 + 1;
} while (sint64 >= 0);
uint = UINT_MAX;
for (;;) {
if (!test_uint(env,uint)) {
goto error;
}
if (uint == 0) break;
uint -= uint / 3 + 1;
}
ulong = ULONG_MAX;
for (;;) {
if (!test_ulong(env,ulong)) {
goto error;
}
if (ulong == 0) break;
ulong -= ulong / 3 + 1;
}
uint64 = (ErlNifUInt64)-1; /* UINT64_MAX */
for (;;) {
if (!test_uint64(env,uint64)) {
goto error;
}
if (uint64 == 0) break;
uint64 -= uint64 / 3 + 1;
}
if (MAX_SMALL < INT_MAX) { /* 32-bit */
for (i=-10 ; i <= 10; i++) {
if (!test_int(env,MAX_SMALL+i)) {
goto error;
}
}
for (i=-10 ; i <= 10; i++) {
if (!test_int(env,MIN_SMALL+i)) {
goto error;
}
}
for (i=-10 ; i <= 10; i++) {
if (!test_uint(env,MAX_SMALL+i)) {
goto error;
}
}
}
assert((MAX_SMALL < INT_MAX) == (MIN_SMALL > INT_MIN));
for (i=-10 ; i < 10; i++) {
if (!test_long(env,MAX_SMALL+i) || !test_ulong(env,MAX_SMALL+i) ||
!test_long(env,MIN_SMALL+i) ||
!test_int64(env,MAX_SMALL+i) || !test_uint64(env,MAX_SMALL+i) ||
!test_int64(env,MIN_SMALL+i)) {
goto error;
}
if (MAX_SMALL < INT_MAX) {
if (!test_int(env,MAX_SMALL+i) || !test_uint(env,MAX_SMALL+i) ||
!test_int(env,MIN_SMALL+i)) {
goto error;
}
}
}
for (d=3.141592e-100 ; d < 1e100 ; d *= 9.97) {
if (!test_double(env,d) || !test_double(env,-d)) {
goto error;
}
}
if (!enif_make_existing_atom(env,"nif_SUITE", &atom, ERL_NIF_LATIN1)
|| !enif_is_identical(atom,enif_make_atom(env,"nif_SUITE"))) {
fprintf(stderr, "nif_SUITE not an atom?\r\n");
goto error;
}
for (i=2; i; i--) {
if (enif_make_existing_atom(env,"nif_SUITE_pink_unicorn", &atom, ERL_NIF_LATIN1)) {
fprintf(stderr, "pink unicorn exist?\r\n");
goto error;
}
}
ref1 = enif_make_ref(env);
ref2 = enif_make_ref(env);
if (!enif_is_ref(env,ref1) || !enif_is_ref(env,ref2)
|| enif_is_identical(ref1,ref2) || enif_compare(ref1,ref2)==0) {
fprintf(stderr, "strange refs?\r\n");
goto error;
}
return enif_make_atom(env,"ok");
error:
return enif_make_atom(env,"error");
}
