ERL_NIF_TERM
vert_virNodeNumOfDevices(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
VERT_RESOURCE *vp = NULL;
ErlNifBinary cap = {0};
u_int32_t flags = 0;
int n = 0;
VERT_GET_RESOURCE(0, vp, VERT_RES_CONNECT);
VERT_GET_IOLIST(1, cap);
VERT_GET_UINT(2, flags);
if (cap.size > 0)
VERT_BIN_APPEND_NULL(cap);
n = virNodeNumOfDevices(vp->res,
(cap.size == 0 ? NULL : (char *)cap.data),
flags);
VERTERR(n < 0);
return enif_make_tuple2(env,
atom_ok,
enif_make_int(env, n));
}
ERL_NIF_TERM x_pool_lookup(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
uint64_t id;
char pool_name[MAX_NAME_LEN];
if (!enif_get_uint64(env, argv[0], &id) ||
!enif_get_string(env, argv[1], pool_name, MAX_NAME_LEN, ERL_NIF_LATIN1))
{
return enif_make_badarg(env);
}
rados_t cluster = map_cluster_get(id);
if (cluster == NULL)
{
return enif_make_badarg(env);
}
int64_t err = rados_pool_lookup(cluster, pool_name);
if (err < 0)
{
return make_error_tuple(env, -err);
}
return enif_make_tuple2(env,
enif_make_atom(env, "ok"),
enif_make_int64(env, err)); // Pool ID
}
ERL_NIF_TERM
geef_index_write_tree(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
geef_index *index;
geef_repository *repo;
ErlNifBinary bin;
git_oid id;
int error;
if (!enif_get_resource(env, argv[0], geef_index_type, (void **) &index))
return enif_make_badarg(env);
if (argc == 2) {
if (!enif_get_resource(env, argv[1], geef_repository_type, (void **) &repo))
return enif_make_badarg(env);
error = git_index_write_tree_to(&id, index->index, repo->repo);
} else {
error = git_index_write_tree(&id, index->index);
}
if (error < 0)
return geef_error(env);
if (geef_oid_bin(&bin, &id) < 0)
return geef_oom(env);
return enif_make_tuple2(env, atoms.ok, enif_make_binary(env, &bin));
}
// int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
static ERL_NIF_TERM
nif_getsockname(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int s = -1;
ErlNifBinary addr = {0};
socklen_t addrlen = 0;
if (!enif_get_int(env, argv[0], &s))
return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[1], &addr))
return enif_make_badarg(env);
/* Make the binary mutable */
if (!enif_realloc_binary(&addr, addr.size))
return error_tuple(env, ENOMEM);
addrlen = addr.size;
if (getsockname(s, (struct sockaddr *)addr.data, (socklen_t *)&addrlen) < 0)
return error_tuple(env, errno);
PROCKET_REALLOC(addr, addrlen);
return enif_make_tuple2(env,
atom_ok,
enif_make_binary(env, &addr));
}
static ERL_NIF_TERM
ex_slp_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
char *lang;
char *ret_code;
int isasync;
unsigned int term_len;
SLPHandle *hslp;
SLPEXP SLPError SLPAPI error;
if (enif_get_atom_length(env, argv[0], &term_len, ERL_NIF_LATIN1) < 0) {
return enif_make_badarg(env);
}
if (enif_get_atom(env, argv[0], lang, term_len, ERL_NIF_LATIN1) < 0) {
return enif_make_badarg(env);
}
if ( ! enif_get_int(env, argv[1], &isasync)) return enif_make_badarg(env);
hslp = enif_alloc_resource(NIF_SLP_HANDLE, sizeof(SLPHandle));
if (hslp == NULL) return enif_make_badarg(env);
//error = SLPOpen(lang, isasync > 0 ? SLP_TRUE : SLP_FALSE, hslp);
error = SLPOpen(lang, isasync > 0 ? SLP_TRUE : SLP_FALSE, hslp);
ERL_NIF_TERM term = enif_make_resource(env, hslp);
enif_release_resource(hslp);
return enif_make_tuple2(env, enif_make_int(env, error), term);
}
ERL_NIF_TERM ucrypto_ec_sign_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
unsigned int length;
struct ec_key_handle *handle = NULL;
ErlNifBinary data;
ErlNifBinary signature;
if (! enif_get_resource(env, argv[0], ec_key_resource, (void **)&handle))
return enif_make_badarg(env);
if (! enif_inspect_iolist_as_binary(env, argv[1], &data))
return enif_make_badarg(env);
if (! handle->key)
return enif_make_tuple2(env, ATOM_ERROR, ATOM_UNINITIALIZED_KEY);
length = ECDSA_size(handle->key);
if (! enif_alloc_binary(length, &signature))
return ATOM_ERROR;
if (! ECDSA_sign(0, data.data, data.size, signature.data, &length, handle->key))
return ATOM_ERROR;
if (! enif_realloc_binary(&signature, length))
return ATOM_ERROR;
return enif_make_binary(env, &signature);
}
/* 0: procotol, 1: type, 2: family */
static ERL_NIF_TERM
nif_socket(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int s = -1;
int family = 0;
int type = 0;
int protocol = 0;
int flags = 0;
if (!enif_get_int(env, argv[0], &family))
return enif_make_badarg(env);
if (!enif_get_int(env, argv[1], &type))
return enif_make_badarg(env);
if (!enif_get_int(env, argv[2], &protocol))
return enif_make_badarg(env);
s = socket(family, type, protocol);
if (s < 0)
return error_tuple(env, errno);
flags = fcntl(s, F_GETFL, 0);
if (flags < 0)
return error_tuple(env, errno);
if (fcntl(s, F_SETFL, flags|O_NONBLOCK) < 0)
return error_tuple(env, errno);
return enif_make_tuple2(env,
atom_ok,
enif_make_int(env, s));
}
ERL_NIF_TERM
vert_virSecretGetValue(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
VERT_RESOURCE *sp = NULL;
u_int32_t flags = 0;
size_t value_size = 0;
unsigned char *secret = NULL;
ERL_NIF_TERM buf = {0};
VERT_GET_RESOURCE(0, sp, VERT_RES_SECRET);
VERT_GET_UINT(1, flags);
secret = virSecretGetValue(sp->res, &value_size, flags);
VERTERR(secret == NULL);
BINCOPY(buf, secret, value_size);
free(secret);
return enif_make_tuple2(env,
atom_ok,
buf);
}
static ERL_NIF_TERM read_file_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
posix_errno_t posix_errno;
efile_fileinfo_t info = {0};
efile_path_t path;
efile_data_t *d;
ErlNifBinary result;
ASSERT(argc == 1);
if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
return posix_error_to_tuple(env, posix_errno);
} else if((posix_errno = efile_read_info(&path, 1, &info))) {
return posix_error_to_tuple(env, posix_errno);
} else if((posix_errno = efile_open(&path, EFILE_MODE_READ, efile_resource_type, &d))) {
return posix_error_to_tuple(env, posix_errno);
}
posix_errno = read_file(d, info.size, &result);
enif_release_resource(d);
if(posix_errno) {
return posix_error_to_tuple(env, posix_errno);
}
return enif_make_tuple2(env, am_ok, enif_make_binary(env, &result));
}
static ERL_NIF_TERM describe_error(ErlNifEnv* env, int err) {
switch (err) {
case EAGAIN:
return enif_make_atom(env, "eagain");
case EINVAL:
return enif_make_atom(env, "einval");
case ENOSPC:
return enif_make_atom(env, "enospc");
case ENOENT:
return enif_make_atom(env, "enoent");
case ENOMEM:
return enif_make_atom(env, "enomem");
case EACCES:
return enif_make_atom(env, "eacces");
case EBADF:
return enif_make_atom(env, "ebadf");
case ENODEV:
return enif_make_atom(env, "enodev");
case ENXIO:
return enif_make_atom(env, "enxio");
case EOVERFLOW:
return enif_make_atom(env, "eoverflow");
}
return enif_make_tuple2(env,
enif_make_atom(env, "errno"),
enif_make_int(env, err));
}
static ERL_NIF_TERM emmap_position(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
mhandle *handle;
long position;
long relpos;
if (argc==3
&& enif_get_resource(env, argv[0], MMAP_RESOURCE, (void**)&handle)
&& enif_get_long(env, argv[2], &relpos)
&& (argv[1] == ATOM_CUR || argv[1] == ATOM_BOF || argv[1] == ATOM_EOF))
{
RW_LOCK;
if (argv[1] == ATOM_BOF) {
position = 0L + relpos;
} else if (argv[1] == ATOM_CUR) {
position = handle->position + relpos;
} else if (argv[1] == ATOM_EOF) {
position = handle->len - relpos;
}
if (position < 0L || ((unsigned long)position) > handle->len) {
RW_UNLOCK;
return enif_make_badarg(env);
}
handle->position = position;
RW_UNLOCK;
return enif_make_tuple2(env, ATOM_OK, enif_make_ulong(env, position));
}
else
{
return enif_make_badarg(env);
}
}
ERL_NIF_TERM cb_http(ErlNifEnv* env, handle_t* handle, void* obj)
{
http_args_t* args = (http_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret;
lcb_http_request_t req;
lcb_http_cmd_t cmd;
cmd.version = 0;
cmd.v.v0.path = args->path;
cmd.v.v0.npath = strlen(args->path);
cmd.v.v0.body = args->body;
cmd.v.v0.nbody = strlen(args->body);
cmd.v.v0.method = args->method;
cmd.v.v0.chunked = 0; // no support for chunking
cmd.v.v0.content_type = args->content_type;
ret = lcb_make_http_request(handle->instance, &cb, args->type, &cmd, &req);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if(cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
ErlNifBinary value_binary;
enif_alloc_binary(cb.size, &value_binary);
memcpy(value_binary.data, cb.data, cb.size);
return enif_make_tuple2(env, A_OK(env), enif_make_binary(env, &value_binary));
}
ERL_NIF_TERM cb_arithmetic(ErlNifEnv* env, handle_t* handle, void* obj)
{
arithmetic_args_t* args = (arithmetic_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret; //for checking responses
lcb_arithmetic_cmd_t arithmetic;
const lcb_arithmetic_cmd_t* commands[1];
commands[0] = &arithmetic;
memset(&arithmetic, 0, sizeof(arithmetic));
arithmetic.v.v0.key = args->key;
arithmetic.v.v0.nkey = args->nkey;
arithmetic.v.v0.initial = args->initial;
arithmetic.v.v0.create = args->create;
arithmetic.v.v0.delta = args->delta;
ret = lcb_arithmetic(handle->instance, &cb, 1, commands);
free(args->key);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if(cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
return enif_make_tuple2(env, A_OK(env), return_value(env, &cb));
}
ERL_NIF_TERM cb_getl(ErlNifEnv* env, handle_t* handle, void* obj)
{
getl_args_t* args = (getl_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret;
lcb_get_cmd_t cmd;
const lcb_get_cmd_t *commands[1];
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.key = args->key;
cmd.v.v0.nkey = args->nkey;
cmd.v.v0.exptime = args->exp;
cmd.v.v0.lock = 1;
ret = lcb_get(handle->instance, &cb, 1, commands);
free(args->key);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if(cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
return enif_make_tuple2(env, A_OK(env), return_value(env, &cb));
}
ERL_NIF_TERM x_get_instance_id(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
const char * func_name = "x_get_instance_id()";
uint64_t id;
if (!enif_get_uint64(env, argv[0], &id))
{
logger.error(MOD_NAME, func_name, "enif get params failed");
return enif_make_badarg(env);
}
logger.debug(MOD_NAME, func_name, "cluster : %ld", id);
rados_t cluster = map_cluster_get(id);
if (cluster == NULL)
{
logger.error(MOD_NAME, func_name, "cluster non-existing : %ld", id);
return enif_make_badarg(env);
}
uint64_t inst_id = rados_get_instance_id(cluster);
return enif_make_tuple2(env,
enif_make_atom(env, "ok"),
enif_make_uint64(env, inst_id));
}
static ERL_NIF_TERM open_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
posix_errno_t posix_errno;
efile_data_t *d;
ErlNifPid controlling_process;
enum efile_modes_t modes;
ERL_NIF_TERM result;
efile_path_t path;
ASSERT(argc == 2);
if(!enif_is_list(env, argv[1])) {
return enif_make_badarg(env);
}
modes = efile_translate_modelist(env, argv[1]);
if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
return posix_error_to_tuple(env, posix_errno);
} else if((posix_errno = efile_open(&path, modes, efile_resource_type, &d))) {
return posix_error_to_tuple(env, posix_errno);
}
result = enif_make_resource(env, d);
enif_release_resource(d);
enif_self(env, &controlling_process);
if(enif_monitor_process(env, d, &controlling_process, &d->monitor)) {
return posix_error_to_tuple(env, EINVAL);
}
return enif_make_tuple2(env, am_ok, result);
}
ERL_NIF_TERM x_create_with_user(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
const char * func_name = "x_create_with_user()";
logger.debug(MOD_NAME, func_name, "Entered");
char name[MAX_NAME_LEN];
memset(name, 0, MAX_NAME_LEN);
if (!enif_get_string(env, argv[0], name, MAX_NAME_LEN, ERL_NIF_LATIN1))
{
logger.error(MOD_NAME, func_name, "enif get params failed");
return enif_make_badarg(env);
}
rados_t cluster;
int err = rados_create(&cluster, name);
if (err < 0)
{
logger.error(MOD_NAME, func_name, "Unable to create cluster handle with name: %s", name);
return make_error_tuple(env, -err);
}
uint64_t id = new_id();
map_cluster_add(id, cluster);
logger.debug(MOD_NAME, func_name, "cluster : %ld", id);
return enif_make_tuple2(env,
enif_make_atom(env, "ok"),
enif_make_uint64(env, id));
}
static ERL_NIF_TERM seek_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
Sint64 new_position, offset;
enum efile_seek_t seek;
ASSERT(argc == 2);
if(!enif_get_int64(env, argv[1], &offset)) {
return enif_make_badarg(env);
}
if(enif_is_identical(argv[0], am_bof)) {
seek = EFILE_SEEK_BOF;
} else if(enif_is_identical(argv[0], am_cur)) {
seek = EFILE_SEEK_CUR;
} else if(enif_is_identical(argv[0], am_eof)) {
seek = EFILE_SEEK_EOF;
} else {
return enif_make_badarg(env);
}
if(!efile_seek(d, seek, offset, &new_position)) {
return posix_error_to_tuple(env, d->posix_errno);
}
return enif_make_tuple2(env, am_ok, enif_make_uint64(env, new_position));
}
/* 0: socket, 1: buffer, 2: flags, 3: struct sockaddr */
static ERL_NIF_TERM
nif_sendto(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int sockfd = -1;
int flags = 0;
ssize_t n = 0;
ErlNifBinary buf = {0};
ErlNifBinary sa = {0};
if (!enif_get_int(env, argv[0], &sockfd))
return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[1], &buf))
return enif_make_badarg(env);
if (!enif_get_int(env, argv[2], &flags))
return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[3], &sa))
return enif_make_badarg(env);
n = sendto(sockfd, buf.data, buf.size, flags,
(sa.size == 0 ? NULL : (struct sockaddr *)sa.data),
sa.size);
if (n < 0)
return error_tuple(env, errno);
return enif_make_tuple2(env, atom_ok, enif_make_int64(env, n));
}
static ERL_NIF_TERM
create(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
Example* res;
ERL_NIF_TERM ret;
unsigned int id;
Tracker* tracker;
if(argc != 1)
{
return enif_make_badarg(env);
}
if(!enif_get_uint(env, argv[0], &id))
{
return enif_make_badarg(env);
}
res = enif_alloc_resource(RES_TYPE, sizeof(Example));
if(res == NULL) return enif_make_badarg(env);
ret = enif_make_resource(env, res);
enif_release_resource(res);
res->id = id;
tracker = (Tracker*) enif_priv_data(env);
tracker->count += 1;
return enif_make_tuple2(env, atom_ok, ret);
}
/* 0: socket, 1: length */
static ERL_NIF_TERM
nif_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int fd = -1;
unsigned long len = 0;
ErlNifBinary buf = {0};
ssize_t bufsz = 0;
if (!enif_get_int(env, argv[0], &fd))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &len))
return enif_make_badarg(env);
if (!enif_alloc_binary(len, &buf))
return error_tuple(env, ENOMEM);
if ( (bufsz = read(fd, buf.data, buf.size)) == -1) {
int err = errno;
enif_release_binary(&buf);
return error_tuple(env, err);
}
PROCKET_REALLOC(buf, bufsz);
return enif_make_tuple2(env, atom_ok, enif_make_binary(env, &buf));
}
ERL_NIF_TERM x_create(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
const char * func_name = "x_create()";
logger.debug(MOD_NAME, func_name, "Entered");
logger.flush();
rados_t cluster;
int err = rados_create(&cluster, NULL);
if (err < 0)
{
logger.error(MOD_NAME, func_name, "Unable to create cluster handle");
return make_error_tuple(env, -err);
}
logger.debug(MOD_NAME, func_name, "cluster created");
logger.flush();
uint64_t id = new_id();
map_cluster_add(id, cluster);
logger.debug(MOD_NAME, func_name, "cluster added to local map: %ld", id);
logger.flush();
return enif_make_tuple2(env,
enif_make_atom(env, "ok"),
enif_make_uint64(env, id));
}
static ERL_NIF_TERM make_error(ErlNifEnv* env, yaml_parser_t *parser)
{
ERL_NIF_TERM err;
switch (parser->error) {
case YAML_MEMORY_ERROR:
err = enif_make_atom(env, "memory_error");
break;
case YAML_PARSER_ERROR:
err = enif_make_tuple4(env,
enif_make_atom(env, "parser_error"),
make_binary(env, (const unsigned char*) parser->problem),
enif_make_uint(env, parser->problem_mark.line),
enif_make_uint(env, parser->problem_mark.column));
break;
case YAML_SCANNER_ERROR:
err = enif_make_tuple4(env,
enif_make_atom(env, "scanner_error"),
make_binary(env, (const unsigned char*) parser->problem),
enif_make_uint(env, parser->problem_mark.line),
enif_make_uint(env, parser->problem_mark.column));
break;
default:
err = enif_make_atom(env, "unexpected_error");
break;
}
return enif_make_tuple2(env, enif_make_atom(env, "error"), err);
}
/* 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);
}
/*
{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(Feature).
*/
static ERL_NIF_TERM
f_get_geometry(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");
}
OGRGeometryH geom_clone = OGR_G_Clone(geom);
EnvGeometry_t **geometry = \
enif_alloc_resource(OGR_G_RESOURCE, sizeof(EnvGeometry_t*));
*geometry = (EnvGeometry_t*) enif_alloc(sizeof(EnvGeometry_t));
(**geometry).env = NULL;
(**geometry).obj = geom_clone;
eterm = enif_make_resource(env, geometry);
enif_release_resource(geometry);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
/*
{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),
{ok, Types} = lgeo_ogr:fd_get_fields_type(FeatureDefn).
{"Integer","String"}
*/
static ERL_NIF_TERM
fd_get_fields_type(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
EnvFeatureDefn_t **feat_defn;
ERL_NIF_TERM eterm;
if (argc != 1) {
return enif_make_badarg(env);
}
if(!enif_get_resource(env, argv[0], OGR_FD_RESOURCE, (void**)&feat_defn)) {
return enif_make_badarg(env);
}
int count = OGR_FD_GetFieldCount((**feat_defn).obj);
ERL_NIF_TERM *arr = (ERL_NIF_TERM *) malloc(sizeof(ERL_NIF_TERM)*count);
int index;
for(index=0; index<count; index++)
{
OGRFieldDefnH field_defn = OGR_FD_GetFieldDefn((**feat_defn).obj, index);
arr[index] = enif_make_string(env,
OGR_GetFieldTypeName(OGR_Fld_GetType(field_defn)),
ERL_NIF_LATIN1);
}
eterm = enif_make_tuple_from_array(env, arr, index);
free(arr);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
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 _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)
)
);
}
ERL_NIF_TERM
geef_reflog_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
git_reflog *reflog;
geef_repository *repo;
ErlNifBinary bin;
int error;
size_t count, i;
ERL_NIF_TERM list;
if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
return enif_make_badarg(env);
if (!enif_inspect_iolist_as_binary(env, argv[1], &bin))
return enif_make_badarg(env);
if (!geef_terminate_binary(&bin))
return geef_oom(env);
if ((error = git_reflog_read(&reflog, repo->repo, (char *)bin.data)) < 0)
return geef_error(env);
count = git_reflog_entrycount(reflog);
list = enif_make_list(env, 0);
for (i = count; i > 0; i--) {
ErlNifBinary id_old, id_new, message;
ERL_NIF_TERM tentry, name, email, time, offset;
const git_reflog_entry *entry;
entry = git_reflog_entry_byindex(reflog, i-1);
if (geef_oid_bin(&id_old, git_reflog_entry_id_old(entry)))
goto on_oom;
if (geef_oid_bin(&id_new, git_reflog_entry_id_new(entry)))
goto on_oom;
if (geef_signature_to_erl(&name, &email, &time, &offset,
env, git_reflog_entry_committer(entry)))
goto on_oom;
if (geef_string_to_bin(&message, git_reflog_entry_message(entry)))
goto on_oom;
tentry = enif_make_tuple7(env, name, email, time, offset,
enif_make_binary(env, &id_old),
enif_make_binary(env, &id_new),
enif_make_binary(env, &message));
list = enif_make_list_cell(env, tentry, list);
}
git_reflog_free(reflog);
return enif_make_tuple2(env, atoms.ok, list);
on_oom:
git_reflog_free(reflog);
return geef_oom(env);
}
static void
salt_reply_error(struct salt_msg *sm, const char *why)
{
nif_heap_t *hp = sm->msg_heap;
nif_term_t tag;
nif_term_t rsn;
nif_term_t res;
nif_term_t msg;
/* From_pid ! {Mref, {error, Rsn}} */
tag = enif_make_atom(hp, "error");
rsn = enif_make_atom(hp, why);
res = enif_make_tuple2(hp, tag, rsn);
msg = enif_make_tuple2(hp, sm->msg_mref, res);
(void)enif_send(NULL, &sm->msg_from, hp, msg);
}
