wayland/src, branch 1.3.92

Fix buffer overflow when serializing a closure object

2014-01-09T22:27:52Z

Here is the JIRA page of this issue https://bugs.tizen.org/jira/browse/TIVI-1889 Change-Id: I773a6d2d8f6fd02ff10c92450db1fa8a69544219 Signed-off-by: Chi Ding Closes: https://bugs.freedesktop.org/show_bug.cgi?id=65186

scanner: set errno=0 before strtol

2013-12-17T18:57:52Z

POSIX says to set errno=0 before calling strtol since the return value alne cannot tell a failure. on ubuntu armel I get: ../src/wayland-scanner client-header < ../../protocol/wayland.xml > wayland-client-protocol.h :1188: error: invalid integer (2) Signed-off-by: Adrian Negreanu

client: Handle EINTR in wl_display_dispatch_queue()

2013-12-10T00:19:33Z

Restart the poll() if we take a signal. This is easily triggered in an application that ends up blocking in eglSwapBuffers(), and causes EGL to fail to allocate a back buffer.

doc: Fix spelling of parameters

2013-12-09T23:50:01Z

Signed-off-by: Jonas Ådahl

doc: Remove incorrect docmentation

2013-12-09T23:43:04Z

The documentation was about wl_client_get_object(), not about wl_resource_get_client(). Signed-off-by: Jonas Ådahl

client: Make wl_proxy_set_queue() with NULL revert to default queue

2013-12-05T01:01:01Z

This will be useful in order to implement the EGL_WL_create_wayland_buffer_from_image extension. The buffers created within Mesa's Wayland platform are created using the the wl_drm object as a proxy factory which means they will be set to use Mesa's internal event queue. However, these buffers will be owned by the client application so they ideally need to use the default event loop. This function provides a way to set the proxy's event queue back to the default. krh: Edited from Neils original patch to just use wl_proxy_set_queue() with a NULL argument instead of introducing a new function.

Add -pthread to AM_CFLAGS to do the right thing when using threads

2013-11-23T20:24:43Z

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

connection: Error out if file descriptor was not received

2013-11-22T06:01:48Z

Otherwise the tail of fds_in buffer would just shift beyond the beginning. That confuses the actual request handler and results in a crash further on due to corrupted tail. Signed-off-by: Lubomir Rintel

wayland-server: Improve error messages for bad globals

2013-11-19T21:26:32Z

A bug in Weston's toytoolkit gave me an hour of debugging headaches. Improve the error messages that we send if a client requests an invalid global, either by name or by version.

client: Introduce functions to allocate and marshal proxies atomically

2013-11-16T04:49:36Z

The server requires clients to only allocate one ID ahead of the previously highest ID in order to keep the ID range tight. Failure to do so will make the server close the client connection. However, the way we allocate new IDs is racy. The generated code looks like: new_proxy = wl_proxy_create(...); wl_proxy_marshal(proxy, ... new_proxy, ...); If two threads do this at the same time, there's a chance that thread A will allocate a proxy, then get pre-empted by thread B which then allocates a proxy and then passes it to wl_proxy_marshal(). The ID for thread As proxy will be one higher that the currently highest ID, but the ID for thread Bs proxy will be two higher. But since thread B prempted thread A before it could send its new ID, B will send its new ID first, the server will see the ID from thread Bs proxy first, and will reject it. We fix this by introducing wl_proxy_marshal_constructor(). This function is identical to wl_proxy_marshal(), except that it will allocate a wl_proxy for NEW_ID arguments and send it, all under the display mutex. By introducing a new function, we maintain backwards compatibility with older code from the generator, and make sure that the new generated code has an explicit dependency on a new enough libwayland-client.so. A virtual Wayland merit badge goes to Kalle Vahlman, who tracked this down and analyzed the issue. Reported-by: Kalle Vahlman

shm: Avoid file descriptor leak upon unsuccessful mmap

2013-11-16T00:21:45Z

It would be possible to make the compositor leak file descriptors by passing descriptors of open unmmapable files to it, such as /dev/null. Signed-off-by: Lubomir Rintel

Add documentation for wl_shm_buffer_begin/end_access

2013-11-15T22:46:48Z

It's not obvious that these functions are needed so it would be good to have some documentation for them.

scanner: Add location to elements so we can give better errors/warnings

2013-11-15T22:44:39Z

scanner: Make fail() function use va_list and elaborate a few errors

2013-11-15T22:44:39Z

scanner: Introduce struct location for tracking source locations

2013-11-15T22:44:39Z

scanner: Warn about requests with more than one new-id and don't generate stubs

2013-11-15T22:44:39Z

The generated code only support one new-id per request, since the stubs return the new proxy. It's still possible to send requests with multiple new-id arguments, but it must be done with wl_proxy_marshal_array_constructor().

server: Start documenting the server side API

2013-11-14T05:11:17Z

This is now public, stable API, so it seems prudent to actually document it.

server: Add API to protect access to an SHM buffer

2013-11-14T00:31:28Z

Linux will let you mmap a region of a file that is larger than the size of the file. If you then try to read from that region the process will get a SIGBUS signal. Currently the clients can use this to crash a compositor because it can create a pool and lie about the size of the file which will cause the compositor to try and read past the end of it. The compositor can't simply check the size of the file to verify that it is big enough because then there is a race condition where the client may truncate the file after the check is performed. This patch adds the following two public functions in the server API which can be used wrap access to an SHM buffer: void wl_shm_buffer_begin_access(struct wl_shm_buffer *buffer); void wl_shm_buffer_end_access(struct wl_shm_buffer *buffer); The first time wl_shm_buffer_begin_access is called a signal handler for SIGBUS will be installed. If the signal is caught then the buffer for the current pool is remapped to an anonymous private buffer at the same address which allows the compositor to continue without crashing. The end_access function will then post an error to the buffer resource. The current pool is stored as part of some thread-local storage so that multiple threads can safely independently access separate buffers. Eventually we may want to add some more API so that compositors can hook into the signal handler or replace it entirely if they also want to do some SIGBUS handling.

wayland: Be consistent about #include-guard names

2013-10-21T21:39:06Z

We had a mix of inconsistent names, some of which were non-conformant. Standardize on all-uppercase-and-underscore naming convention. https://bugs.freedesktop.org/show_bug.cgi?id=70679

scanner: Handle unrecognized invocation mode

2013-10-08T04:36:31Z

Print usage if we don't recognize the invocation mode. Also fixes uninitialized variable warning.

client: Fix handling display->reader_count if poll fails

2013-09-25T17:11:20Z

In wl_display_dispatch_queue, if poll fails then it would previously return immediately and leak a reference in display->reader_count. Then if the application ignores the error and tries to read again it will block forever. This can happen for example if the poll fails with EINTR which the application might consider to be a recoverable error. This patch makes it cancel the read so the reader_count will be decremented when poll fails.

Export the Wayland protocol XML file

2013-09-22T04:48:56Z

Signed-off-by: Jason Ekstrand

client: fix an inconsistency in documentation

2013-09-21T18:34:57Z

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

doc: Slight tweaks to wl_listener

2013-09-21T18:31:50Z

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

2013-09-21T18:31:41Z

wayland-server: Improve wording for wl_signal_get's doc

2013-09-17T04:59:28Z

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

utils: Add doxygen for wayland-util.h

2013-09-17T04:59:12Z

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

2013-09-17T04:59:00Z

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

wayland-server: Document wl_listener

2013-09-17T04:47:52Z

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

wayland-server: Add a wl_resource_for_each_safe macro

2013-09-11T19:03:22Z

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

2013-09-11T17:53:39Z

wayland-server: Document wl_signal

2013-09-11T17:52:41Z

wayland-server: Fix a uninitialized warning from clang

2013-09-11T17:42:37Z

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

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

2013-08-30T22:53:55Z

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.

Add support for client-side language bindings

2013-08-19T23:23:08Z

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

Add support for server-side language bindings

2013-08-19T23:23:08Z

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

wayland-client: Add wl_proxy_get_listener

2013-08-12T23:26:36Z

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

2013-08-12T23:26:36Z

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

client: Improve spelling and grammar in comments

2013-08-09T04:41:33Z

Signed-off-by: Bryce Harrington

server: Release additional_shm_formats array at display destruction

2013-08-08T20:51:13Z

scanner: expand help string

2013-08-07T23:24:55Z

Signed-off-by: Peter Hutterer

scanner: support help and --help

2013-08-07T23:24:44Z

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

2013-08-07T16:17:24Z

We just declare struct wl_display manually instead.

shm: Add API for renderers to register additional pixel formats

2013-08-06T23:48:02Z

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

2013-08-06T17:16:46Z

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

2013-08-06T16:51:53Z

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

2013-07-29T23:50:44Z

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

wayland-client: Handle potential NULL-deref

2013-07-13T04:42:14Z

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

2013-07-13T04:35:21Z

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.

2013-07-13T01:52:33Z

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

Replace two remaining wl_display_add_gloavl() occurences

2013-07-09T23:18:10Z

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

2013-07-09T22:59:11Z

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

2013-07-09T22:00:00Z

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

2013-07-09T21:59:56Z

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()

2013-07-09T05:15:37Z

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.

2013-07-03T20:38:12Z

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

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

2013-07-02T21:01:46Z

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

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

2013-07-02T21:01:46Z

wayland-server: Remove error event posting from wl_resource_create

2013-07-02T21:01:46Z

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

2013-07-02T21:01:46Z

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

2013-07-02T21:01:46Z

wayland-server: Verify request versions before invoking handler

2013-07-02T21:01:46Z

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

Add wl_resource_create() and a version field to wl_resource

2013-07-02T21:01:23Z

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

Add version information to wl_message signatures.

2013-07-02T19:52:47Z

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

server: Make wl_object and wl_resource opaque structs

2013-07-02T19:52:47Z

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

Change wl_shm_buffer to use a resource pointer

2013-06-21T23:18:08Z

This commit also has the effect of making wl_shm_buffer no longer a wl_buffer derivative. Signed-off-by: Jason Ekstrand

Change SHM wl_buffer functions to use the wl_shm_buffer structure

2013-06-21T23:18:06Z

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

Add a wl_resource_instance_of function

2013-06-21T23:18:04Z

Signed-off-by: Jason Ekstrand

Free non-legacy resources inside wl_resource_destroy

2013-06-20T19:12:26Z

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

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

2013-06-17T15:50:42Z

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

2013-06-14T19:56:08Z

Signed-off-by: Jason Ekstrand

server: Add wl_resource_get_id()

2013-06-07T05:00:30Z

Remove incorrect sanity-check from wl_map_insert_at

2013-06-05T21:45:47Z

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

Change WL_ZOMBIE_OBJECT from 0x2 to an actual pointer

2013-06-05T21:45:36Z

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

Add accessor functions for wl_resource and deprecate wl_client_add_resource

2013-06-05T04:59:08Z

This is the first step towards making wl_resource an opaque pointer type. Signed-off-by: Jason Ekstrand

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

2013-06-05T04:55:17Z

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

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

2013-06-05T04:33:57Z

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

server: Drop struct wl_surface

2013-05-08T13:45:59Z

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

2013-05-07T13:10:49Z

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).

wayland-client: Avoid null dereference when handling deletion

2013-04-04T16:39:57Z

If an unknown id is deleted then the lookup in the map will return NULL and so we should avoid dereferencing that. As this is unexpected behaviour log a message about the problem too.

utils: const-ify some function arguments

2013-04-03T16:46:57Z

wayland-server: Listen for pointer current surface destruction

2013-04-03T16:46:57Z

Add a destroy listener so that when the current surface associated with the pointer is destroyed we can reset the pointer to the current surface. In order to achieve this add a wl_pointer_set_current() which handles assigning the surface and creating the listener. This resolves a use-after-free error triggered with nested popup surfaces Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=696946

docs: Document non-blocking behaviour of wl_display_flush()

2013-04-03T01:31:02Z

server: use void* instead of function pointer for wl_object.implementation

2013-04-03T01:07:07Z

This is needed to make C++ programs that include wayland-server.h build: C++ does not allow conversions from data pointers to function pointers.

server: use the right function pointer type in wl_signal_get

2013-04-02T21:11:44Z

use the wl_notify_func type, and not void *, or else wl_signal_get will not be usable by a c++ plugin because it will not cast void * to a function pointer.

wayland-server: Avoid deferencing a NULL pointer in error case

2013-04-01T21:16:29Z

Reorder the error handling in the case that closure is NULL due to ENOMEM to ensure that we can safely call wl_closure_lookup_objects on the second test. Prior to this reordering the closure would be deferenced in the ENOMEM case due to the invocation of the second half of the logical OR check.

Add wl_resource_init and use it in libwayland implementations of data sharing and SHM

