int
run_delete_event (const char *cmd, size_t argc, char *argv[])
{
if (argc != 1) {
fprintf (stderr,
_("use 'delete-event <name>' to delete an event handler\n"));
return -1;
}
const struct entry key = { .name = argv[0] };
struct entry *entry, *p;
entry = hash_delete (event_handlers, &key);
if (!entry) {
fprintf (stderr, _("delete-event: %s: no such event handler\n"), argv[0]);
return -1;
}
/* Delete them from the handle. */
p = entry;
while (p) {
guestfs_delete_event_callback (g, p->eh);
p = p->next;
}
/* Free the structures. */
entry_free (entry);
return 0;
}
PyObject *
py_guestfs_delete_event_callback (PyObject *self, PyObject *args)
{
PyObject *py_g;
guestfs_h *g;
int eh;
PyObject *py_callback;
char key[64];
if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_delete_event_callback",
&py_g, &eh))
return NULL;
g = get_handle (py_g);
snprintf (key, sizeof key, "_python_event_%d", eh);
py_callback = guestfs_get_private (g, key);
if (py_callback) {
Py_XDECREF (py_callback);
guestfs_set_private (g, key, NULL);
guestfs_delete_event_callback (g, eh);
}
Py_INCREF (Py_None);
return Py_None;
}
JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1delete_1event_1callback
(JNIEnv *env, jobject obj, jlong jg, jint eh)
{
guestfs_h *g = (guestfs_h *) (long) jg;
char key[64];
struct callback_data *data;
snprintf (key, sizeof key, "_java_event_%d", eh);
data = guestfs_get_private (g, key);
if (data) {
(*env)->DeleteGlobalRef (env, data->callback);
free (data);
guestfs_set_private (g, key, NULL);
guestfs_delete_event_callback (g, eh);
}
}
static void
replace_old_style_event_callback (guestfs_h *g,
guestfs_event_callback cb,
uint64_t event_bitmask,
void *opaque,
void *opaque2)
{
size_t i;
/* Use 'cb' pointer as a sentinel to replace the existing callback
* for this event if one was registered previously. Else append a
* new event.
*/
for (i = 0; i < g->nr_events; ++i)
if (g->events[i].cb == cb) {
if (opaque2 == NULL) {
/* opaque2 (the original callback) is NULL, which in the
* old-style API meant remove the callback.
*/
guestfs_delete_event_callback (g, i);
return;
}
goto replace;
}
if (opaque2 == NULL)
return; /* see above */
/* i == g->nr_events */
g->events =
safe_realloc (g, g->events,
(g->nr_events+1) * sizeof (struct event));
g->nr_events++;
replace:
g->events[i].event_bitmask = event_bitmask;
g->events[i].cb = cb;
g->events[i].opaque = opaque;
g->events[i].opaque2 = opaque2;
}
/* Guestfs.delete_event_callback */
CAMLprim value
ocaml_guestfs_delete_event_callback (value gv, value ehv)
{
CAMLparam2 (gv, ehv);
char key[64];
int eh = Int_val (ehv);
guestfs_h *g = Guestfs_val (gv);
snprintf (key, sizeof key, "_ocaml_event_%d", eh);
value *root = guestfs_get_private (g, key);
if (root) {
caml_remove_global_root (root);
free (root);
guestfs_set_private (g, key, NULL);
guestfs_delete_event_callback (g, eh);
}
CAMLreturn (Val_unit);
}
int
run_event (const char *cmd, size_t argc, char *argv[])
{
int r;
struct entry *entry = NULL, *old_entry;
if (argc != 3) {
fprintf (stderr,
_("use 'event <name> <eventset> <script>' to register an event handler\n"));
goto error;
}
entry = calloc (1, sizeof *entry);
if (entry == NULL) {
perror ("calloc");
goto error;
}
entry->eh = -1;
r = event_bitmask_of_event_set (argv[1], &entry->event_bitmask);
if (r == -1)
goto error;
entry->name = strdup (argv[0]);
if (entry->name == NULL) {
perror ("strdup");
goto error;
}
entry->command = strdup (argv[2]);
if (entry->command == NULL) {
perror ("strdup");
goto error;
}
entry->eh =
guestfs_set_event_callback (g, do_event_handler,
entry->event_bitmask, 0, entry);
if (entry->eh == -1)
goto error;
r = hash_insert_if_absent (event_handlers, entry, (const void **) &old_entry);
if (r == -1)
goto error;
if (r == 0) { /* old_entry set to existing entry */
entry->next = old_entry->next;
/* XXX are we allowed to update the old entry? */
old_entry->next = entry;
}
return 0;
error:
if (entry) {
if (entry->eh >= 0)
guestfs_delete_event_callback (g, entry->eh);
free (entry->name);
free (entry->command);
free (entry);
}
return -1;
}
