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); }