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