2013-03-19T03:04:32Z

This commit adds a wl_resource_init function for initializing wl_resource structures similar to wl_client_add_object. From this commit forward, wl_resource structures should not be initialized manually, but should use wl_resource_init. In the event of a change to the wl_resource structure, this allows us to protect against regressions by filling in added fields with reasonable defaults. In this way, while changing wl_object or wl_resource still constitutes an ABI break, compositors following this rule will only need to be recompiled in order to properly link against the new version. Signed-off-by: Jason Ekstrand

Change wl_closure_invoke to take an opcode instead of an actual function pointer

2013-03-19T03:04:32Z

Signed-off-by: Jason Ekstrand

client: Invoke new_id closure arguments as pointers instead of integers

2013-03-17T20:39:48Z

This commit adds a flags parameter to wl_closure_invoke(). The so far added flags are ment to specify if the invokation is client side or server side. When on the server side, closure arguments of type 'new_id' should be invoked as a integer id while on the client side they should be invoked as a pointer to a proxy object. This fixes a bug happening when the address of a client side 'new_id' proxy object did not fit in a 32 bit integer. krh: Squashed test suite compile fix from Jason Ekstrand. Signed-off-by: Jonas Ådahl

client: Check reference count only for destroyed proxies

2013-03-17T20:24:02Z

The llvm static analyzer tool reported "Use of memory after it is freed" in dispatch_event() because the proxy is used after being freed if the reference count reaches zero without the destroyed flag being set. This would never happen in practice because the owner of the proxy object always holds a reference until calling wl_proxy_destroy() which would also set the destroyed flag. Since this is the case, it is safe to do the reference count check only if the destroyed flag is set, as it can never reach zero if not. This commit doesn't change the behavior of the function, but makes the static analyzer more happy. Fixes https://bugs.freedesktop.org/show_bug.cgi?id=61385 Signed-off-by: Jonas Ådahl

Stylistic nitpicking

2013-02-26T18:40:38Z

No space between '!' and its argument, prefer i++ over ++i.

Clean up and refactor wl_closure and associated functions

2013-02-26T16:31:55Z

The primary purpose of this patch is to clean up wl_closure and separate closure storage, libffi, and the wire format. To that end, a number of changes have been made: - The maximum number of closure arguments has been changed from a magic number to a #define WL_CLOSURE_MAX_ARGS - A wl_argument union has been added for storing a generalized closure argument and wl_closure has been converted to use wl_argument instead of the combination of libffi, the wire format, and a dummy extra buffer. As of now, the "extra" field in wl_closure should be treated as bulk storage and never direclty referenced outside of wl_connection_demarshal. - Everything having to do with libffi has been moved into wl_closure_invoke and the convert_arguments_to_ffi helper function. - Everything having to do with the wire format has been restricted to wl_connection_demarshal and the new static serialize_closure function. The wl_closure_send and wl_closure_queue functions are now light wrappers around serialize_closure. Signed-off-by: Jason Ekstrand

client: add wl_proxy_get_class()

2013-02-26T16:28:21Z

This is a useful shorthand for client application debugging macros, since you can ask the object class from the object itself. Signed-off-by: Pekka Paalanen

scanner: Fix 'destroy)' typo in check for destroy request presence

2013-02-25T21:01:38Z

This is there to enforce that we don't have interfaces with a destroy request that isn't a destructor. The check never worked because of the typo, but we also don't have any interfaces like that.

scanner: remove list_length in favor of wl_list_length

2013-02-25T18:12:27Z

connection.c: Align pointer extra storage correctly

2013-02-04T12:07:17Z

Most extra data are just pointers, but in case of fds we store an int in the extra space. That can cause un-aligned access to pointers on 64 bit architectures. Make sure we always align pointer storage correctly.

Match libtool version info in 1.0 branch

2013-01-28T20:27:38Z

Master should always as old or older than the stable branch. I didn't copy over the libtool version bump when we bumped it in the 1.0 branch.

event-loop: fix returning the destroy-signal listener

2013-01-24T21:14:33Z

We need to actually return the destroy-listener, otherwise the return value is undefined. Signed-off-by: David Herrmann

Add a destroy signal to the wl_event_loop object

2013-01-15T19:05:27Z

Added a destroy signal to the wl_display object.

2013-01-11T20:52:39Z

Added a destroy signal to the wl_display object.