Export the Wayland protocol XML file

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

tests: add wl_resource tests

tests: add unit tests for wl_signal

Test wl_signal initialization, adding and getting listeners and emitting

tests: extended message when leak in test is detected

When memory or fd leak is detected, print how many blocks of memory were
allocated and not freed, respectively how many files were opened/unclosed.

client: fix an inconsistency in documentation

The errno is set to EAGAIN when there are undispatched events, according
to L1066 of wayland-client.c.

doc: Slight tweaks to wl_listener

Prefer \comment over // in code blocks for consistency's sake and keep
variable definitions separated by a line from the rest of the body.

utils: Document wl_container_of

doc: Create \comment alias for C-style comments

Since /* */ do not nest, documentation is forced to either use C++ style
// comments or some other foreign notation. This commit provides an alias
that allows C-style comments to be introduced in code blocks that support
aliases.

It should be noted that this macro will not work within \code blocks, as
Doxygen commands are ignored there. Instead, Doxygen's fenced code
blocks (created via ~~~) must be used for proper output. To demonstrate:

~~~
struct example_node {
        int id;
        \comment{Other members ...}
};
~~~

will roughly yield the following HTML (excluding syntax highlighting):

<pre>
struct example_node {
        int id;
        /* Other members ... */
};
</pre>

doc: Include wayland-util.* for doxygen output

This commit creates a shared file list that is included by both the
client and the server for the XML Makefile targets, as classes within
util are used by both the client and the server.

wayland-server: Improve wording for wl_signal_get's doc

The old description was a bit vague; this commit hopefully improves
describing what is returned.

utils: Add doxygen for wayland-util.h

This is needed for doxygen to generate output for macro definitions, such
as wl_container_of, that are contained by this file. Classes like
wl_list would be documented regardless.

utils: Reference some useful methods in wl_signal's doxygen

This commit adds a bit more detail on the lifecycle of a signal.

wayland-server: Document wl_listener

This patch takes Kristian's comments into account, adding a demonstration and
giving a more thorough idea of how wl_listener is used.

gitignore: add ./compile

./compile is a GNU autotools helper script and should be ignored by git

wayland-server: Add a wl_resource_for_each_safe macro

A version of wl_resource_for_each that is safe for iteration when items
in the list are removed.

utils: tweak wl_list for better doxygen output

wayland-server: Document wl_signal

wayland-server: Fix a uninitialized warning from clang

This warning is unnecessary, since the pointer in question is only used
for pointer arithmetic, but setting it explicitly to NULL doesn't hurt.

configure.ac: Bump version to 1.2.90 for master branch

scanner: Emit wl_*_destroy stub even if interface has a destructor

If an interface has a destructor but no 'destroy' method we used to
not emit a destroy method.  Now with the fix for missing destroy
requests for wl_pointer etc we need to emit the local wl_*_destroy
always.

protocol: Add release requests for wl_pointer, wl_keyboard, and wl_touch

We missed destroy requests in the 1.0 protocol and since the scanner
generates local-only *_destroy requests in that case we can't add
destroy requests without breaking protocol.  A client needs to verify
that the server provides a version 3 seat to use the protocol destructor
so the name needs to be something else than wl_*_destroy.

v2 (Rob Bradford): Rebased, bumped the protocol versions and added since
attributes to the requests.

Add support for client-side language bindings

This commit adds support for language bindings on the client half of the
library.  The idea is the same as for server-side dispatchers.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Add support for server-side language bindings

This commit adds support for server-side languages bindings.  This is done
in two ways:

1. Adding a wl_resource_set_dispatcher function that corresponds to
wl_resource_set_interface.  The only difference between the two functions
is that the new version takes a dispatcher along with the implementation,
data, and destructor.  This allows for runtime calling of native language
functions for callbacks instead of having to generate function pointers.

2. Adding versions of wl_resource_post_event and wl_resource_queue_event
that take an array of wl_argument instead of a variable argument list.
This allows for easier run-time argument conversion and removes the need
for libffi-based calling of variadic functions.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

doc: Add a section on interface and protocol object versioning

There have been a lot of questions asked lately about versioning of
interfaces and protocol objects.  This addition to the documentation should
clear up some of those questions.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

doc: Update the ID alocation section

The method described of alocation IDs has been wrong at least since version
1.0.  This commit updates it to correspond to the way IDs are chosen in
versions >= 1.0.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

publican: only split chapters and top-level sections onto separate pages

When generating HTML, don't split once we're into subjections. This
generates a single page for each protocol interface instead of the previous
separate pages for requests, events and enums.
No effect on the rest of the HTML configuration.

protocol: Improve a bit of grammar for wl_surface::attach description

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

wayland-client: Add wl_proxy_get_listener

This is the mirror function to wl_proxy_add_listener and is useful
inside client libraries to differentiate events on listeners for which
multiple proxies have been created.

wayland-server: Add a wl_resource_for_each macro

This macro allows you to correctly iterate through a list of resources
handling the opaque nature of this type.

protocol: Fix pluralization of user in popup_done description

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

protocol: Improve grammar for set class description

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

protocol: Add missing d to 'x an y'

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

protocol: Fix typo by removing a redundant 'a'

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

client: Improve spelling and grammar in comments

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

publican: Fix grammar several places in Protocol docs

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

publican: Drop unneeded 'of'

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

publican: Cleanup Preface's grammar.

Signed-off-by: Bryce Harrington <b.harrington@samsung.com>

server: Release additional_shm_formats array at display destruction

scanner: check for wayland-scanner.pc before using variables

If wayland-scanner.pc can't be found the variables end up being set
irrespectively, leaving the user with odd compiler errors about missing
headers, etc.

scanner: expand help string

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

scanner: support help and --help

wayland-scanner without arguments prints out usage. With help or --help it
waits for stdin to supply something which isn't quite as informative as
printing out the help.

This patch also moves the strcmp for args up to have all of them in one
location.

Don't include wayland-server.h in wayland-private.h

We just declare struct wl_display manually instead.

shm: Add API for renderers to register additional pixel formats

server: Set client->error when we fail to send a closure

We we're using wl_event_loop_add_idle() here, but if we're failing
because of OOM, that will typically also fail.  Instead, use the
existing client->error flag, which will break out of the event
handling loop and shut down the client.

server: Handle OOM properly when we fail to allocate a send closure

If we can't allocate a closure, don't just silently continue.  Set
client->error so we shut down the client when we're done processing events.

client: Simply wl_display_dispatch_queue_pending() and fix return value

We're supposed to return number of events dispatched on success, not 0.
Refactor to avoid goto and just return ret.

protocol: Copy missing pixel formats from wl_drm to wl_shm

Bump version to 1.2.0

wayland-client: Handle potential NULL-deref

Instead, return -1 on out-of-memory.  errno will be set to ENOMEM by
the failing malloc.

scanner: Fail more gracefully on out-of-memory

Failing with an error message and error code is little nicer.  I doubt we'll
hit this case much, but it makes the static analysis happy.

connection: Handle empty signature and signature with just a version.

Functions like wl_argument_from_va_list expect from get_next_argument,
to initialize details->type but when the signature is empty or contains
only version (like in desktop-shell-protocol.c in weston) it is left
uninitialized.

This patch fixes it, by initializing details->type with '\0' value,
signaling end of arguments.

Signed-off-by: Mariusz Ceier <mceier+wayland@gmail.com>

Bump version to 1.1.91

Replace two remaining wl_display_add_gloavl() occurences

wayland-server: Don't close display fd in fatal error handler

We can't do that there, we have to make sure it stays a valid fd until
the application calls wl_display_disconnect().  Otherwise the application
may end up poll()ing on a stale or wrong fd in case another part of the
application (or another thread) triggered a fatal error.

wayland-server: Return 0 from read_events() in case of EAGAIN

Getting no data from the socket is not an error condition.  This may
happen in case of calling prepare_read() and then read_events() with
no other pending readers and no data in the socket.  In general,
read_events() may not queue up events in the given event queue.  From
a given threads point of view it doesn't matter whether events were
read and put in a different event queue or no events were read at all.

wayland-client: Treat EOF when reading the wayland socket as an error

If EOF is encountered while reading from the Wayland socket, make
wl_display_read_events() return -1 so that it will be treated as an
error. The documentation for this function states that it will set
errno when there is an error so it additionally makes up an errno of
EPIPE.

If we don't do this then when the compositor quits the Wayland socket
will be become ready for reading but wl_display_dispatch will do
nothing which typically makes the application take up 100% CPU. In
particular eglSwapBuffers will likely get stuck in an infinite busy
loop because it repeatedly calls wl_display_dispatch_queue while it
waits for the frame callback.

https://bugzilla.gnome.org/show_bug.cgi?id=703892

