Initial commit.
This has the basic event loop, and a first cut of the libffi dispatcher.
This commit is contained in:
Kristian Høgsberg
commit
97f1ebe8d5
|
|
@ -0,0 +1,17 @@
|
|||
CFLAGS = -Wall -g $(shell pkg-config --cflags libffi)
|
||||
LDLIBS = $(shell pkg-config --libs libffi)
|
||||
|
||||
all : wayland client
|
||||
|
||||
wayland_objs = wayland.o event-loop.o hash.o
|
||||
|
||||
wayland : $(wayland_objs)
|
||||
gcc -o $@ $(wayland_objs) $(LDLIBS)
|
||||
|
||||
client_objs = client.o
|
||||
|
||||
client : $(client_objs)
|
||||
gcc -o $@ $(client_objs)
|
||||
|
||||
clean :
|
||||
rm client wayland *.o
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
|
||||
KEYWORDS:
|
||||
|
||||
Wayland is a nano display server, relying on drm modesetting, gem
|
||||
batchbuffer submission and hw initialization generally in the
|
||||
kernel. Wayland is compositing manager and display server in one
|
||||
process. window management is largely pushed to the clients, they
|
||||
draw their own decorations and move and resize themselves,
|
||||
typically implemented in a library. more of the core desktop could
|
||||
be pushed into wayland, for example, stock desktop components such
|
||||
as the panel or the desktop background.
|
||||
|
||||
It is still designed with a windowed type of desktop in mind, as
|
||||
opposed to fullscreen-all-the-time type of interface.
|
||||
|
||||
Current trends goes towards less and less rendering in X server,
|
||||
more hardware setup and management in kernel and shared libraries
|
||||
allow code sharing without putting it all in a server.
|
||||
|
||||
Client allocates DRM buffers, draws decorations, and full window
|
||||
contents and posts entire thing to server along with dimensions.
|
||||
|
||||
Everything is direct rendered and composited. No cliprects, no
|
||||
drawing api/protocl between server and client. No
|
||||
pixmaps/windows/drawables, only surfaces (essentially pixmaps). No
|
||||
gcs/fonts, no nested windows. OpenGL is already direct rendered,
|
||||
pixman may be direct rendered which adds the cairo API, or cairo
|
||||
may gain a GL backend.
|
||||
|
||||
ISSUES:
|
||||
|
||||
Include panel and desktop background in wayland?
|
||||
|
||||
How does clients move their surfaces? set a full tri-mesh every time?
|
||||
|
||||
How does the server apply transformations to a surface behind the
|
||||
clients back? (wobbly, minimize, zoom) Maybe wobble is client side?
|
||||
|
||||
How do apps share the glyph cache?
|
||||
|
||||
Input handling - keyboard focus, multiple input devices, multiple
|
||||
pointers, multi touch.
|
||||
|
||||
Drawing cursors, moving them, cursor themes, attaching surfaces to
|
||||
cursors. How do you change cursors when you mouse over a text
|
||||
field if you don't have subwindows?
|
||||
|
||||
synaptics, 3-button emulation, xkb, scim
|
||||
|
||||
RMI
|
||||
|
||||
the get_interface method is called on an object to get an object
|
||||
handle that implements the specified interface.
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/un.h>
|
||||
#include <ctype.h>
|
||||
|
||||
static const char socket_name[] = "\0wayland";
|
||||
|
||||
struct method {
|
||||
const char *name;
|
||||
uint32_t opcode;
|
||||
};
|
||||
|
||||
static const struct method display_methods[] = {
|
||||
{ "get_interface", 0 },
|
||||
{ "create_surface", 1 },
|
||||
{ NULL }
|
||||
};
|
||||
|
||||
static const struct method surface_methods[] = {
|
||||
{ "get_interface", 0 },
|
||||
{ "post", 1 },
|
||||
{ NULL }
|
||||
};
|
||||
|
||||
struct interface {
|
||||
const char *name;
|
||||
const struct method *methods;
|
||||
};
|
||||
|
||||
static const struct interface interfaces[] = {
|
||||
{ "display", display_methods },
|
||||
{ "surface", surface_methods },
|
||||
{ NULL },
|
||||
};
|
||||
|
||||
int send_request(int sock, const char *buffer, int buffer_len)
|
||||
{
|
||||
const struct method *methods;
|
||||
char interface[32], method[32];
|
||||
uint32_t request[3], id, new_id;
|
||||
int i;
|
||||
|
||||
if (sscanf(buffer, "%d/%32[^:]:%32s %d\n",
|
||||
&id, interface, method, &new_id) != 4) {
|
||||
printf("invalid input, expected <id>/<interface>:<method>\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
printf("got object id %d, interface \"%s\", name \"%s\"\n",
|
||||
id, interface, method);
|
||||
|
||||
for (i = 0; interfaces[i].name != NULL; i++) {
|
||||
if (strcmp(interfaces[i].name, interface) == 0)
|
||||
break;
|
||||
}
|
||||
if (interfaces[i].name == NULL) {
|
||||
printf("unknown interface \"%s\"\n", interface);
|
||||
return -1;
|
||||
}
|
||||
|
||||
methods = interfaces[i].methods;
|
||||
for (i = 0; methods[i].name != NULL; i++) {
|
||||
if (strcmp(methods[i].name, method) == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
if (methods[i].name == NULL) {
|
||||
printf("unknown request \"%s\"\n", method);
|
||||
return -1;
|
||||
}
|
||||
|
||||
request[0] = id;
|
||||
request[1] = methods[i].opcode;
|
||||
request[2] = new_id;
|
||||
|
||||
return write(sock, request, sizeof request);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
struct sockaddr_un name;
|
||||
socklen_t size;
|
||||
int sock, len;
|
||||
char buffer[256];
|
||||
|
||||
sock = socket(PF_LOCAL, SOCK_STREAM, 0);
|
||||
if (sock < 0)
|
||||
return -1;
|
||||
|
||||
name.sun_family = AF_LOCAL;
|
||||
memcpy(name.sun_path, socket_name, sizeof socket_name);
|
||||
|
||||
size = offsetof (struct sockaddr_un, sun_path) + sizeof socket_name;
|
||||
|
||||
if (connect (sock, (struct sockaddr *) &name, size) < 0)
|
||||
return -1;
|
||||
|
||||
while (len = read(STDIN_FILENO, buffer, sizeof buffer), len > 0)
|
||||
if (send_request(sock, buffer, len) < 0)
|
||||
break;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/un.h>
|
||||
#include <sys/epoll.h>
|
||||
#include <unistd.h>
|
||||
#include "wayland.h"
|
||||
|
||||
struct wl_event_loop {
|
||||
int epoll_fd;
|
||||
};
|
||||
|
||||
struct wl_event_source {
|
||||
int fd;
|
||||
wl_event_loop_func_t func;
|
||||
void *data;
|
||||
};
|
||||
|
||||
struct wl_event_source *
|
||||
wl_event_loop_add_fd(struct wl_event_loop *loop,
|
||||
int fd, uint32_t mask,
|
||||
wl_event_loop_func_t func,
|
||||
void *data)
|
||||
{
|
||||
struct wl_event_source *source;
|
||||
struct epoll_event ep;
|
||||
|
||||
source = malloc(sizeof *source);
|
||||
source->fd = fd;
|
||||
source->func = func;
|
||||
source->data = data;
|
||||
|
||||
ep.events = 0;
|
||||
if (mask & WL_EVENT_READABLE)
|
||||
ep.events |= EPOLLIN;
|
||||
if (mask & WL_EVENT_WRITEABLE)
|
||||
ep.events |= EPOLLOUT;
|
||||
ep.data.ptr = source;
|
||||
|
||||
if (epoll_ctl(loop->epoll_fd, EPOLL_CTL_ADD, fd, &ep) < 0) {
|
||||
free(source);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return source;
|
||||
}
|
||||
|
||||
int
|
||||
wl_event_loop_remove_source(struct wl_event_loop *loop,
|
||||
struct wl_event_source *source)
|
||||
{
|
||||
int fd;
|
||||
|
||||
fd = source->fd;
|
||||
free(source);
|
||||
|
||||
return epoll_ctl(loop->epoll_fd, EPOLL_CTL_DEL, fd, NULL);
|
||||
}
|
||||
|
||||
struct wl_event_loop *
|
||||
wl_event_loop_create(void)
|
||||
{
|
||||
struct wl_event_loop *loop;
|
||||
|
||||
loop = malloc(sizeof *loop);
|
||||
if (loop == NULL)
|
||||
return NULL;
|
||||
|
||||
loop->epoll_fd = epoll_create(16);
|
||||
if (loop->epoll_fd < 0) {
|
||||
free(loop);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return loop;
|
||||
}
|
||||
|
||||
void
|
||||
wl_event_loop_destroy(struct wl_event_loop *loop)
|
||||
{
|
||||
close(loop->epoll_fd);
|
||||
free(loop);
|
||||
}
|
||||
|
||||
#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
|
||||
|
||||
int
|
||||
wl_event_loop_wait(struct wl_event_loop *loop)
|
||||
{
|
||||
struct epoll_event ep[32];
|
||||
struct wl_event_source *source;
|
||||
int i, count;
|
||||
|
||||
count = epoll_wait(loop->epoll_fd, ep, ARRAY_LENGTH(ep), -1);
|
||||
if (count < 0)
|
||||
return -1;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
source = ep[i].data.ptr;
|
||||
source->func(source->fd, ep[i].events, source->data);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <stdlib.h>
|
||||
#include "wayland.h"
|
||||
|
||||
int wl_hash_insert(struct wl_hash *hash, struct wl_object *object)
|
||||
{
|
||||
struct wl_object **objects;
|
||||
uint32_t alloc;
|
||||
|
||||
if (hash->count == hash->alloc) {
|
||||
if (hash->alloc == 0)
|
||||
alloc = 16;
|
||||
else
|
||||
alloc = hash->alloc * 2;
|
||||
objects = realloc(hash->objects, alloc * sizeof *objects);
|
||||
if (objects == NULL)
|
||||
return -1;
|
||||
|
||||
hash->objects = objects;
|
||||
hash->alloc = alloc;
|
||||
}
|
||||
|
||||
hash->objects[hash->count] = object;
|
||||
hash->count++;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct wl_object *
|
||||
wl_hash_lookup(struct wl_hash *hash, uint32_t id)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < hash->count; i++) {
|
||||
if (hash->objects[i]->id == id)
|
||||
return hash->objects[i];
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
wl_hash_delete(struct wl_hash *hash, struct wl_object *object)
|
||||
{
|
||||
/* writeme */
|
||||
}
|
||||
|
|
@ -0,0 +1,423 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/un.h>
|
||||
#include <ffi.h>
|
||||
#include "wayland.h"
|
||||
|
||||
#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
|
||||
|
||||
struct wl_region {
|
||||
};
|
||||
|
||||
struct wl_client {
|
||||
char protocol_buffer[4096];
|
||||
struct wl_event_source *source;
|
||||
struct wl_display *display;
|
||||
};
|
||||
|
||||
struct wl_display {
|
||||
struct wl_object base;
|
||||
struct wl_event_loop *loop;
|
||||
struct wl_hash objects;
|
||||
};
|
||||
|
||||
struct wl_surface {
|
||||
struct wl_object base;
|
||||
|
||||
/* provided by client */
|
||||
int width, height;
|
||||
int buffer;
|
||||
int stride;
|
||||
|
||||
/* these are used by the wayland server, not set from client */
|
||||
void (*screen_to_surface)(int sx, int sy, int *wx, int *wy);
|
||||
void (*surface_to_screen)(int sx, int sy, int *wx, int *wy);
|
||||
|
||||
/* how to convert buffer contents to pixels in screen format;
|
||||
* yuv->rgb, indexed->rgb, svg->rgb, but mostly just rgb->rgb. */
|
||||
|
||||
/* how to transform/render rectangular contents to polygons. */
|
||||
};
|
||||
|
||||
static void
|
||||
wl_surface_get_interface(struct wl_client *client,
|
||||
struct wl_surface *surface,
|
||||
const char *interface, uint32_t id)
|
||||
{
|
||||
/* client sends a new object id, and an interface identifier
|
||||
* to name the object that implements the interface */
|
||||
printf("surface::get_interface\n");
|
||||
}
|
||||
|
||||
static const struct wl_argument get_interface_arguments[] = {
|
||||
{ WL_ARGUMENT_STRING },
|
||||
{ WL_ARGUMENT_NEW_ID }
|
||||
};
|
||||
|
||||
static void
|
||||
wl_surface_post(struct wl_client *client,
|
||||
struct wl_surface *surface, uint32_t name,
|
||||
uint32_t width, uint32_t height, uint32_t stride)
|
||||
{
|
||||
printf("surface::post\n");
|
||||
}
|
||||
|
||||
static const struct wl_argument post_arguments[] = {
|
||||
{ WL_ARGUMENT_UINT32 },
|
||||
{ WL_ARGUMENT_UINT32 },
|
||||
{ WL_ARGUMENT_UINT32 },
|
||||
{ WL_ARGUMENT_UINT32 },
|
||||
};
|
||||
|
||||
void
|
||||
wl_surface_update(struct wl_surface *surface,
|
||||
uint32_t source_name, struct wl_region *region)
|
||||
{
|
||||
/* FIXME: how to demarshal region? */
|
||||
/* copy region from buffer into current window contents. */
|
||||
}
|
||||
|
||||
static const struct wl_argument update_arguments[] = {
|
||||
{ WL_ARGUMENT_UINT32 },
|
||||
{ WL_ARGUMENT_UINT32 },
|
||||
};
|
||||
|
||||
static const struct wl_method surface_methods[] = {
|
||||
{ "get_interface", wl_surface_get_interface,
|
||||
ARRAY_LENGTH(get_interface_arguments), get_interface_arguments },
|
||||
{ "post", wl_surface_post,
|
||||
ARRAY_LENGTH(post_arguments), post_arguments }
|
||||
};
|
||||
|
||||
static const struct wl_interface surface_interface = {
|
||||
"surface", 1,
|
||||
ARRAY_LENGTH(surface_methods),
|
||||
surface_methods,
|
||||
};
|
||||
|
||||
struct wl_surface *
|
||||
wl_surface_create(struct wl_display *display, uint32_t id)
|
||||
{
|
||||
struct wl_surface *surface;
|
||||
|
||||
surface = malloc(sizeof *surface);
|
||||
if (surface == NULL)
|
||||
return NULL;
|
||||
|
||||
surface->base.id = id;
|
||||
surface->base.interface = &surface_interface;
|
||||
/* doesn't create any pixel buffers, just the wl_surface
|
||||
* object. the client allocates and attaches pixel buffers
|
||||
* itself and renders to them, then posts them using
|
||||
* wl_window_post. */
|
||||
|
||||
/* add to display list */
|
||||
|
||||
return surface;
|
||||
}
|
||||
|
||||
static void
|
||||
wl_client_data(int fd, uint32_t mask, void *data);
|
||||
|
||||
struct wl_client *
|
||||
wl_client_create(struct wl_display *display, int fd)
|
||||
{
|
||||
struct wl_client *client;
|
||||
|
||||
client = malloc(sizeof *client);
|
||||
if (client == NULL)
|
||||
return NULL;
|
||||
|
||||
client->display = display;
|
||||
|
||||
client->source = wl_event_loop_add_fd(display->loop, fd,
|
||||
WL_EVENT_READABLE |
|
||||
WL_EVENT_READABLE,
|
||||
wl_client_data, client);
|
||||
|
||||
printf("new client: %p\n", client);
|
||||
|
||||
/* Send global objects to client in hand shake response, eg:
|
||||
*
|
||||
* display: 0,
|
||||
* glyph_cache: 1
|
||||
* some other extension global object: 2
|
||||
*
|
||||
* etc */
|
||||
|
||||
return client;
|
||||
}
|
||||
|
||||
void
|
||||
wl_client_destroy(struct wl_client *client)
|
||||
{
|
||||
printf("disconnect from client %p\n", client);
|
||||
wl_event_loop_remove_source(client->display->loop, client->source);
|
||||
free(client);
|
||||
}
|
||||
|
||||
static void
|
||||
demarshal(struct wl_client *client, struct wl_object *target,
|
||||
const struct wl_method *method, uint32_t *data, int len)
|
||||
{
|
||||
ffi_type *types[10];
|
||||
ffi_cif cif;
|
||||
uint32_t *p, result;
|
||||
int i;
|
||||
union {
|
||||
uint32_t uint32;
|
||||
const char *string;
|
||||
void *object;
|
||||
uint32_t new_id;
|
||||
} values[10];
|
||||
void *args[10];
|
||||
struct wl_object *object;
|
||||
|
||||
if (method->argument_count > ARRAY_LENGTH(types)) {
|
||||
printf("too many args (%d)\n", method->argument_count);
|
||||
return;
|
||||
}
|
||||
|
||||
types[0] = &ffi_type_pointer;
|
||||
values[0].object = client;
|
||||
args[0] = &values[0];
|
||||
|
||||
types[1] = &ffi_type_pointer;
|
||||
values[1].object = target;
|
||||
args[1] = &values[1];
|
||||
|
||||
p = data;
|
||||
for (i = 0; i < method->argument_count; i++) {
|
||||
switch (method->arguments[i].type) {
|
||||
case WL_ARGUMENT_UINT32:
|
||||
types[i + 2] = &ffi_type_uint32;
|
||||
values[i + 2].uint32 = *p;
|
||||
printf("got uint32 (%d)\n", *p);
|
||||
p++;
|
||||
break;
|
||||
case WL_ARGUMENT_STRING:
|
||||
printf("got string\n");
|
||||
types[i + 2] = &ffi_type_pointer;
|
||||
/* FIXME */
|
||||
values[i + 2].uint32 = *p++;
|
||||
break;
|
||||
case WL_ARGUMENT_OBJECT:
|
||||
types[i + 2] = &ffi_type_pointer;
|
||||
object = wl_hash_lookup(&client->display->objects, *p);
|
||||
if (object == NULL)
|
||||
printf("unknown object (%d)\n", *p);
|
||||
if (object->interface != method->arguments[i].data)
|
||||
printf("wrong object type\n");
|
||||
values[i + 2].object = object;
|
||||
printf("got object (%d)\n", *p);
|
||||
p++;
|
||||
break;
|
||||
case WL_ARGUMENT_NEW_ID:
|
||||
types[i + 2] = &ffi_type_uint32;
|
||||
values[i + 2].new_id = *p;
|
||||
object = wl_hash_lookup(&client->display->objects, *p);
|
||||
if (object != NULL)
|
||||
printf("object already exists (%d)\n", *p);
|
||||
printf("got new_id (%d)\n", *p);
|
||||
p++;
|
||||
break;
|
||||
default:
|
||||
printf("unknown type\n");
|
||||
break;
|
||||
}
|
||||
args[i + 2] = &values[i + 2];
|
||||
}
|
||||
|
||||
ffi_prep_cif(&cif, FFI_DEFAULT_ABI, method->argument_count + 2,
|
||||
&ffi_type_uint32, types);
|
||||
ffi_call(&cif, FFI_FN(method->func), &result, args);
|
||||
}
|
||||
|
||||
static void
|
||||
wl_client_data(int fd, uint32_t mask, void *data)
|
||||
{
|
||||
struct wl_client *client = data;
|
||||
struct wl_object *object;
|
||||
const struct wl_method *method;
|
||||
char buffer[256];
|
||||
uint32_t *p;
|
||||
int len;
|
||||
|
||||
if (mask & WL_EVENT_READABLE) {
|
||||
len = read(fd, buffer, sizeof buffer);
|
||||
if (len == 0) {
|
||||
wl_client_destroy(client);
|
||||
} else {
|
||||
printf("got %d bytes from client %p\n",
|
||||
len, client);
|
||||
if (len < 2 * sizeof *p)
|
||||
/* read more... */
|
||||
return;
|
||||
|
||||
p = (uint32_t *) buffer;
|
||||
object = wl_hash_lookup(&client->display->objects,
|
||||
p[0]);
|
||||
if (object == NULL) {
|
||||
/* send error */
|
||||
printf("invalid object\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (p[1] >= object->interface->method_count) {
|
||||
/* send error */
|
||||
printf("invalid method\n");
|
||||
return;
|
||||
}
|
||||
|
||||
method = &object->interface->methods[p[1]];
|
||||
printf("calling method %s on interface %s\n",
|
||||
method->name, object->interface->name);
|
||||
demarshal(client, object, method, p + 2, len - 8);
|
||||
}
|
||||
}
|
||||
|
||||
if (mask & WL_EVENT_WRITEABLE) {
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
wl_display_get_interface(struct wl_client *client,
|
||||
struct wl_display *display,
|
||||
const char *interface, uint32_t id)
|
||||
{
|
||||
/* client sends a new object id, and an interface identifier
|
||||
* to name the object that implements the interface */
|
||||
printf("display::get_interface\n");
|
||||
}
|
||||
|
||||
static int
|
||||
wl_display_create_surface(struct wl_client *client,
|
||||
struct wl_display *display, uint32_t id)
|
||||
{
|
||||
struct wl_surface *surface;
|
||||
|
||||
printf("display::create_surface, client %p, display %p, new_id=%d\n",
|
||||
client, display, id);
|
||||
|
||||
surface = wl_surface_create(display, id);
|
||||
wl_hash_insert(&display->objects, &surface->base);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct wl_argument create_surface_arguments[] = {
|
||||
{ WL_ARGUMENT_NEW_ID }
|
||||
};
|
||||
|
||||
static const struct wl_method display_methods[] = {
|
||||
{ "get_interface", wl_display_get_interface,
|
||||
ARRAY_LENGTH(get_interface_arguments), get_interface_arguments },
|
||||
{ "create_surface", wl_display_create_surface,
|
||||
ARRAY_LENGTH(create_surface_arguments), create_surface_arguments },
|
||||
};
|
||||
|
||||
static const struct wl_interface display_interface = {
|
||||
"display", 1, ARRAY_LENGTH(display_methods), display_methods,
|
||||
};
|
||||
|
||||
struct wl_display *
|
||||
wl_display_create(void)
|
||||
{
|
||||
struct wl_display *display;
|
||||
|
||||
display = malloc(sizeof *display);
|
||||
if (display == NULL)
|
||||
return NULL;
|
||||
|
||||
display->loop = wl_event_loop_create();
|
||||
if (display->loop == NULL) {
|
||||
free(display);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
display->base.id = 0;
|
||||
display->base.interface = &display_interface;
|
||||
wl_hash_insert(&display->objects, &display->base);
|
||||
|
||||
return display;
|
||||
}
|
||||
|
||||
void
|
||||
wl_display_run(struct wl_display *display)
|
||||
{
|
||||
while (1)
|
||||
wl_event_loop_wait(display->loop);
|
||||
}
|
||||
|
||||
/* The plan here is to generate a random anonymous socket name and
|
||||
* advertise that through a service on the session dbus.
|
||||
*/
|
||||
static const char socket_name[] = "\0wayland";
|
||||
|
||||
static void
|
||||
socket_data(int fd, uint32_t mask, void *data)
|
||||
{
|
||||
struct wl_display *display = data;
|
||||
struct sockaddr_un name;
|
||||
socklen_t length;
|
||||
int client_fd;
|
||||
|
||||
length = sizeof name;
|
||||
client_fd = accept (fd, (struct sockaddr *) &name, &length);
|
||||
if (client_fd < 0)
|
||||
fprintf(stderr, "failed to accept\n");
|
||||
|
||||
wl_client_create(display, client_fd);
|
||||
}
|
||||
|
||||
int
|
||||
wl_display_add_socket(struct wl_display *display)
|
||||
{
|
||||
struct sockaddr_un name;
|
||||
int sock;
|
||||
socklen_t size;
|
||||
|
||||
sock = socket(PF_LOCAL, SOCK_STREAM, 0);
|
||||
if (sock < 0)
|
||||
return -1;
|
||||
|
||||
name.sun_family = AF_LOCAL;
|
||||
memcpy(name.sun_path, socket_name, sizeof socket_name);
|
||||
|
||||
size = offsetof (struct sockaddr_un, sun_path) + sizeof socket_name;
|
||||
if (bind(sock, (struct sockaddr *) &name, size) < 0)
|
||||
return -1;
|
||||
|
||||
if (listen(sock, 1) < 0)
|
||||
return -1;
|
||||
|
||||
wl_event_loop_add_fd(display->loop, sock, WL_EVENT_READABLE,
|
||||
socket_data, display);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
struct wl_display *display;
|
||||
|
||||
display = wl_display_create();
|
||||
|
||||
if (wl_display_add_socket(display)) {
|
||||
fprintf(stderr, "failed to add socket: %m\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
printf("wayland online, display is %p\n", display);
|
||||
|
||||
wl_display_run(display);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
#ifndef WAYLAND_H
|
||||
#define WAYLAND_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
enum {
|
||||
WL_EVENT_READABLE = 0x01,
|
||||
WL_EVENT_WRITEABLE = 0x02
|
||||
};
|
||||
|
||||
struct wl_event_loop;
|
||||
struct wl_event_source;
|
||||
typedef void (*wl_event_loop_func_t)(int fd, uint32_t mask, void *data);
|
||||
|
||||
struct wl_event_loop *wl_event_loop_create(void);
|
||||
void wl_event_loop_destroy(struct wl_event_loop *loop);
|
||||
struct wl_event_source *wl_event_loop_add_fd(struct wl_event_loop *loop,
|
||||
int fd, uint32_t mask,
|
||||
wl_event_loop_func_t func,
|
||||
void *data);
|
||||
int wl_event_loop_remove_source(struct wl_event_loop *loop,
|
||||
struct wl_event_source *source);
|
||||
int wl_event_loop_wait(struct wl_event_loop *loop);
|
||||
|
||||
struct wl_hash {
|
||||
struct wl_object **objects;
|
||||
uint32_t count, alloc, id;
|
||||
};
|
||||
|
||||
int wl_hash_insert(struct wl_hash *hash, struct wl_object *object);
|
||||
struct wl_object *wl_hash_lookup(struct wl_hash *hash, uint32_t id);
|
||||
void wl_hash_delete(struct wl_hash *hash, struct wl_object *object);
|
||||
|
||||
struct wl_client;
|
||||
|
||||
enum {
|
||||
WL_ARGUMENT_UINT32,
|
||||
WL_ARGUMENT_STRING,
|
||||
WL_ARGUMENT_OBJECT,
|
||||
WL_ARGUMENT_NEW_ID
|
||||
};
|
||||
|
||||
struct wl_argument {
|
||||
uint32_t type;
|
||||
void *data;
|
||||
};
|
||||
|
||||
struct wl_method {
|
||||
const char *name;
|
||||
void *func;
|
||||
int argument_count;
|
||||
const struct wl_argument *arguments;
|
||||
};
|
||||
|
||||
struct wl_interface {
|
||||
const char *name;
|
||||
int version;
|
||||
int method_count;
|
||||
const struct wl_method *methods;
|
||||
};
|
||||
|
||||
struct wl_object {
|
||||
const struct wl_interface *interface;
|
||||
uint32_t id;
|
||||
};
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue