static ERL_NIF_TERM nif_notify(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary summary; ErlNifBinary body; ErlNifBinary icon; ErlNifBinary category; int urgency = NOTIFY_URGENCY_NORMAL; int timeout = 0; gchar *s_summary = NULL; gchar *s_body = NULL; gchar *s_icon = NULL; gchar *s_category = NULL; ERL_NIF_TERM hints; ERL_NIF_TERM head; ERL_NIF_TERM tail; const ERL_NIF_TERM *array; int arity = 0; NotifyNotification *notify = NULL; ERL_NIF_TERM rv = atom_ok; if (!enif_inspect_iolist_as_binary(env, argv[0], &summary)) return enif_make_badarg(env); if (!enif_inspect_iolist_as_binary(env, argv[1], &body)) return enif_make_badarg(env); if (!enif_inspect_iolist_as_binary(env, argv[2], &icon)) return enif_make_badarg(env); if (!enif_inspect_iolist_as_binary(env, argv[3], &category)) return enif_make_badarg(env); if (!enif_get_int(env, argv[4], &urgency)) return enif_make_badarg(env); if (!enif_get_int(env, argv[5], &timeout)) return enif_make_badarg(env); if (!enif_is_list(env, argv[6])) return enif_make_badarg(env); hints = argv[6]; s_summary = stralloc(&summary); s_body = stralloc(&body); s_icon = stralloc(&icon); s_category = stralloc(&category); if ( (s_summary == NULL) || (s_body == NULL) || (s_icon == NULL) || (s_category == NULL)) { rv = enif_make_tuple2(env, atom_error, atom_nomem); goto ERR; } notify = notify_notification_new(s_summary, s_body, s_icon); notify_notification_set_category(notify, s_category); notify_notification_set_urgency(notify, urgency); notify_notification_set_timeout(notify, timeout); while (enif_get_list_cell(env, hints, &head, &tail)) { ERL_NIF_TERM key; ERL_NIF_TERM value = atom_undefined; if (enif_get_tuple(env, head, &arity, &array)) { switch (arity) { case 2: value = array[1]; key = array[0]; break; default: rv = enif_make_badarg(env); goto ERR; } } else if (enif_is_list(env, head)) { arity = 0; key = head; } else { rv = enif_make_badarg(env); goto ERR; } if (notify_hints_type(env, notify, arity, key, value) < 0) { rv = enif_make_badarg(env); goto ERR; } hints = tail; } notify_notification_show(notify, NULL); ERR: if (notify) g_object_unref(G_OBJECT(notify)); strfree(s_summary); strfree(s_body); strfree(s_icon); strfree(s_category); return rv; }
static ERL_NIF_TERM do_job(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { state_t *state = NULL; ErlNifBinary input; size_t block_size; int is_eof; size_t input_size; char *input_data; rs_result res; if (!enif_get_resource(env, argv[0], state_r, (void *) &state)) return enif_make_badarg(env); if (argc == 1) { is_eof = 1; input_size = 0; input_data = NULL; } else { if (!enif_inspect_iolist_as_binary(env, argv[1], &input)) return enif_make_badarg(env); is_eof = 0; input_size = input.size; input_data = (char *) input.data; } block_size = MAX(state->in_size + input_size, RS_JOB_BLOCKSIZE); if (input_size) { state->in = realloc(state->in, state->in_size + input_size); memcpy(state->in + state->in_size, input_data, input_size); } state->in_size += input_size; state->out_size = 0; while (1) { state->out = realloc(state->out, state->out_size + block_size); rs_buffers_t buf = {.next_in = state->in, .avail_in = state->in_size, .eof_in = is_eof, .next_out = state->out + state->out_size, .avail_out = block_size}; res = rs_job_iter(state->job, &buf); state->in_size = buf.avail_in; state->out_size += block_size - buf.avail_out; if (res == RS_BLOCKED) { if (buf.avail_in > 0) { state->in = realloc(state->in, buf.avail_in); memcpy(state->in, buf.next_in, buf.avail_in); } if (!is_eof) return mk_output(env, state); } else if (res == RS_DONE) { return mk_output(env, state); } else { return mk_error(env, res); } } } static ERL_NIF_TERM job_iter(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { return do_job(env, argc, argv); } static ERL_NIF_TERM job_done(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { return do_job(env, argc, argv); } static ErlNifFunc nif_funcs[] = { {"sig_init", 0, sig_init}, {"loadsig_init", 0, loadsig_init}, {"delta_init", 1, delta_init}, {"patch_init", 1, patch_init}, {"format_error_nif", 1, format_error}, {"job_iter", 2, job_iter}, {"job_done", 1, job_done} }; ERL_NIF_INIT(rsync, nif_funcs, load, NULL, NULL, NULL)
static ERL_NIF_TERM re2_match(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary sdata; if (enif_inspect_iolist_as_binary(env, argv[0], &sdata)) { const re2::StringPiece s((const char*)sdata.data, sdata.size); autohandle<re2::RE2> re; union re2_handle_union handle; ErlNifBinary pdata; matchoptions opts(env); if (argc == 3 && !parse_match_options(env, argv[2], opts)) return enif_make_badarg(env); if (enif_get_resource(env, argv[1], re2_resource_type, &handle.vp) && handle.p->re != NULL) { re.set(handle.p->re, true); if (opts.caseless) // caseless allowed either in compile or match return enif_make_badarg(env); } else if (enif_inspect_iolist_as_binary(env, argv[1], &pdata)) { const re2::StringPiece p((const char*)pdata.data, pdata.size); re2::RE2::Options re2opts; re2opts.set_log_errors(false); if (opts.caseless) re2opts.set_case_sensitive(false); re.set(new re2::RE2(p, re2opts)); } else { return enif_make_badarg(env); } if (!re->ok()) return enif_make_badarg(env); int n = re->NumberOfCapturingGroups()+1; std::vector<re2::StringPiece> group; group.reserve(n); if (re->Match(s, opts.offset, s.size(), re2::RE2::UNANCHORED, &group[0], n)) { int start = 0; int arrsz = n; if (opts.vs == matchoptions::VS_NONE) { // return match atom only return a_match; } else if (opts.vs == matchoptions::VS_FIRST) { // return first match only ERL_NIF_TERM first = mres(env, s, group[0], opts.ct); if (enif_is_identical(first, a_err_alloc_binary)) { return error(env, a_err_alloc_binary); } else { return enif_make_tuple2(env, a_match, enif_make_list1(env, first)); } } else if (opts.vs == matchoptions::VS_ALL_BUT_FIRST) { // skip first match start = 1; arrsz--; } if (opts.vs == matchoptions::VS_VLIST) { // return matched subpatterns as specified in ValueList return re2_match_ret_vlist(env, re, s, opts, group, n); } else { // return all or all_but_first matches ERL_NIF_TERM* arr = new ERL_NIF_TERM[n]; for(int i = start, arridx=0; i < n; i++,arridx++) { ERL_NIF_TERM res = mres(env, s, group[i], opts.ct); if (enif_is_identical(res, a_err_alloc_binary)) { delete[] arr; return error(env, a_err_alloc_binary); } else { arr[arridx] = res; } } ERL_NIF_TERM list = enif_make_list_from_array(env,arr,arrsz); delete[] arr; return enif_make_tuple2(env, a_match, list); } } else { return a_nomatch; } } else { return enif_make_badarg(env); } }
ERL_NIF_TERM geef_index_add(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { geef_index *index; const ERL_NIF_TERM *eentry; int arity; unsigned int tmp; ErlNifBinary path, id; git_index_entry entry; if (!enif_get_resource(env, argv[0], geef_index_type, (void **) &index)) return enif_make_badarg(env); if (!enif_get_tuple(env, argv[1], &arity, &eentry)) return enif_make_badarg(env); memset(&entry, 0, sizeof(entry)); if (enif_compare(eentry[1], atoms.undefined) && !enif_get_int64(env, eentry[1], &entry.ctime.seconds)) return enif_make_badarg(env); if (enif_compare(eentry[2], atoms.undefined) && !enif_get_int64(env, eentry[2], &entry.mtime.seconds)) return enif_make_badarg(env); if (enif_compare(eentry[3], atoms.undefined) && !enif_get_uint(env, eentry[3], &entry.dev)) return enif_make_badarg(env); if (enif_compare(eentry[4], atoms.undefined) && !enif_get_uint(env, eentry[4], &entry.ino)) return enif_make_badarg(env); if (!enif_get_uint(env, eentry[5], &entry.mode)) return enif_make_badarg(env); if (enif_compare(eentry[6], atoms.undefined) && !enif_get_uint(env, eentry[6], &entry.uid)) return enif_make_badarg(env); if (enif_compare(eentry[7], atoms.undefined) && !enif_get_uint(env, eentry[7], &entry.gid)) return enif_make_badarg(env); if (!enif_get_int64(env, eentry[8], &entry.file_size)) return enif_make_badarg(env); /* [9] comes later */ tmp = 0; if (enif_compare(eentry[10], atoms.undefined) && !enif_get_uint(env, eentry[10], &tmp)) return enif_make_badarg(env); entry.flags = tmp; tmp = 0; if (enif_compare(eentry[11], atoms.undefined) && !enif_get_uint(env, eentry[11], &tmp)) return enif_make_badarg(env); entry.flags_extended = tmp; if (!enif_inspect_iolist_as_binary(env, eentry[12], &path)) return enif_make_badarg(env); if (!geef_terminate_binary(&path)) return geef_oom(env); entry.path = (char *) path.data; if (!enif_inspect_binary(env, eentry[9], &id)) return enif_make_badarg(env); git_oid_fromraw(&entry.id, id.data); if (git_index_add(index->index, &entry) < 0) return geef_error(env); return atoms.ok; }