wayland-server: Add wl_global_create/destroy()

This patch introduces wl_global_create() and wl_global_destroy() as
replacements for wl_display_add_global() and wl_display_remove_global().
The add/remove_global API did not allow a compositor to indicate
the implemented version of a global, it just took the version from
the interface meta data.  The problem is that the meta data
(which lives in libwayland-server.so) can get out of sync with a
compositor implementation.  The compositor will then advertise a
higher version of a global than what it actually implements.

The new API lets a compositor pass in a version when it registers
a global, which solves the problem.  The add/remove API is deprecated
with this patch and will be removed.

build: Add wayland-scanner.pc.

To allow user program to include wayland-scanner.m4 in tarball, move
the path variables from it into wayland-scanner.pc.

build: Install wayland-scanner.mk under $(pkgdatadir).

wayland-server: Free non-legacy wl_resource structs during wl_client_destroy

We need to free the non-legacy resources during client shutdown as well.

wayland-server: Remove left-over double free in unbind_resource() helper

wayland-server: Remove error event posting from wl_resource_create

The wl_client_add/new_object() functions sends out an NO_MEMORY error if
the allocation fails.  This was convenient in a couple of places where
that was all the error handling that was needed.  Unfortunately that
looks like out-of-memory isn't handled at the call site and set a bad
precedent for not cleaning up properly or not handling at all.

As we're introducing wl_resource_create() as a replacement for those two
functions, let's remove the automatic error event posting and require
the caller to do that if necessary.

This commit also introduces a new helper, wl_client_post_no_memory() to
make it possible to send NO_MEMORY events from bind where we don't have
a wl_resource.

wayland-server: Mark wl_client_add/new_object as deprecated

wayland-server: Dont free resource in user data destroy callback

wayland-server: Verify request versions before invoking handler

This commit provides a layer of protection for the compositor in the form
of message version checking.  We track version information in the
wl_resource and now use this version information to verify that a request
exists in that protocol version before invoking it.  This way libwayland
won't accidentally invoke a request that does not exist and thereby cause
the compositor to crash.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Add wl_resource_create() and a version field to wl_resource

A new function, wl_resource_create(), lets the compositor create a
wl_resource for a given version of the interface.  Passing 0 for the
object ID will allocate a new ID. The implementation, user data and
destructor can be set with wl_resource_set_implementation().

These two functions deprecates wl_client_add/new_object and the
main difference and motivation is the ability to provide a version number
for the resource.  This lets the compositor track which version of the
interface a client has created and we'll use that to verify incoming requests.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Add version information to wl_message signatures.

This commit adds version information to wl_message signatures and a
wl_message_get_since function to retrieve.  The since version comes in the
form of a (possible) integer at the begining of the message.  If the
message starts with an integer, then it specifies the "since" version of
that message.  Messages present in version one do not get this "since"
information.  In this way we can run-time detect the version information
for a structure on a per-message basis.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

server: Make wl_object and wl_resource opaque structs

With the work to add wl_resource accessors and port weston to use them,
we're ready to make wl_resource and wl_object opaque structs.  We keep
wl_buffer in the header for EGL stacks to use, but don't expose it by
default.  In time we'll remove it completely, but for now it provides a
transition paths for code that still uses wl_buffer.

Reviewed-by: Jason Ekstrand<jason@jlekstrand.net>

protocol: add no_keymap format to keymap formats

This format is used to specify that the key button events received are not in
relation to any key map and that the codes should be interpreted directly.

v2: Use zero for the no keymap enum value and enhance the documentation
for the enum entry.

Change wl_shm_buffer to use a resource pointer

This commit also has the effect of making wl_shm_buffer no longer a
wl_buffer derivative.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Change SHM wl_buffer functions to use the wl_shm_buffer structure

This commit does not break ABI.  It merely changes the types of some things
and adds a wl_shm_buffer_get function.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Add a wl_resource_instance_of function

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Free non-legacy resources inside wl_resource_destroy

This commit makes wl_resource_destroy automatically free all non-legacy
resource structures.  Since wl_resource is now an opaque structure it
doesn't make sense for the clients to be freeing it.  This checks to make
sure that it was added through wl_client_add_object or wl_client_new_object
and not wl_client_add_resource before it frees it.  This way if it is a
legacy resources embedded in a structure somewhere we don't have an invalid
free.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

doc: Add a small contributing guide

Document what we expect in terms of commit messages and coding style.
New contributors are usually unaware of this, so it is good to have a
document to point them too.

