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