static int
weston_xserver_handle_event(int listen_fd, uint32_t mask, void *data)
{
struct weston_xserver *mxs = data;
char display[8], s[8];
int sv[2], client_fd;
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
weston_log("socketpair failed\n");
return 1;
}
mxs->process.pid = fork();
switch (mxs->process.pid) {
case 0:
/* SOCK_CLOEXEC closes both ends, so we need to unset
* the flag on the client fd. */
client_fd = dup(sv[1]);
if (client_fd < 0)
return 1;
snprintf(s, sizeof s, "%d", client_fd);
setenv("WAYLAND_SOCKET", s, 1);
snprintf(display, sizeof display, ":%d", mxs->display);
if (execl(XSERVER_PATH,
XSERVER_PATH,
display,
"-wayland",
"-rootless",
"-retro",
"-nolisten", "all",
"-terminate",
NULL) < 0)
weston_log("exec failed: %m\n");
exit(-1);
default:
weston_log("forked X server, pid %d\n", mxs->process.pid);
close(sv[1]);
mxs->client = wl_client_create(mxs->wl_display, sv[0]);
weston_watch_process(&mxs->process);
wl_event_source_remove(mxs->abstract_source);
wl_event_source_remove(mxs->unix_source);
break;
case -1:
weston_log( "failed to fork\n");
break;
}
return 1;
}
void
tty_destroy(struct tty *tty)
{
if (tty->input_source)
wl_event_source_remove(tty->input_source);
wl_event_source_remove(tty->vt_source);
tty_reset(tty);
close(tty->fd);
free(tty);
}
void
tty_destroy(struct tty *tty)
{
struct vt_mode mode = { 0 };
if(!tty)
return;
if (ioctl(tty->fd, KDSKBMODE, tty->kb_mode))
fprintf(stderr, "failed to restore keyboard mode: %m\n");
if (ioctl(tty->fd, KDSETMODE, KD_TEXT))
fprintf(stderr,
"failed to set KD_TEXT mode on tty: %m\n");
if (tcsetattr(tty->fd, TCSANOW, &tty->terminal_attributes) < 0)
fprintf(stderr,
"could not restore terminal to canonical mode\n");
mode.mode = VT_AUTO;
if (ioctl(tty->fd, VT_SETMODE, &mode) < 0)
fprintf(stderr, "could not reset vt handling\n");
if (tty->has_vt && tty->vt != tty->starting_vt) {
ioctl(tty->fd, VT_ACTIVATE, tty->starting_vt);
ioctl(tty->fd, VT_WAITACTIVE, tty->starting_vt);
}
wl_event_source_remove(tty->vt_source);
close(tty->fd);
free(tty);
}
static int
clipboard_source_data(int fd, uint32_t mask, void *data)
{
struct clipboard_source *source = data;
struct clipboard *clipboard = source->clipboard;
char *p;
int len, size;
if (source->contents.alloc - source->contents.size < 1024) {
wl_array_add(&source->contents, 1024);
source->contents.size -= 1024;
}
p = source->contents.data + source->contents.size;
size = source->contents.alloc - source->contents.size;
len = read(fd, p, size);
if (len == 0) {
wl_event_source_remove(source->event_source);
close(fd);
source->event_source = NULL;
} else if (len < 0) {
clipboard_source_unref(source);
clipboard->source = NULL;
} else {
source->contents.size += len;
}
return 1;
}
static int
writable_callback(int fd, uint32_t mask, void *data)
{
struct weston_wm *wm = data;
unsigned char *property;
int len, remainder;
property = xcb_get_property_value(wm->property_reply);
remainder = xcb_get_property_value_length(wm->property_reply) -
wm->property_start;
len = write(fd, property + wm->property_start, remainder);
if (len == -1) {
free(wm->property_reply);
wm->property_reply = NULL;
if (wm->property_source)
wl_event_source_remove(wm->property_source);
wm->property_source = NULL;
close(fd);
weston_log("write error to target fd: %m\n");
return 1;
}
weston_log("wrote %d (chunk size %d) of %d bytes\n",
wm->property_start + len,
len, xcb_get_property_value_length(wm->property_reply));
wm->property_start += len;
if (len == remainder) {
free(wm->property_reply);
wm->property_reply = NULL;
if (wm->property_source)
wl_event_source_remove(wm->property_source);
wm->property_source = NULL;
if (wm->incr) {
xcb_delete_property(wm->conn,
wm->selection_window,
wm->atom.wl_selection);
} else {
weston_log("transfer complete\n");
close(fd);
}
}
return 1;
}
WLC_API void
wlc_event_source_remove(struct wlc_event_source *source)
{
assert(source);
if (wlc.display)
wl_event_source_remove((struct wl_event_source*)source);
}
static void weston_dbus_unbind(DBusConnection *c, struct wl_event_source *ctx)
{
dbus_connection_set_timeout_functions(c, NULL, NULL, NULL,
NULL, NULL);
dbus_connection_set_watch_functions(c, NULL, NULL, NULL,
NULL, NULL);
dbus_connection_unref(c);
wl_event_source_remove(ctx);
}
static int weston_dbus_bind(struct wl_event_loop *loop, DBusConnection *c,
struct wl_event_source **ctx_out)
{
bool b;
int r, fd;
/* Idle events cannot reschedule themselves, therefore we use a dummy
* event-fd and mark it for post-dispatch. Hence, the dbus
* dispatcher is called after every dispatch-round.
* This is required as dbus doesn't allow dispatching events from
* within its own event sources. */
fd = eventfd(0, EFD_CLOEXEC);
if (fd < 0)
return -errno;
*ctx_out = wl_event_loop_add_fd(loop, fd, 0, weston_dbus_dispatch, c);
close(fd);
if (!*ctx_out)
return -ENOMEM;
wl_event_source_check(*ctx_out);
b = dbus_connection_set_watch_functions(c,
weston_dbus_add_watch,
weston_dbus_remove_watch,
weston_dbus_toggle_watch,
loop,
NULL);
if (!b) {
r = -ENOMEM;
goto error;
}
b = dbus_connection_set_timeout_functions(c,
weston_dbus_add_timeout,
weston_dbus_remove_timeout,
weston_dbus_toggle_timeout,
loop,
NULL);
if (!b) {
r = -ENOMEM;
goto error;
}
dbus_connection_ref(c);
return 0;
error:
dbus_connection_set_timeout_functions(c, NULL, NULL, NULL,
NULL, NULL);
dbus_connection_set_watch_functions(c, NULL, NULL, NULL,
NULL, NULL);
wl_event_source_remove(*ctx_out);
*ctx_out = NULL;
return r;
}
void swc_drm_finalize()
{
if (drm.global)
wl_global_destroy(drm.global);
wl_event_source_remove(drm.event_source);
wld_destroy_renderer(swc.drm->renderer);
wld_destroy_context(swc.drm->context);
close(swc.drm->fd);
}
void
weston_launcher_destroy(struct weston_launcher *launcher)
{
if (launcher->logind) {
weston_logind_destroy(launcher->logind);
} else if (launcher->fd != -1) {
close(launcher->fd);
wl_event_source_remove(launcher->source);
} else {
weston_launcher_restore(launcher);
wl_event_source_remove(launcher->vt_source);
}
if (launcher->tty >= 0)
close(launcher->tty);
free(launcher);
}
static void
headless_output_destroy(struct weston_output *output_base)
{
struct headless_output *output = (struct headless_output *) output_base;
wl_event_source_remove(output->finish_frame_timer);
free(output);
return;
}
static void
weston_xserver_shutdown(struct weston_xserver *wxs)
{
char path[256];
snprintf(path, sizeof path, "/tmp/.X%d-lock", wxs->display);
unlink(path);
snprintf(path, sizeof path, "/tmp/.X11-unix/X%d", wxs->display);
unlink(path);
if (wxs->process.pid == 0) {
wl_event_source_remove(wxs->abstract_source);
wl_event_source_remove(wxs->unix_source);
}
close(wxs->abstract_fd);
close(wxs->unix_fd);
if (wxs->wm)
weston_wm_destroy(wxs->wm);
wxs->loop = NULL;
}
static void weston_dbus_remove_timeout(DBusTimeout *timeout, void *data)
{
struct wl_event_source *s;
s = dbus_timeout_get_data(timeout);
if (!s)
return;
wl_event_source_remove(s);
}
static void weston_dbus_remove_watch(DBusWatch *watch, void *data)
{
struct wl_event_source *s;
s = dbus_watch_get_data(watch);
if (!s)
return;
wl_event_source_remove(s);
}
static int
free_source_callback(int fd, uint32_t mask, void *data)
{
struct free_source_context *context = data;
context->count++;
/* Remove other source */
if (fd == context->p1[0]) {
wl_event_source_remove(context->source2);
context->source2 = NULL;
} else if (fd == context->p2[0]) {
wl_event_source_remove(context->source1);
context->source1 = NULL;
} else {
assert(0);
}
return 1;
}
void DBusHandler::Callbacks::removeTimeout(DBusTimeout* timeout, void* data)
{
wl_event_source* s = (wl_event_source*) dbus_timeout_get_data(timeout);
if(!s)
{
ny::sendWarning("dbusRemoveTimeout: dbus timeout has no data");
return;
}
wl_event_source_remove(s);
}
void DBusHandler::Callbacks::removeWatch(DBusWatch* watch, void* data)
{
wl_event_source* s = nullptr;
if (!(s = (wl_event_source*) dbus_watch_get_data(watch)))
{
ny::sendWarning("dbusRemoveWatch: dbus watch has no data");
return;
}
wl_event_source_remove(s);
}
void idleSwitch(void* data)
{
if(!idleSwitchSource || !data || !vtSwitchTo) return;
auto* th = static_cast<iro::TerminalHandler*>(data);
th->activate(vtSwitchTo);
vtSwitchTo = 0;
wl_event_source_remove(idleSwitchSource);
idleSwitchSource = 0;
}
static bool
input_set_event_loop(struct wl_event_loop *loop)
{
if (input.event_source) {
wl_event_source_remove(input.event_source);
input.event_source = NULL;
}
if (input.handle && loop && !(input.event_source = wl_event_loop_add_fd(loop, libinput_get_fd(input.handle), WL_EVENT_READABLE, input_event, &input)))
return false;
return true;
}
WL_EXPORT void
wl_event_loop_dispatch_idle(struct wl_event_loop *loop)
{
struct wl_event_source_idle *source;
while (!wl_list_empty(&loop->idle_list)) {
source = container_of(loop->idle_list.next,
struct wl_event_source_idle, base.link);
source->func(source->base.data);
wl_event_source_remove(&source->base);
}
}
static int
handle_sigusr1(int signal_number, void *data)
{
struct weston_xserver *wxs = data;
/* We'd be safer if we actually had the struct
* signalfd_siginfo from the signalfd data and could verify
* this came from Xwayland.*/
wxs->wm = weston_wm_create(wxs, wxs->wm_fd);
wl_event_source_remove(wxs->sigusr1_source);
return 1;
}
static void
launcher_direct_destroy(struct weston_launcher *launcher_base)
{
struct launcher_direct *launcher = wl_container_of(launcher_base, launcher, base);
launcher_direct_restore(&launcher->base);
wl_event_source_remove(launcher->vt_source);
if (launcher->tty >= 0)
close(launcher->tty);
free(launcher);
}
X11Backend::~X11Backend()
{
for(auto& outp : outputs_)
destroyOutput(*outp);
if(eglContext_)
{
eglContext_->unbindWlDisplay(compositor_->wlDisplay());
eglContext_.reset();
}
if(inputEventSource_)wl_event_source_remove(inputEventSource_);
if(xDisplay_) XCloseDisplay(xDisplay_);
}
static void
weston_compositor_destroy_listener(struct wl_listener *listener, void *data)
{
struct systemd_notifier *notifier;
sd_notify(0, "STOPPING=1");
notifier = container_of(listener,
struct systemd_notifier,
compositor_destroy_listener);
if (notifier->watchdog_source)
wl_event_source_remove(notifier->watchdog_source);
wl_list_remove(¬ifier->compositor_destroy_listener.link);
free(notifier);
}
void
evdev_device_destroy(struct evdev_device *device)
{
struct evdev_dispatch *dispatch;
dispatch = device->dispatch;
if (dispatch)
dispatch->interface->destroy(dispatch);
wl_event_source_remove(device->source);
wl_list_remove(&device->link);
if (device->mtdev)
mtdev_close_delete(device->mtdev);
close(device->fd);
free(device->devname);
free(device->devnode);
free(device);
}
static void
clipboard_source_unref(struct clipboard_source *source)
{
char **s;
source->refcount--;
if (source->refcount > 0)
return;
if (source->event_source)
wl_event_source_remove(source->event_source);
wl_signal_emit(&source->base.resource.destroy_signal,
&source->base.resource);
s = source->base.mime_types.data;
free(*s);
wl_array_release(&source->base.mime_types);
wl_array_release(&source->contents);
free(source);
}
static dbus_bool_t weston_dbus_add_timeout(DBusTimeout *timeout, void *data)
{
struct wl_event_loop *loop = data;
struct wl_event_source *s;
int r;
s = wl_event_loop_add_timer(loop, weston_dbus_dispatch_timeout,
timeout);
if (!s)
return FALSE;
r = weston_dbus_adjust_timeout(timeout, s);
if (r < 0) {
wl_event_source_remove(s);
return FALSE;
}
dbus_timeout_set_data(timeout, s, NULL);
return TRUE;
}
static void
headless_output_destroy(struct weston_output *output_base)
{
struct headless_output *output = (struct headless_output *) output_base;
struct headless_backend *b =
(struct headless_backend *) output->base.compositor->backend;
wl_event_source_remove(output->finish_frame_timer);
if (b->use_pixman) {
pixman_renderer_output_destroy(&output->base);
pixman_image_unref(output->image);
free(output->image_buf);
}
weston_output_destroy(&output->base);
free(output);
return;
}
unsigned int DBusHandler::Callbacks::addTimeout(DBusTimeout* timeout, void* data)
{
if(!data) return 0;
auto& loop = static_cast<DBusHandler*>(data)->compositor().wlEventLoop();
wl_event_source* source;
if(!(source = wl_event_loop_add_timer(&loop, dispatchTimeout, timeout)))
{
ny::sendWarning("dbusAddTimeout: failed to add wl_event_loop_timer");
return 0;
}
if(adjustTimeout(timeout, source) < 0)
{
ny::sendWarning("dbusAddTimeout: failed to adjust timeout");
wl_event_source_remove(source);
return 0;
}
dbus_timeout_set_data(timeout, source, nullptr);
return true;
}
WaylandInputEvent::~WaylandInputEvent()
{
if (!m_wlEventSource)
wl_event_source_remove(m_wlEventSource);
if (m_xkbInfo.keymap)
xkb_map_unref(m_xkbInfo.keymap);
if (m_xkbInfo.keymap_area)
munmap(m_xkbInfo.keymap_area, m_xkbInfo.keymap_size);
if (m_xkbInfo.keymap_fd >= 0)
close(m_xkbInfo.keymap_fd);
xkb_context_unref(m_xkbContext);
free((char*)m_xkbNames.rules);
free((char*)m_xkbNames.model);
free((char*)m_xkbNames.layout);
free((char*)m_xkbNames.variant);
free((char*)m_xkbNames.options);
}