client: Add wl_display_prepare_read() API to relax thread model assumptions

The current thread model assumes that the application or toolkit will have
one thread that either polls the display fd and dispatches events or just
dispatches in a loop.  Only this main thread will read from the fd while
all other threads will block on a pthread condition and expect the main
thread to deliver events to them.

This turns out to be too restrictive.  We can't assume that there
always will be a thread like that.  Qt QML threaded rendering will
block the main thread on a condition that's signaled by a rendering
thread after it finishes rendering.  This leads to a deadlock when the
rendering threads blocks in eglSwapBuffers(), and the main thread is
waiting on the condition.  Another problematic use case is with games
that has a rendering thread for a splash screen while the main thread
is busy loading game data or compiling shaders.  The main thread isn't
responsive and ends up blocking eglSwapBuffers() in the rendering thread.

We also can't assume that there will be only one thread polling on the
file descriptor.  A valid use case is a thread receiving data from a
custom wayland interface as well as a device fd or network socket.
The thread may want to wait on either events from the wayland
interface or data from the fd, in which case it needs to poll on both
the wayland display fd and the device/network fd.

The solution seems pretty straightforward: just let all threads read
from the fd.  However, the main-thread restriction was introduced to
avoid a race.  Simplified, main loops will do something like this:

wl_display_dispatch_pending(display);

/* Race here if other thread reads from fd and places events
 * in main eent queue.  We go to sleep in poll while sitting on
 * events that may stall the application if not dispatched. */

poll(fds, nfds, -1);

/* Race here if other thread reads and doesn't queue any
 * events for main queue. wl_display_dispatch() below will block
 * trying to read from the fd, while other fds in the mainloop
 * are ignored. */

wl_display_dispatch(display);

The restriction that only the main thread can read from the fd avoids
these races, but has the problems described above.

This patch introduces new API to solve both problems.  We add

int wl_display_prepare_read(struct wl_display *display);

and

int wl_display_read_events(struct wl_display *display);

wl_display_prepare_read() registers the calling thread as a potential
reader of events.  Once data is available on the fd, all reader
threads must call wl_display_read_events(), at which point one of the
threads will read from the fd and distribute the events to event
queues.  When that is done, all threads return from
wl_display_read_events().

From the point of view of a single thread, this ensures that between
calling wl_display_prepare_read() and wl_display_read_events(), no
other thread will read from the fd and queue events in its event
queue.  This avoids the race conditions described above, and we avoid
relying on any one thread to be available to read events.

server: Add aditional wl_resource accessors

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

protocol: Add missing since attribute for name event on wl_seat

This event was added in version 2 of the protocol.

build: Fix warning message on syscall failures

server: Add wl_resource_get_id()

Update tests for wl_map changes and add a map_flags test

Remove incorrect sanity-check from wl_map_insert_at

I got a little over-eager with my sanity checks and didn't realize that the
client uses wl_map_insert_at to mark objects as zombies when they come from
the server-side.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Change WL_ZOMBIE_OBJECT from 0x2 to an actual pointer

In order to use the second-lowest bit of each pointer in wl_map for the
WL_MAP_ENTRY_LEGACY flag, every pointer has to be a multiple of 4.  This
was a good assumption, except with WL_ZOMBIE_OBJECT.  This commit creates
an actual static variable to which WL_ZOMBIE_OBJECT now points.  Since
things are only every compared to WL_ZOMBIE_OBJECT with "==" or "!=", the
only thing that matters is that it is unique.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

protocol: Move new name event below existing requests and events and version it

Missed v2 of Robs patch that already did this based on feedback from
Ander and Daniel.

Add accessor functions for wl_resource and deprecate wl_client_add_resource

This is the first step towards making wl_resource an opaque pointer type.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Add support for flags in the wl_map API and add a WL_MAP_ENTRY_LEGACY flag

The implementation in this commit allows for one bit worth of flags.  If
more flags are desired at a future date, then the wl_map implementation
will have to change but the wl_map API will not.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

Add a "side" field and some sanity checks to wl_map.

The original wl_map implementation did no checking to ensures that ids fell
on the correct side of the WL_SERVER_ID_START line.  This meant that a
client could send the server a server ID and it would happily try to use
it.  Also, there was no distinction between server-side and client-side in
wl_map_remove.  Because wl_map_remove added the entry to the free list
regardless of which side it came from, the following set of actions would
break the map:

