Merge branch 'master' into feature/multiseat

backend/wayland/wl_seat.c

@@ -90,7 +90,7 @@ static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer,
 
 	struct wlr_event_pointer_axis wlr_event;
 	wlr_event.device = dev;
-	wlr_event.delta = value;
+	wlr_event.delta = wl_fixed_to_double(value);
 	wlr_event.orientation = axis;
 	wlr_event.time_msec = time;
 	wlr_event.source = wlr_wl_pointer->axis_source;

include/rootston/view.h

@@ -73,15 +73,19 @@ struct roots_view {
 	// elsewhere
 	void (*get_size)(struct roots_view *view, struct wlr_box *box);
 	void (*activate)(struct roots_view *view, bool active);
+	void (*move)(struct roots_view *view, double x, double y);
 	void (*resize)(struct roots_view *view, uint32_t width, uint32_t height);
-	void (*set_position)(struct roots_view *view, double x, double y);
+	void (*move_resize)(struct roots_view *view, double x, double y,
+		uint32_t width, uint32_t height);
 	void (*close)(struct roots_view *view);
 };
 
 void view_get_size(struct roots_view *view, struct wlr_box *box);
 void view_activate(struct roots_view *view, bool active);
+void view_move(struct roots_view *view, double x, double y);
 void view_resize(struct roots_view *view, uint32_t width, uint32_t height);
-void view_set_position(struct roots_view *view, double x, double y);
+void view_move_resize(struct roots_view *view, double x, double y,
+	uint32_t width, uint32_t height);
 void view_close(struct roots_view *view);
 bool view_center(struct roots_view *view);
 void view_setup(struct roots_view *view);

rootston/cursor.c

@@ -119,8 +119,8 @@ void cursor_update_position(struct roots_input *input, uint32_t time) {
 		if (input->active_view) {
 			double dx = input->cursor->x - input->offs_x;
 			double dy = input->cursor->y - input->offs_y;
-			view_set_position(input->active_view,
+			view_move(input->active_view, input->view_x + dx,
-				input->view_x + dx, input->view_y + dy);
+				input->view_y + dy);
 		}
 		break;
 	case ROOTS_CURSOR_RESIZE:
@@ -134,15 +134,19 @@ void cursor_update_position(struct roots_input *input, uint32_t time) {
 			if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_TOP) {
 				active_y = input->view_y + dy;
 				height -= dy;
+				if (height < 0) {
+					active_y += height;
 				}
-			if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_BOTTOM) {
+			} else if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_BOTTOM) {
 				height += dy;
 			}
 			if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_LEFT) {
 				active_x = input->view_x + dx;
 				width -= dx;
+				if (width < 0) {
+					active_x += width;
 				}
-			if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) {
+			} else if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) {
 				width += dx;
 			}
 
@@ -153,13 +157,14 @@ void cursor_update_position(struct roots_input *input, uint32_t time) {
 				height = 0;
 			}
 
-			// TODO we might need one configure event for this
 			if (active_x != input->active_view->x ||
 					active_y != input->active_view->y) {
-				view_set_position(input->active_view, active_x, active_y);
+				view_move_resize(input->active_view, active_x, active_y,
-			}
+					width, height);
+			} else {
 				view_resize(input->active_view, width, height);
 			}
