void* cb_http_args(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { http_args_t* args = (http_args_t*)enif_alloc(sizeof(http_args_t)); unsigned int len; if (!enif_get_list_length(env, argv[0], &len)) goto error0; len += 1; args->path = (char *)enif_alloc(len * sizeof(char)); if (!enif_get_string(env, argv[0], args->path, len, ERL_NIF_LATIN1)) goto error1; if (!enif_get_list_length(env, argv[1], &len)) goto error1; len += 1; args->body = (char *)enif_alloc(len * sizeof(char)); if (!enif_get_string(env, argv[1], args->body, len, ERL_NIF_LATIN1)) goto error2; if (!enif_get_list_length(env, argv[2], &len)) goto error2; len += 1; args->content_type = (char *)enif_alloc(len * sizeof(char)); if (!enif_get_string(env, argv[2], args->content_type, len, ERL_NIF_LATIN1)) goto error3; if (!enif_get_int(env, argv[3], (int*)&args->method)) goto error3; if (!enif_get_int(env, argv[4], (int*)&args->type)) goto error3; return (void*)args; error3: enif_free(args->content_type); error2: enif_free(args->path); error1: enif_free(args->body); error0: return NULL; }
/* @brief Checks whether two *paths* are on the same mount point; they don't * have to refer to existing or accessible files/directories. */ static int has_same_mount_point(const efile_path_t *path_a, const efile_path_t *path_b) { WCHAR *mount_a, *mount_b; int result = 0; mount_a = enif_alloc(path_a->size); mount_b = enif_alloc(path_b->size); if(mount_a != NULL && mount_b != NULL) { int length_a, length_b; length_a = PATH_LENGTH(path_a); length_b = PATH_LENGTH(path_b); if(GetVolumePathNameW((WCHAR*)path_a->data, mount_a, length_a)) { ASSERT(wcslen(mount_a) <= length_a); if(GetVolumePathNameW((WCHAR*)path_b->data, mount_b, length_b)) { ASSERT(wcslen(mount_b) <= length_b); result = !_wcsicmp(mount_a, mount_b); } } } if(mount_b != NULL) { enif_free(mount_b); } if(mount_a != NULL) { enif_free(mount_a); } return result; }
static int load(ErlNifEnv *env, void **priv, ERL_NIF_TERM load_info) { PRIVDATA *data = NULL; int nelem = 0; if (!enif_get_int(env, load_info, &nelem) || (nelem < 1)) return (-1); data = (PRIVDATA *)enif_alloc(sizeof(PRIVDATA)); if (data == NULL) return (-1); data->data = (PRIVVAL *)enif_alloc(sizeof(PRIVVAL) * nelem); if (data->data == NULL) { enif_free(data); return (-1); } (void)memset(data->data, 0, sizeof(PRIVVAL) * nelem); data->lock = enif_mutex_create("wat_lock"); if (data->lock == NULL) return (-1); NELEM(data) = nelem; *priv = data; return (0); }
int on_load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info) { UErrorCode status = U_ZERO_ERROR; int i, j; couch_ejson_global_ctx_t *globalCtx; globalCtx = (couch_ejson_global_ctx_t *) enif_alloc(sizeof(couch_ejson_global_ctx_t)); if (globalCtx == NULL) { return 1; } if (!enif_get_int(env, info, &globalCtx->numCollators)) { return 2; } if (globalCtx->numCollators < 1) { return 3; } globalCtx->collMutex = enif_mutex_create("coll_mutex"); if (globalCtx->collMutex == NULL) { return 4; } globalCtx->collators = (UCollator **) enif_alloc(sizeof(UCollator *) * globalCtx->numCollators); if (globalCtx->collators == NULL) { enif_mutex_destroy(globalCtx->collMutex); return 5; } for (i = 0; i < globalCtx->numCollators; i++) { globalCtx->collators[i] = ucol_open("", &status); if (U_FAILURE(status)) { for (j = 0; j < i; j++) { ucol_close(globalCtx->collators[j]); } enif_free(globalCtx->collators); enif_mutex_destroy(globalCtx->collMutex); return 5; } } globalCtx->collStackTop = 0; *priv = globalCtx; ATOM_TRUE = enif_make_atom(env, "true"); ATOM_FALSE = enif_make_atom(env, "false"); ATOM_NULL = enif_make_atom(env, "null"); ATOM_ERROR = enif_make_atom(env, "error"); return 0; }
static struct buf *init_buf(ErlNifEnv* env, int buf_len) { struct buf *rbuf = enif_alloc(sizeof(struct buf)); rbuf->limit = buf_len; rbuf->len = 0; rbuf->b = enif_alloc(rbuf->limit); return rbuf; }
static int get_engine_load_cmd_list(ErlNifEnv* env, const ERL_NIF_TERM term, char **cmds, int i) { ERL_NIF_TERM head, tail; const ERL_NIF_TERM *tmp_tuple; ErlNifBinary tmpbin; int arity; char *tuple1 = NULL, *tuple2 = NULL; if (enif_is_empty_list(env, term)) { cmds[i] = NULL; return 0; } if (!enif_get_list_cell(env, term, &head, &tail)) goto err; if (!enif_get_tuple(env, head, &arity, &tmp_tuple)) goto err; if (arity != 2) goto err; if (!enif_inspect_binary(env, tmp_tuple[0], &tmpbin)) goto err; if ((tuple1 = enif_alloc(tmpbin.size + 1)) == NULL) goto err; (void) memcpy(tuple1, tmpbin.data, tmpbin.size); tuple1[tmpbin.size] = '\0'; cmds[i] = tuple1; i++; if (!enif_inspect_binary(env, tmp_tuple[1], &tmpbin)) goto err; if (tmpbin.size == 0) { cmds[i] = NULL; } else { if ((tuple2 = enif_alloc(tmpbin.size + 1)) == NULL) goto err; (void) memcpy(tuple2, tmpbin.data, tmpbin.size); tuple2[tmpbin.size] = '\0'; cmds[i] = tuple2; } i++; return get_engine_load_cmd_list(env, tail, cmds, i); err: if (tuple1 != NULL) { i--; enif_free(tuple1); } cmds[i] = NULL; return -1; }
static int handle_start(void *ctx, int array) { state_t *st = (state_t *)ctx; container_t *c = enif_alloc(st->env, sizeof(container_t)); /* link and initialize container struct */ c->next = st->c; st->c = c; c->count = 0; c->arraysz = 32; /* initial term buffer size */ c->array = enif_alloc(st->env, c->arraysz); return 1; }
void* nif_create_main_thread(char* name) { nif_thread_state* st = (nif_thread_state*)enif_alloc(sizeof(nif_thread_state)); st->lock = enif_mutex_create("esdl2_lock"); st->cond = enif_cond_create("esdl2_cond"); st->mailbox = (nif_thread_mailbox*)enif_alloc(sizeof(nif_thread_mailbox)); TAILQ_INIT(st->mailbox); enif_thread_create(name, &(st->tid), nif_main_thread, st, NULL); return (void*)st; }
int queue_push(queue *queue, void *item) { qitem * entry = (qitem *) enif_alloc(sizeof(qitem)); if (entry == NULL) return 0; entry->data = item; entry->next = NULL; enif_mutex_lock(queue->lock); assert(queue->length >= 0 && "Invalid queue size at push"); if (queue->tail != NULL) { queue->tail->next = entry; } queue->tail = entry; if (queue->head == NULL) { queue->head = queue->tail; } queue->length += 1; enif_cond_signal(queue->cond); enif_mutex_unlock(queue->lock); return 1; }
queue * queue_new() { queue *ret; ret = (queue *) enif_alloc(sizeof(queue)); if (ret == NULL) goto error; ret->lock = NULL; ret->cond = NULL; ret->head = NULL; ret->tail = NULL; ret->message = NULL; ret->length = 0; ret->lock = enif_mutex_create("queue_lock"); if (ret->lock == NULL) goto error; ret->cond = enif_cond_create("queue_cond"); if (ret->cond == NULL) goto error; return ret; error: if (ret->lock != NULL) enif_mutex_destroy(ret->lock); if (ret->cond != NULL) enif_cond_destroy(ret->cond); if (ret != NULL) enif_free(ret); return NULL; }
static int on_load(ErlNifEnv *env, void **priv_data, ERL_NIF_TERM load_info) { gmperl_privdata_t *priv; priv = (gmperl_privdata_t *)enif_alloc(sizeof(gmperl_privdata_t)); priv->gmperl_mpz_rt = NULL; priv->gmperl_mpq_rt = NULL; priv->gmperl_mpf_rt = NULL; *priv_data = priv; /* Use Erlang NIF memory allocation/deallocation */ mp_set_memory_functions(gmperl_allocate, gmperl_reallocate, gmperl_free); /* Create resource types */ ErlNifResourceFlags flags = (ErlNifResourceFlags)(ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER); priv->gmperl_mpz_rt = enif_open_resource_type(env, "gmperl_nifs", "gmperl_mpz_resource", gmperl_mpz_t_dtor, flags, NULL); priv->gmperl_mpq_rt = enif_open_resource_type(env, "gmperl_nifs", "gmperl_mpq_resource", gmperl_mpq_t_dtor, flags, NULL); priv->gmperl_mpf_rt = enif_open_resource_type(env, "gmperl_nifs", "gmperl_mpf_resource", gmperl_mpf_t_dtor, flags, NULL); if (!enif_make_existing_atom(env, "ok", &priv->atom_ok, ERL_NIF_LATIN1) || !enif_make_existing_atom(env, "true", &priv->atom_true, ERL_NIF_LATIN1) || !enif_make_existing_atom(env, "false", &priv->atom_false, ERL_NIF_LATIN1)) { return -1; } return 0; }
static ERL_NIF_TERM float_ref(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int err; double helper; float *value; value = enif_alloc(sizeof(float)); if (!value) { goto error; } err = enif_get_double(env, argv[0], &helper); if (!err) { enif_free(value); goto error; } *value = (float)helper; return enif_make_tuple2(env, nifty_make_ptr(env, (ptr_t)value), enif_make_string(env, "nifty.float *", ERL_NIF_LATIN1)); error: return enif_make_badarg(env); }
int queue_push(queue_t* queue, ErlNifPid* pid) { qitem_t* item = (qitem_t*) enif_alloc(sizeof(qitem_t)); if(item == NULL) return 0; item->pid = pid; item->next = NULL; enif_mutex_lock(queue->lock); if(queue->tail != NULL) { queue->tail->next = item; } queue->tail = item; if(queue->head == NULL) { queue->head = queue->tail; } enif_cond_signal(queue->cond); enif_mutex_unlock(queue->lock); return 1; }
/* {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); }
static ERL_NIF_TERM new_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { XML_Parser parser; expat_parser *parser_data = (expat_parser *)enif_alloc(sizeof(expat_parser)); ERL_NIF_TERM parser_resource; // this is the variant from esl/exml:208d5e17e547b303b310627e3e525b57b2843e83 /*parser = XML_ParserCreate_MM("UTF-8", &ms, "\n");*/ // this makes the tests pass, but according to expat documentation it turns namespace support off /*parser = XML_ParserCreate_MM("UTF-8", &ms, NULL);*/ // this is a try to preserve namespace support but make the tests pass; // this is the character defined as a macro in xmlwf sources for namespace-enabled parser /*XML_Char namespaceSeparator = '\001';*/ /*parser = XML_ParserCreate_MM("UTF-8", &ms, &namespaceSeparator);*/ parser = XML_ParserCreate_MM("UTF-8", &ms, ":"); parser_data->env = env; parser_data->xmlns = (ERL_NIF_TERM)NULL; init_parser(parser, parser_data); XML_Parser *xml_parser = (XML_Parser *)enif_alloc_resource(PARSER_POINTER, sizeof(XML_Parser)); *xml_parser = parser; parser_resource = enif_make_resource(env, (void *)xml_parser); enif_release_resource(xml_parser); return enif_make_tuple(env, 2, OK, parser_resource); };
void* cb_store_args(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { store_args_t* args = (store_args_t*)enif_alloc(sizeof(store_args_t)); ErlNifBinary value_binary; ErlNifBinary key_binary; if (!enif_get_int(env, argv[0], &args->operation)) goto error0; if (!enif_inspect_iolist_as_binary(env, argv[1], &key_binary)) goto error0; if (!enif_inspect_iolist_as_binary(env, argv[2], &value_binary)) goto error0; args->nkey = key_binary.size; args->nbytes = value_binary.size; args->key = (char*)malloc(key_binary.size); args->bytes = (char*)malloc(value_binary.size); memcpy(args->bytes, value_binary.data, value_binary.size); memcpy(args->key, key_binary.data, key_binary.size); if (!enif_get_uint(env, argv[3], &args->flags)) goto error1; if (!enif_get_int(env, argv[4], &args->exp)) goto error1; if (!enif_get_uint64(env, argv[5], (ErlNifUInt64*)&args->cas)) goto error1; return args; error1: free(args->bytes); free(args->key); error0: enif_free(args); return NULL; }
static ERL_NIF_TERM do_column_types(ErlNifEnv *env, sqlite3_stmt *stmt) { int i, size; const char *type; ERL_NIF_TERM *array; ERL_NIF_TERM column_types; size = sqlite3_column_count(stmt); if(size == 0) return enif_make_tuple(env, 0); else if(size < 0) return make_error_tuple(env, "invalid_column_count"); array = (ERL_NIF_TERM *) enif_alloc(sizeof(ERL_NIF_TERM) * size); if(!array) return make_error_tuple(env, "no_memory"); for(i = 0; i < size; i++) { type = sqlite3_column_decltype(stmt, i); if(type == NULL) { type = "nil"; } array[i] = make_atom(env, type); } column_types = enif_make_tuple_from_array(env, array, size); enif_free(array); return column_types; }
static void enq_char(yang_scanner_t* obj, int c) { token_t* t = (token_t*) enif_alloc(sizeof(token_t)); t->type = c; t->line = obj->line; enq_token(obj, t); }
static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) { PrivData* data = enif_alloc(sizeof(PrivData)); assert(data != NULL); data->ref_cnt = 1; data->call_history = NULL; data->nif_mod = NULL; add_call(env, data, "load"); data->rt_arr[0].t = enif_open_resource_type(env,NULL,"Gold",resource_dtor, ERL_NIF_RT_CREATE,NULL); data->rt_arr[1].t = enif_open_resource_type(env,NULL,"Silver",resource_dtor, ERL_NIF_RT_CREATE,NULL); binary_resource_type = enif_open_resource_type(env,NULL,"nif_SUITE.binary", binary_resource_dtor, ERL_NIF_RT_CREATE, NULL); msgenv_resource_type = enif_open_resource_type(env,NULL,"nif_SUITE.msgenv", msgenv_dtor, ERL_NIF_RT_CREATE, NULL); atom_self = enif_make_atom(env,"self"); atom_ok = enif_make_atom(env,"ok"); atom_join = enif_make_atom(env,"join"); atom_binary_resource_type = enif_make_atom(env,"binary_resource_type"); *priv_data = data; return 0; }
static int make_num(ErlNifEnv* env, const unsigned char *value, size_t size, long int *i, double *d) { int ret = 0; if (size>0) { char *buf = enif_alloc(size + 1); if (buf) { memcpy(buf, value, size); buf[size] = '\0'; char *check; *i = strtol(buf, &check, 10); if (*check == '\0') ret = INTEGER; else if (*check == '.') { *d = strtod(buf, &check); if (*check == '\0') ret = FLOAT; } enif_free(buf); } } return ret; }
int init_parser(Parser* parser, ErlNifEnv* env, ERL_NIF_TERM arg, ErlNifBinary* buffer, ERL_NIF_TERM columns) { parser->env = env; parser->atoms = enif_priv_data(env); parser->raw = arg; parser->buffer = buffer->data; if(!enif_get_list_length(env, columns, &parser->table_width)) return 0; ERL_NIF_TERM list, head, tail; int val, index = 0; parser->columns = (int *) enif_alloc(parser->table_width * sizeof(int)); list = columns; while(enif_get_list_cell(env, list, &head, &tail)) { if (!enif_get_int(env, head, &val)) return 0; parser->columns[index] = val; index++; list = tail; } parser->frame_start = 0; parser->frame_size = 0; parser->buffer_size = buffer->size; return 1; }
queue_ptr queue_create(const char* name) { queue_ptr ret; ret = (queue_ptr) enif_alloc(sizeof(struct queue_t)); if(ret == NULL) goto error; ret->lock = NULL; ret->cond = NULL; ret->head = NULL; ret->tail = NULL; ret->message = NULL; ret->length = 0; ret->lock = enif_mutex_create("queue_lock"); if(ret->lock == NULL) goto error; ret->cond = enif_cond_create("queue_cond"); if(ret->cond == NULL) goto error; return ret; error: if(ret->lock != NULL) enif_mutex_destroy(ret->lock); if(ret->cond != NULL) enif_cond_destroy(ret->cond); if(ret != NULL) enif_free(ret); return NULL; }
static int load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info) { jiffy_st* st = enif_alloc(sizeof(jiffy_st)); if(st == NULL) { return 1; } st->atom_ok = make_atom(env, "ok"); st->atom_error = make_atom(env, "error"); st->atom_null = make_atom(env, "null"); st->atom_true = make_atom(env, "true"); st->atom_false = make_atom(env, "false"); st->atom_bignum = make_atom(env, "bignum"); st->atom_bignum_e = make_atom(env, "bignum_e"); st->atom_bigdbl = make_atom(env, "bigdbl"); st->atom_partial = make_atom(env, "partial"); st->atom_uescape = make_atom(env, "uescape"); st->atom_pretty = make_atom(env, "pretty"); // Markers used in encoding st->ref_object = make_atom(env, "$object_ref$"); st->ref_array = make_atom(env, "$array_ref$"); *priv = (void*) st; return 0; }
queue *queue_create() { queue *ret; // int i = 0; // qitem *item; ret = (queue *) enif_alloc(sizeof(struct queue_t)); if(ret == NULL) goto error; // ret->freeitem = freecb; ret->lock = NULL; ret->cond = NULL; ret->head = NULL; ret->tail = NULL; ret->length = 0; ret->reuseq = NULL; ret->lock = enif_mutex_create("queue_lock"); if(ret->lock == NULL) goto error; ret->cond = enif_cond_create("queue_cond"); if(ret->cond == NULL) goto error; return ret; error: if(ret->lock != NULL) enif_mutex_destroy(ret->lock); if(ret->cond != NULL) enif_cond_destroy(ret->cond); if(ret != NULL) enif_free(ret); return NULL; }
/* 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); }
static ERL_NIF_TERM list_to_cstr(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int err, written, tmp; unsigned int l; char* cstr; err = enif_get_list_length(env, argv[0], &l); if (!err) { goto error; } l+=1; // Null Termination cstr = enif_alloc(sizeof(char)*l); if (!cstr) { goto error; } written = 0; while (written<(l)) { tmp = enif_get_string(env, argv[0], cstr+written, l-written, ERL_NIF_LATIN1); if (tmp<=0) { enif_free(cstr); goto error; } written += tmp; } return enif_make_tuple2(env, enif_make_int64(env, (ptr_t)cstr), enif_make_string(env, "nifty.char *", ERL_NIF_LATIN1)); error: return enif_make_badarg(env); }
static ERL_NIF_TERM compile(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary patternbin; if (enif_inspect_iolist_as_binary(env, argv[0], &patternbin)) { ERL_NIF_TERM ret; xmlRegexpPtr xre; char *patternstr = enif_alloc(patternbin.size + 1); patternstr[patternbin.size] = 0; memcpy(patternstr, patternbin.data, patternbin.size); if ((xre = xmlRegexpCompile((xmlChar *)patternstr)) != NULL) { struct regexp *r; r = enif_alloc_resource(regexp_type, sizeof(struct regexp)); memset(r, 0, sizeof(*r)); r->xre = xre; r->string = patternstr; /* transfer ownership to calling process */ ret = enif_make_tuple2(env, am_ok(env), enif_make_resource(env, r)); enif_release_resource(r); } else { enif_free(patternstr); ret = last_error(env, "Bad Pattern"); } return ret; } return enif_make_badarg(env); }
static int load(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info) { state_t* state = (state_t*) enif_alloc(sizeof(state_t)); if(state == NULL) return -1; state->queue = queue_create(); if(state->queue == NULL) goto error; state->opts = enif_thread_opts_create("thread_opts"); if(enif_thread_create( "", &(state->qthread), thr_main, state, state->opts ) != 0) { goto error; } state->atom_ok = enif_make_atom(env, "ok"); *priv = (void*) state; return 0; error: if(state->queue != NULL) queue_destroy(state->queue); //enif_free(state->queue); //double free bug ( already called free at queue_destroy() ) return -1; }
static int load(ErlNifEnv *env, void **priv_data, ERL_NIF_TERM load_info) { EWPCAP_STATE *state = NULL; state = enif_alloc(sizeof(EWPCAP_STATE)); if (state == NULL) return -1; atom_ok = enif_make_atom(env, "ok"); atom_error = enif_make_atom(env, "error"); atom_enomem = enif_make_atom(env, "enomem"); atom_ewpcap = enif_make_atom(env, "ewpcap"); atom_ewpcap_resource = enif_make_atom(env, "ewpcap_resource"); atom_ewpcap_error = enif_make_atom(env, "ewpcap_error"); atom_description = enif_make_atom(env, "description"); atom_addr = enif_make_atom(env, "addr"); atom_flag = enif_make_atom(env, "flag"); atom_netmask = enif_make_atom(env, "netmask"); atom_broadaddr = enif_make_atom(env, "broadaddr"); atom_dstaddr = enif_make_atom(env, "dstaddr"); atom_loopback = enif_make_atom(env, "loopback"); if ( (EWPCAP_RESOURCE = enif_open_resource_type(env, NULL, "ewpcap_resource", ewpcap_cleanup, ERL_NIF_RT_CREATE, NULL)) == NULL) return -1; return 0; }
qitem* queue_get_item(queue *queue) { qitem *entry = NULL; int i; while (enif_mutex_trylock(queue->lock) != 0) { } if (queue->reuseq != NULL) { entry = queue->reuseq; queue->reuseq = queue->reuseq->next; entry->next = NULL; } else { entry = enif_alloc(sizeof(qitem)*BLOCK_SIZE); memset(entry,0,sizeof(qitem)*BLOCK_SIZE); for (i = 1; i < BLOCK_SIZE; i++) { entry[i].env = enif_alloc_env(); entry[i].next = queue->reuseq; queue->reuseq = &entry[i]; } entry->env = enif_alloc_env(); entry->blockStart = 1; } enif_mutex_unlock(queue->lock); return entry; }