1. Client creates a bunch of objects
2. Client deletes one or more of those objects
3. Client does something that causes the server to create an object

Because of the problem in wl_map_remove, the server would take an old
client-side id, apply the WL_SERVER_ID_START offset, and try to use it as a
server-side id regardless of whether or not it was valid.

Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>

protocol: Add a name event to give seat name

This provides the ability for a client to differentiate events from
different seats in a multiple seat environment.

build: Add declaration checks to check for required syscall flags

The required flags are relatively new and some older enterprise distributions
do not feature them.

https://bugs.freedesktop.org/show_bug.cgi?id=63360

protocol: Modes are specified in HW pixels

Modes are mainly meant to be used in coordination with fullscreen in
DRIVER mode, by e.g. games. For such games what they generally want
is to match some hardware mode and resize their window for that. We
don't really need to complicate this with the scaling. So, we
keep the resolutions in HW pixels, and drop the SCALED flag (as it
is now useless).

This lets you just create e.g an 800x600 buffer of scale 1 and
fullscreen that, ignoring the output scaling factor (although you can
of course also respect it and create a 400x300 surface at scale 2).
Conceptually the mode change is treated like a scaling which overrides
the normal output scale.

The only complexity is the FILL mode where it can happen that the user
specifies a buffer of the same size as the screen, but the output has scale
2 and the buffer scale 1. Just scanning out this buffer will work, but
effectively this is a downscaling operation, as the "real" size of the surface
in pels is twice the size of the output. We solve this by allowing FILL to
downscale (but still not upscale).

protocol: Use signed int for scale values

We usually use signed ints for things like this, to avoid
issues C sign coersion.

protocol: Support scaled outputs and surfaces

This adds the wl_surface.set_buffer_scale request, and a wl_output.scale
event. These together lets us support automatic upscaling of "old"
clients on very high resolution monitors, while allowing "new" clients
to take advantage of this to render at the higher resolution when the
surface is displayed on the scaled output.

It is similar to set_buffer_transform in that the buffer is stored in
a transformed pixels (in this case scaled). This means that if an output
is scaled we can directly use the pre-scaled buffer with additional data,
rather than having to scale it.

Additionally this adds a "scaled" flag to the wl_output.mode flags
so that clients know which resolutions are native and which are scaled.

Also, in places where the documentation was previously not clear as to
what coordinate system was used this was fleshed out.

It also adds a scaling_factor event to wl_output that specifies the
scaling of an output.

This is meant to be used for outputs with a very high DPI to tell the
client that this particular output has subpixel precision. Coordinates
in other parts of the protocol, like input events, relative window
positioning and output positioning are still in the compositor space
rather than the scaled space. However, input has subpixel precision
so you can still get input at full resolution.

This setup means global properties like mouse acceleration/speed,
pointer size, monitor geometry, etc can be specified in a "mostly
similar" resolution even on a multimonitor setup where some monitors
are low dpi and some are e.g. retina-class outputs.

protocol: Allow output changes to be treated atomically

This add a wl_output.done event which is send after every group
of events caused by some property change. This allows clients to treat
changes touching multiple events in an atomic fashion.

protocol: Fix documentation typo

server: Drop struct wl_surface

This struct was only defined in the server API for the purpose of the
input structs and helper functions.  Now that those are gone we can dro it.

Remove input structs

Looking at the functionality in the server library, it's clear (in
hindsight) that there are two different "things" in there: 1) The IPC
API, that is, everything that concerns wl_display, wl_client,
wl_resource and 2) and half-hearted attempt at sharing input code and
focus logic that leaves a lot of problematic structs in the API
surface, only to share less than 1000 lines of code.

We can just move those input structs and helper functions into weston
and cut libwayland-server down to just the core server side IPC API.
In the short term, compositors can copy those structs and functions
into their source, but longer term, they're probably better off
reimplementing those objects and logic their native framework
(QObject, GObject etc).

configure.ac: Bump to 1.1.90 to open master for 1.2 work

protocol: revert hotspot_x/y in set_cursor back to int

copy/paste error introduced in 9c0357af6ee42c318ce37b458ae7bdb7d51316cb

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

protocol: Make it clear that returned "one-shot" objects are destroyed

The objects returned by the frame and sync request are destroyed by the
compositor after the "done" event on the wl_callback interface is fired.

configure.ac: Bump version to 1.1.0

docs: Create html-pdf directories too

Fixes make dist here.