+		}
 		break;
 	case ROOTS_CURSOR_ROTATE:
 		if (input->active_view) {

rootston/desktop.c

@@ -45,9 +45,15 @@ void view_get_size(struct roots_view *view, struct wlr_box *box) {
 	box->height = view->wlr_surface->current->height;
 }
 
-void view_set_position(struct roots_view *view, double x, double y) {
+void view_activate(struct roots_view *view, bool activate) {
-	if (view->set_position) {
+	if (view->activate) {
-		view->set_position(view, x, y);
+		view->activate(view, activate);
+	}
+}
+
+void view_move(struct roots_view *view, double x, double y) {
+	if (view->move) {
+		view->move(view, x, y);
 		return;
 	}
 
@@ -55,18 +61,23 @@ void view_set_position(struct roots_view *view, double x, double y) {
 	view->y = y;
 }
 
-void view_activate(struct roots_view *view, bool activate) {
-	if (view->activate) {
-		view->activate(view, activate);
-	}
-}
-
 void view_resize(struct roots_view *view, uint32_t width, uint32_t height) {
 	if (view->resize) {
 		view->resize(view, width, height);
 	}
 }
 
+void view_move_resize(struct roots_view *view, double x, double y,
+		uint32_t width, uint32_t height) {
+	if (view->move_resize) {
+		view->move_resize(view, x, y, width, height);
+		return;
+	}
+
+	view_move(view, x, y);
+	view_resize(view, width, height);
+}
+
 void view_close(struct roots_view *view) {
 	if (view->close) {
 		view->close(view);
@@ -101,7 +112,7 @@ bool view_center(struct roots_view *view) {
 	double view_x = (double)(width - size.width) / 2 + l_output->x;
 	double view_y = (double)(height - size.height) / 2 + l_output->y;
 
-	view_set_position(view, view_x, view_y);
+	view_move(view, view_x, view_y);
 
 	return true;
 }

rootston/wl_shell.c

@@ -120,7 +120,7 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
 			surface->parent);
 		if (i != -1) {
 			struct roots_view *parent = desktop->views->items[i];
-			view_set_position(view,
+			view_move(view,
 				parent->x + surface->transient_state->x,
 				parent->y + surface->transient_state->y);
 		}

rootston/xdg_shell_v6.c

@@ -25,27 +25,63 @@ static void activate(struct roots_view *view, bool active) {
 	}
 }
 
-static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
+static void apply_size_constraints(struct wlr_xdg_surface_v6 *surf,
-	assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
+		uint32_t width, uint32_t height, uint32_t *dest_width,
-	struct wlr_xdg_surface_v6 *surf = view->xdg_surface_v6;
+		uint32_t *dest_height) {
-	if (surf->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
+	*dest_width = width;
+	*dest_height = height;
+
 	struct wlr_xdg_toplevel_v6_state *state =
 		&surf->toplevel_state->current;
 	if (width < state->min_width) {
-			width = state->min_width;
+		*dest_width = state->min_width;
 	} else if (state->max_width > 0 &&
 			width > state->max_width) {
-			width = state->max_width;
+		*dest_width = state->max_width;
 	}
 	if (height < state->min_height) {
-			height = state->min_height;
+		*dest_height = state->min_height;
 	} else if (state->max_height > 0 &&
 			height > state->max_height) {
-			height = state->max_height;
+		*dest_height = state->max_height;
+	}
+}
+
+static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
+	assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
+	struct wlr_xdg_surface_v6 *surf = view->xdg_surface_v6;
+	if (surf->role != WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
+		return;
 	}
 
-		wlr_xdg_toplevel_v6_set_size(surf, width, height);
+	uint32_t contrained_width, contrained_height;
+	apply_size_constraints(surf, width, height, &contrained_width,
+		&contrained_height);
+
+	wlr_xdg_toplevel_v6_set_size(surf, contrained_width, contrained_height);
+}
+
+static void move_resize(struct roots_view *view, double x, double y,
+		uint32_t width, uint32_t height) {
+	assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
+	struct wlr_xdg_surface_v6 *surf = view->xdg_surface_v6;
+	if (surf->role != WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
+		return;
 	}
+
+	uint32_t contrained_width, contrained_height;
+	apply_size_constraints(surf, width, height, &contrained_width,
+		&contrained_height);
+
+	x = x + width - contrained_width;
+	y = y + height - contrained_height;
+
+	// TODO: we should wait for an ack_configure event before updating the
+	// position
+	view->x = x;
+	view->y = y;
+
+	wlr_xdg_toplevel_v6_set_size(surf, contrained_width, contrained_height);
 }
 
 static void close(struct roots_view *view) {
@@ -130,6 +166,10 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
 		&roots_surface->request_resize);
 
 	struct roots_view *view = calloc(1, sizeof(struct roots_view));
+	if (!view) {
+		free(roots_surface);
+		return;
+	}
 	view->type = ROOTS_XDG_SHELL_V6_VIEW;
 	view->xdg_surface_v6 = surface;
 	view->roots_xdg_surface_v6 = roots_surface;
@@ -137,6 +177,7 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
 	view->get_size = get_size;
 	view->activate = activate;
 	view->resize = resize;
+	view->move_resize = move_resize;
 	view->close = close;
 	view->desktop = desktop;
 	roots_surface->view = view;

rootston/xwayland.c

@@ -15,38 +15,69 @@ static void activate(struct roots_view *view, bool active) {
 	wlr_xwayland_surface_activate(xwayland, view->xwayland_surface, active);
 }
 
-static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
+static void move(struct roots_view *view, double x, double y) {
 	assert(view->type == ROOTS_XWAYLAND_VIEW);
 	struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
+	view->x = x;
+	view->y = y;
+	wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface,
+		x, y, xwayland_surface->width, xwayland_surface->height);
+}
+
+static void apply_size_constraints(
+		struct wlr_xwayland_surface *xwayland_surface, uint32_t width,
+		uint32_t height, uint32_t *dest_width, uint32_t *dest_height) {
+	*dest_width = width;
+	*dest_height = height;
 
 	struct wlr_xwayland_surface_size_hints *size_hints =
 		xwayland_surface->size_hints;
 	if (size_hints != NULL) {
 		if (width < (uint32_t)size_hints->min_width) {
-			width = size_hints->min_width;
+			*dest_width = size_hints->min_width;
 		} else if (size_hints->max_width > 0 &&
 				width > (uint32_t)size_hints->max_width) {
-			width = size_hints->max_width;
+			*dest_width = size_hints->max_width;
 		}
 		if (height < (uint32_t)size_hints->min_height) {
-			height = size_hints->min_height;
+			*dest_height = size_hints->min_height;
 		} else if (size_hints->max_height > 0 &&
 				height > (uint32_t)size_hints->max_height) {
-			height = size_hints->max_height;
+			*dest_height = size_hints->max_height;
 		}
 	}
+}
+
+static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
+	assert(view->type == ROOTS_XWAYLAND_VIEW);
+	struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
+
+	uint32_t contrained_width, contrained_height;
+	apply_size_constraints(xwayland_surface, width, height, &contrained_width,
+		&contrained_height);
 
 	wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface,
-		xwayland_surface->x, xwayland_surface->y, width, height);
+		xwayland_surface->x, xwayland_surface->y, contrained_width,
+		contrained_height);
 }
 
-static void set_position(struct roots_view *view, double x, double y) {
+static void move_resize(struct roots_view *view, double x, double y,
+		uint32_t width, uint32_t height) {
 	assert(view->type == ROOTS_XWAYLAND_VIEW);
 	struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
+
+	uint32_t contrained_width, contrained_height;
+	apply_size_constraints(xwayland_surface, width, height, &contrained_width,
+		&contrained_height);
+
+	x = x + width - contrained_width;
+	y = y + height - contrained_height;
+
 	view->x = x;
 	view->y = y;
+
 	wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface,
-		x, y, xwayland_surface->width, xwayland_surface->height);
+		x, y, contrained_width, contrained_height);
 }
 
 static void close(struct roots_view *view) {
@@ -204,7 +235,8 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
 	view->desktop = desktop;
 	view->activate = activate;
 	view->resize = resize;
-	view->set_position = set_position;
+	view->move = move;
+	view->move_resize = move_resize;
 	view->close = close;
 	roots_surface->view = view;
 	wlr_list_add(desktop->views, view);

types/wlr_compositor.c

@@ -13,10 +13,21 @@ static void destroy_surface_listener(struct wl_listener *listener, void *data) {
 static void wl_compositor_create_surface(struct wl_client *client,
 		struct wl_resource *resource, uint32_t id) {
 	struct wlr_compositor *compositor = wl_resource_get_user_data(resource);
+
 	struct wl_resource *surface_resource = wl_resource_create(client,
 		&wl_surface_interface, wl_resource_get_version(resource), id);
+	if (surface_resource == NULL) {
+		wl_resource_post_no_memory(resource);
+		return;
+	}
+
 	struct wlr_surface *surface = wlr_surface_create(surface_resource,
 		compositor->renderer);
+	if (surface == NULL) {
+		wl_resource_destroy(surface_resource);
+		wl_resource_post_no_memory(resource);
+		return;
+	}
 	surface->compositor_data = compositor;
 	surface->compositor_listener.notify = &destroy_surface_listener;
 	wl_resource_add_destroy_listener(surface_resource,
@@ -49,13 +60,17 @@ static void wl_compositor_destroy(struct wl_resource *resource) {
 	}
 }
 
-static void wl_compositor_bind(struct wl_client *wl_client, void *_compositor,
+static void wl_compositor_bind(struct wl_client *wl_client, void *data,
 		uint32_t version, uint32_t id) {
-	struct wlr_compositor *compositor = _compositor;
+	struct wlr_compositor *compositor = data;
 	assert(wl_client && compositor);
 
 	struct wl_resource *wl_resource =
 		wl_resource_create(wl_client, &wl_compositor_interface, version, id);
+	if (wl_resource == NULL) {
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
 	wl_resource_set_implementation(wl_resource, &wl_compositor_impl,
 		compositor, wl_compositor_destroy);
 	wl_list_insert(&compositor->wl_resources,

types/wlr_data_device.c

@@ -233,6 +233,9 @@ static struct wlr_data_offer *wlr_data_source_send_offer(
 		struct wlr_data_source *source,
 		struct wl_resource *target) {
 	struct wlr_data_offer *offer = calloc(1, sizeof(struct wlr_data_offer));
+	if (offer == NULL) {
+		return NULL;
+	}
 
 	offer->resource =
 		wl_resource_create(wl_resource_get_client(target),
@@ -781,9 +784,7 @@ data_device_manager_impl = {
 
 static void data_device_manager_bind(struct wl_client *client,
 		void *data, uint32_t version, uint32_t id) {
-	struct wl_resource *resource;
+	struct wl_resource *resource = wl_resource_create(client,
-
-	resource = wl_resource_create(client,
 		&wl_data_device_manager_interface,
 		version, id);
 	if (resource == NULL) {
@@ -791,8 +792,8 @@ static void data_device_manager_bind(struct wl_client *client,
 		return;
 	}
 
-	wl_resource_set_implementation(resource,
+	wl_resource_set_implementation(resource, &data_device_manager_impl,
-			&data_device_manager_impl, NULL, NULL);
+		NULL, NULL);
 }
 
 struct wlr_data_device_manager *wlr_data_device_manager_create(
@@ -807,7 +808,6 @@ struct wlr_data_device_manager *wlr_data_device_manager_create(
 	manager->global =
 		wl_global_create(display, &wl_data_device_manager_interface,
 			3, NULL, data_device_manager_bind);
-
 	if (!manager->global) {
 		wlr_log(L_ERROR, "could not create data device manager wl global");
 		free(manager);

types/wlr_gamma_control.c

@@ -83,8 +83,8 @@ static void gamma_control_manager_get_gamma_control(struct wl_client *client,
 	gamma_control->resource = wl_resource_create(client,
 		&gamma_control_interface, version, id);
 	if (gamma_control->resource == NULL) {
-		wl_client_post_no_memory(client);
 		free(gamma_control);
+		wl_client_post_no_memory(client);
 		return;
 	}
 	wlr_log(L_DEBUG, "new gamma_control %p (res %p)", gamma_control,
@@ -109,10 +109,9 @@ static struct gamma_control_manager_interface gamma_control_manager_impl = {
 	.get_gamma_control = gamma_control_manager_get_gamma_control,
 };
 
-static void gamma_control_manager_bind(struct wl_client *client,
+static void gamma_control_manager_bind(struct wl_client *client, void *data,
-		void *_gamma_control_manager, uint32_t version, uint32_t id) {
+		uint32_t version, uint32_t id) {
-	struct wlr_gamma_control_manager *gamma_control_manager =
+	struct wlr_gamma_control_manager *gamma_control_manager = data;
-		_gamma_control_manager;
 	assert(client && gamma_control_manager);
 
 	struct wl_resource *resource = wl_resource_create(client,

types/wlr_output.c

@@ -91,13 +91,17 @@ static struct wl_output_interface wl_output_impl = {
 	.release = wl_output_release
 };
 
-static void wl_output_bind(struct wl_client *wl_client, void *_wlr_output,
+static void wl_output_bind(struct wl_client *wl_client, void *data,
 		uint32_t version, uint32_t id) {
-	struct wlr_output *wlr_output = _wlr_output;
+	struct wlr_output *wlr_output = data;
 	assert(wl_client && wlr_output);
 
 	struct wl_resource *wl_resource = wl_resource_create(wl_client,
 		&wl_output_interface, version, id);
+	if (wl_resource == NULL) {
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
 	wl_resource_set_implementation(wl_resource, &wl_output_impl, wlr_output,
 		wl_output_destroy);
 	wl_list_insert(&wlr_output->wl_resources,

types/wlr_screenshooter.c

@@ -51,16 +51,17 @@ static void output_frame_notify(struct wl_listener *listener, void *_data) {
 }
 
 static void screenshooter_shoot(struct wl_client *client,
-		struct wl_resource *_screenshooter, uint32_t id,
+		struct wl_resource *screenshooter_resource, uint32_t id,
-		struct wl_resource *_output, struct wl_resource *_buffer) {
+		struct wl_resource *output_resource,
+		struct wl_resource *buffer_resource) {
 	struct wlr_screenshooter *screenshooter =
-		wl_resource_get_user_data(_screenshooter);
+		wl_resource_get_user_data(screenshooter_resource);
-	struct wlr_output *output = wl_resource_get_user_data(_output);
+	struct wlr_output *output = wl_resource_get_user_data(output_resource);
-	if (!wl_shm_buffer_get(_buffer)) {
+	if (!wl_shm_buffer_get(buffer_resource)) {
 		wlr_log(L_ERROR, "Invalid buffer: not a shared memory buffer");
 		return;
 	}
-	struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get(_buffer);
+	struct wl_shm_buffer *shm_buffer = wl_shm_buffer_get(buffer_resource);
 	int32_t width = wl_shm_buffer_get_width(shm_buffer);
 	int32_t height = wl_shm_buffer_get_height(shm_buffer);
 	int32_t stride = wl_shm_buffer_get_stride(shm_buffer);
@@ -84,23 +85,31 @@ static void screenshooter_shoot(struct wl_client *client,
 	struct wlr_screenshot *screenshot =
 		calloc(1, sizeof(struct wlr_screenshot));
 	if (!screenshot) {
-		wl_client_post_no_memory(client);
+		wl_resource_post_no_memory(screenshooter_resource);
 		return;
 	}
-	screenshot->output_resource = _output;
+	screenshot->output_resource = output_resource;
 	screenshot->output = output;
 	screenshot->screenshooter = screenshooter;
 	screenshot->resource = wl_resource_create(client,
-		&orbital_screenshot_interface, wl_resource_get_version(_screenshooter),
+		&orbital_screenshot_interface,
-		id);
+		wl_resource_get_version(screenshooter_resource), id);
-	wlr_log(L_DEBUG, "new screenshot %p (res %p)", screenshot,
+	if (screenshot->resource == NULL) {
-		screenshot->resource);
+		free(screenshot);
+		wl_resource_post_no_memory(screenshooter_resource);
+		return;
+	}
 	wl_resource_set_implementation(screenshot->resource, NULL, screenshot,
 		NULL);
 
+	wlr_log(L_DEBUG, "new screenshot %p (res %p)", screenshot,
+		screenshot->resource);
+
 	struct screenshot_state *state = calloc(1, sizeof(struct screenshot_state));
 	if (!state) {
-		wl_client_post_no_memory(client);
+		wl_resource_destroy(screenshot->resource);
+		free(screenshot);
+		wl_resource_post_no_memory(screenshooter_resource);
 		return;
 	}
 	state->width = width;
@@ -117,13 +126,17 @@ static struct orbital_screenshooter_interface screenshooter_impl = {
 	.shoot = screenshooter_shoot,
 };
 
-static void screenshooter_bind(struct wl_client *wl_client,
+static void screenshooter_bind(struct wl_client *wl_client, void *data,
-		void *_screenshooter, uint32_t version, uint32_t id) {
+		uint32_t version, uint32_t id) {
-	struct wlr_screenshooter *screenshooter = _screenshooter;
+	struct wlr_screenshooter *screenshooter = data;
 	assert(wl_client && screenshooter);
 
 	struct wl_resource *wl_resource = wl_resource_create(wl_client,
 		&orbital_screenshooter_interface, version, id);
+	if (wl_resource == NULL) {
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
 	wl_resource_set_implementation(wl_resource, &screenshooter_impl,
 		screenshooter, NULL);
 }
@@ -137,13 +150,12 @@ struct wlr_screenshooter *wlr_screenshooter_create(struct wl_display *display,
 	}
 	screenshooter->renderer = renderer;
 
-	struct wl_global *wl_global = wl_global_create(display,
+	screenshooter->wl_global = wl_global_create(display,
 		&orbital_screenshooter_interface, 1, screenshooter, screenshooter_bind);
-	if (!wl_global) {
+	if (screenshooter->wl_global == NULL) {
 		free(screenshooter);
 		return NULL;
 	}
-	screenshooter->wl_global = wl_global;
 
 	return screenshooter;
 }

types/wlr_seat.c

@@ -65,9 +65,9 @@ static void wl_pointer_destroy(struct wl_resource *resource) {
 }
 
 static void wl_seat_get_pointer(struct wl_client *client,
-		struct wl_resource *pointer_resource, uint32_t id) {
+		struct wl_resource *seat_resource, uint32_t id) {
 	struct wlr_seat_client *seat_client =
-		wl_resource_get_user_data(pointer_resource);
+		wl_resource_get_user_data(seat_resource);
 	if (!(seat_client->seat->capabilities & WL_SEAT_CAPABILITY_POINTER)) {
 		return;
 	}
@@ -78,7 +78,11 @@ static void wl_seat_get_pointer(struct wl_client *client,
 		wl_resource_destroy(seat_client->pointer);
 	}
 	seat_client->pointer = wl_resource_create(client, &wl_pointer_interface,
-		wl_resource_get_version(pointer_resource), id);
+		wl_resource_get_version(seat_resource), id);
+	if (seat_client->pointer == NULL) {
+		wl_resource_post_no_memory(seat_resource);
+		return;
+	}
 	wl_resource_set_implementation(seat_client->pointer, &wl_pointer_impl,
 		seat_client, &wl_pointer_destroy);
 }
@@ -126,6 +130,10 @@ static void wl_seat_get_keyboard(struct wl_client *client,
 	}
 	seat_client->keyboard = wl_resource_create(client, &wl_keyboard_interface,
 		wl_resource_get_version(seat_resource), id);
+	if (seat_client->keyboard == NULL) {
+		wl_resource_post_no_memory(seat_resource);
+		return;
+	}
 	wl_resource_set_implementation(seat_client->keyboard, &wl_keyboard_impl,
 		seat_client, &wl_keyboard_destroy);
 
@@ -162,6 +170,10 @@ static void wl_seat_get_touch(struct wl_client *client,
 	}
 	seat_client->touch = wl_resource_create(client, &wl_touch_interface,
 		wl_resource_get_version(seat_resource), id);
+	if (seat_client->touch == NULL) {
+		wl_resource_post_no_memory(seat_resource);
+		return;
+	}
 	wl_resource_set_implementation(seat_client->touch, &wl_touch_impl,
 		seat_client, &wl_touch_destroy);
 }
@@ -213,6 +225,11 @@ static void wl_seat_bind(struct wl_client *client, void *_wlr_seat,
 	}
 	seat_client->wl_resource =
 		wl_resource_create(client, &wl_seat_interface, version, id);
+	if (seat_client->wl_resource == NULL) {
+		free(seat_client);
+		wl_client_post_no_memory(client);
+		return;
+	}
 	seat_client->client = client;
 	seat_client->seat = wlr_seat;
 	wl_resource_set_implementation(seat_client->wl_resource, &wl_seat_impl,

types/wlr_server_decoration.c

@@ -73,8 +73,8 @@ static void server_decoration_manager_handle_create(struct wl_client *client,
 	decoration->resource = wl_resource_create(client,
 		&org_kde_kwin_server_decoration_interface, version, id);
 	if (decoration->resource == NULL) {
-		wl_client_post_no_memory(client);
 		free(decoration);
+		wl_client_post_no_memory(client);
 		return;
 	}
 	wl_resource_set_implementation(decoration->resource,
@@ -120,9 +120,9 @@ void server_decoration_manager_destroy_resource(struct wl_resource *resource) {
 	wl_list_remove(wl_resource_get_link(resource));
 }
 
-static void server_decoration_manager_bind(struct wl_client *client,
+static void server_decoration_manager_bind(struct wl_client *client, void *data,
-		void *_manager, uint32_t version, uint32_t id) {
+		uint32_t version, uint32_t id) {
-	struct wlr_server_decoration_manager *manager = _manager;
+	struct wlr_server_decoration_manager *manager = data;
 	assert(client && manager);
 
 	struct wl_resource *resource = wl_resource_create(client,

types/wlr_surface.c

@@ -819,14 +819,21 @@ static void subsurface_handle_parent_destroy(struct wl_listener *listener,
 
 void wlr_surface_make_subsurface(struct wlr_surface *surface,
 		struct wlr_surface *parent, uint32_t id) {
+	struct wl_client *client = wl_resource_get_client(surface->resource);
 	assert(surface->subsurface == NULL);
 
 	struct wlr_subsurface *subsurface =
 		calloc(1, sizeof(struct wlr_subsurface));
 	if (!subsurface) {
+		wl_client_post_no_memory(client);
 		return;
 	}
 	subsurface->cached = wlr_surface_state_create();
+	if (subsurface->cached == NULL) {
+		free(subsurface);
+		wl_client_post_no_memory(client);
+		return;
+	}
 	subsurface->synchronized = true;
 	subsurface->surface = surface;
 
@@ -840,10 +847,14 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface,
 	wl_list_insert(&parent->subsurface_pending_list,
 		&subsurface->parent_pending_link);
 
-	struct wl_client *client = wl_resource_get_client(surface->resource);
-
 	subsurface->resource =
 		wl_resource_create(client, &wl_subsurface_interface, 1, id);
+	if (subsurface->resource == NULL) {
+		wlr_surface_state_destroy(subsurface->cached);
+		free(subsurface);
+		wl_client_post_no_memory(client);
+		return;
+	}
 
 	wl_resource_set_implementation(subsurface->resource,
 		&subsurface_implementation, subsurface,

types/wlr_wl_shell.c

@@ -506,19 +506,19 @@ static int shell_surface_ping_timeout(void *user_data) {
 }
 
 static void shell_protocol_get_shell_surface(struct wl_client *client,
-		struct wl_resource *resource, uint32_t id,
+		struct wl_resource *shell_resource, uint32_t id,
 		struct wl_resource *surface_resource) {
 	struct wlr_surface *surface = wl_resource_get_user_data(surface_resource);
 	if (wlr_surface_set_role(surface, wlr_wl_shell_surface_role,
-			resource, WL_SHELL_ERROR_ROLE)) {
+			shell_resource, WL_SHELL_ERROR_ROLE)) {
 		return;
 	}
 
-	struct wlr_wl_shell *wl_shell = wl_resource_get_user_data(resource);
+	struct wlr_wl_shell *wl_shell = wl_resource_get_user_data(shell_resource);
 	struct wlr_wl_shell_surface *wl_surface =
 		calloc(1, sizeof(struct wlr_wl_shell_surface));
 	if (wl_surface == NULL) {
-		wl_client_post_no_memory(client);
+		wl_resource_post_no_memory(shell_resource);
 		return;
 	}
 	wl_list_init(&wl_surface->grab_link);
@@ -530,13 +530,20 @@ static void shell_protocol_get_shell_surface(struct wl_client *client,
 	wl_surface->surface = surface;
 
 	wl_surface->resource = wl_resource_create(client,
-		&wl_shell_surface_interface, wl_resource_get_version(resource), id);
+		&wl_shell_surface_interface, wl_resource_get_version(shell_resource),
-	wlr_log(L_DEBUG, "new wl_shell %p (res %p)", wl_surface,
+		id);
-		wl_surface->resource);
+	if (wl_surface->resource == NULL) {
+		free(wl_surface);
+		wl_resource_post_no_memory(shell_resource);
+		return;
+	}
 	wl_resource_set_implementation(wl_surface->resource,
 		&shell_surface_impl, wl_surface,
 		shell_surface_resource_destroy);
 
+	wlr_log(L_DEBUG, "new wl_shell %p (res %p)", wl_surface,
+		wl_surface->resource);
+
 	wl_signal_init(&wl_surface->events.destroy);
 	wl_signal_init(&wl_surface->events.ping_timeout);
 	wl_signal_init(&wl_surface->events.request_move);
@@ -574,13 +581,17 @@ static void shell_destroy(struct wl_resource *resource) {
 	wl_list_remove(wl_resource_get_link(resource));
 }
 
-static void shell_bind(struct wl_client *wl_client, void *_wl_shell,
+static void shell_bind(struct wl_client *wl_client, void *data,
 		uint32_t version, uint32_t id) {
-	struct wlr_wl_shell *wl_shell = _wl_shell;
+	struct wlr_wl_shell *wl_shell = data;
 	assert(wl_client && wl_shell);
 
 	struct wl_resource *wl_resource = wl_resource_create(wl_client,
 		&wl_shell_interface, version, id);
+	if (wl_resource == NULL) {
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
 	wl_resource_set_implementation(wl_resource, &shell_impl, wl_shell,
 		shell_destroy);
 	wl_list_insert(&wl_shell->wl_resources, wl_resource_get_link(wl_resource));

types/wlr_xdg_shell_v6.c

@@ -343,8 +343,8 @@ static void xdg_shell_create_positioner(struct wl_client *wl_client,
 		wl_resource_get_version(resource),
 		id);
 	if (positioner->resource == NULL) {
-		wl_client_post_no_memory(wl_client);
 		free(positioner);
+		wl_client_post_no_memory(wl_client);
 		return;
 	}
 
@@ -486,7 +486,7 @@ static void xdg_surface_get_popup(struct wl_client *client,
 
 	surface->popup_state = calloc(1, sizeof(struct wlr_xdg_popup_v6));
 	if (!surface->popup_state) {
-		wl_client_post_no_memory(client);
+		wl_resource_post_no_memory(resource);
 		return;
 	}
 
@@ -495,6 +495,7 @@ static void xdg_surface_get_popup(struct wl_client *client,
 			wl_resource_get_version(resource), id);
 	if (surface->popup_state->resource == NULL) {
 		free(surface->popup_state);
+		wl_resource_post_no_memory(resource);
 		return;
 	}
 
@@ -735,7 +736,7 @@ static void xdg_surface_get_toplevel(struct wl_client *client,
 
 	surface->toplevel_state = calloc(1, sizeof(struct wlr_xdg_toplevel_v6));
 	if (surface->toplevel_state == NULL) {
-		wl_client_post_no_memory(client);
+		wl_resource_post_no_memory(resource);
 		return;
 	}
 
@@ -744,6 +745,11 @@ static void xdg_surface_get_toplevel(struct wl_client *client,
 
 	struct wl_resource *toplevel_resource = wl_resource_create(client,
 		&zxdg_toplevel_v6_interface, wl_resource_get_version(resource), id);
+	if (toplevel_resource == NULL) {
+		free(surface->toplevel_state);
+		wl_resource_post_no_memory(resource);
+		return;
+	}
 
 	surface->toplevel_state->resource = toplevel_resource;
 
@@ -1118,9 +1124,20 @@ static void xdg_shell_get_xdg_surface(struct wl_client *wl_client,
 	surface->resource = wl_resource_create(wl_client,
 		&zxdg_surface_v6_interface, wl_resource_get_version(client_resource),
 		id);
+	if (surface->resource == NULL) {
+		free(surface->next_geometry);
+		free(surface->geometry);
+		free(surface);
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
 
 	if (wlr_surface_has_buffer(surface->surface)) {
-		wl_resource_post_error(surface->resource,
+		wl_resource_destroy(surface->resource);
+		free(surface->next_geometry);
+		free(surface->geometry);
+		free(surface);
+		wl_resource_post_error(surface_resource,
 			ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER,
 			"xdg_surface must not have a buffer at creation");
 		return;
@@ -1199,9 +1216,9 @@ static int wlr_xdg_client_v6_ping_timeout(void *user_data) {
 	return 1;
 }
 
-static void xdg_shell_bind(struct wl_client *wl_client, void *_xdg_shell,
+static void xdg_shell_bind(struct wl_client *wl_client, void *data,
 		uint32_t version, uint32_t id) {
-	struct wlr_xdg_shell_v6 *xdg_shell = _xdg_shell;
+	struct wlr_xdg_shell_v6 *xdg_shell = data;
 	assert(wl_client && xdg_shell);
 
 	struct wlr_xdg_client_v6 *client =
@@ -1215,6 +1232,11 @@ static void xdg_shell_bind(struct wl_client *wl_client, void *_xdg_shell,
 
 	client->resource =
 		wl_resource_create(wl_client, &zxdg_shell_v6_interface, version, id);
+	if (client->resource == NULL) {
+		free(client);
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
 	client->client = wl_client;
 	client->shell = xdg_shell;