wayland/src, branch 1.0.5

connection.c: Align pointer extra storage correctly

2013-02-14T19:23:58Z

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.

event-loop: fix returning the destroy-signal listener

2013-01-25T01:22:00Z

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:28:29Z

Added a destroy signal to the wl_display object.

2013-01-11T20:53:12Z

Added a destroy signal to the wl_display object.

client: remove two unused function pointer typedefs

2012-12-12T16:09:46Z

The need for wl_display_update_func_t was removed in commit 53d24713a31d59d9534c1c1a84a7ad46f44ee95f Author: Kristian Høgsberg Date: Thu Oct 4 16:54:22 2012 -0400 Change filedescriptor API to be thread safe and wl_callback_func_t does not seem to have ever been used in the first place. Signed-off-by: Pekka Paalanen

client: Update libtool version for new entry points

2012-11-30T21:43:23Z

We've added wl_display_dispatch_queue_pending, so update the libtool library current and age fields accordingly.

client: Add \since tag for wl_display_dispatch_queue_pending() documentation

2012-11-30T19:14:22Z

pkgconfig: Use configure provided directories

2012-11-28T01:36:48Z

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

scanner: Fix wrong restriction on since field

2012-11-27T16:13:36Z

The scanner would not allow two consecutive requests on an interface to have the same since number, so if a new version of an interface added two new request the version number would have to be increased by two.

client: Don't cancel a roundtrip when any event is received

2012-11-27T16:09:45Z

Since wl_display_dispatch() returns the number of processed events or -1 on error, only cancel the roundtrip if an -1 is returned. This also fixes a potential memory corruption bug happening when wl_display_roundtrip() does an early return and the callback later writes to the then out of scope stack allocated `done' parameter. Introduced by 33b7637b4500a682018b503837b8aca9afae36f2. Signed-off-by: Jonas Ådahl

doc: Fix typos

2012-11-24T03:51:51Z

Signed-off-by: Tiago Vignatti

client: Add an entry point for dispatching a queue without blocking

2012-11-24T02:50:14Z

On the client side EGL, all the wl_buffer.release events need to be processed before buffer allocation, otherwise a third buffer might be allocated unnecessarily. However, the buffer allocation should not block in the case no event was received. In order to do that, a non-blocking queue dispatch function is needed.

debug: Allow WAYLAND_DEBUG=server/client for server/client side only debug

2012-11-21T22:14:55Z

By default the server will dump protocol for both the server and its clients when run with WAYLAND_DEBUG=1. That's still the case, but it now also understands WAYLAND_DEBUG=client or WAYLAND_DEBUG=server, which will only enable debug dumping on either client or server side.

client: Fix source comment typos

2012-11-14T18:59:03Z

client: Keep track of proxy validity and number of reference holders

2012-11-05T20:44:50Z

When events are queued, the associated proxy objects (target proxy and potentially closure argument proxies) are verified being valid. However, as any event may destroy some proxy object, validity needs to be verified again before dispatching. Before this change this was done by again looking up the object via the display object map, but that did not work because a delete_id event could be dispatched out-of-order if it was queued in another queue, causing the object map to either have a new proxy object with the same id or none at all, had it been destroyed in an earlier event in the queue. Instead, make wl_proxy reference counted and increase the reference counter of every object associated with an event when it is queued. In wl_proxy_destroy() set a flag saying the proxy has been destroyed by the application and only free the proxy if the reference counter reaches zero after decreasing it. Before dispatching, verify that a proxy object still is valid by checking that the flag set in wl_proxy_destroy() has not been set. When dequeuing the event, all associated proxy objects are dereferenced and free:ed if the reference counter reaches zero. As proxy reference counter is initiated to 1, when dispatching an event it can never reach zero without having the destroyed flag set. Signed-off-by: Jonas Ådahl

scanner: Preserve paragraph breaks in input XML

2012-10-22T02:24:33Z

If we have a blank line in the incoming XML documentation, keep that in the emitted doxygen comments.

scanner: Fix valgrind errors

2012-10-20T15:38:57Z

Rename __wl_container_of macro to just wl_container_of

2012-10-20T03:26:45Z

The _* namespace and identifiers with double underscore are reserved by the C standard. That makes __wl_container_of is double plus bad, so lets just call it wl_container_of.

Move un-namespaced container_of into private header

2012-10-20T03:06:53Z

Move ARRAY_LENGTH out of public headers

2012-10-19T21:08:38Z

Exporting unprefixed symbols is a pretty bad idea so don't do that. Instea of redefining it WL_ARRAY_LENGTH, we just move the define to our private header. The scanner generates code that uses ARRAY_LENGTH, but we can just make it count the number elements and emit an integer constant instead.

doc: Clarify documentation about dispatching event queues

2012-10-19T20:50:29Z

Clarify on what cases each of the dispatching functions may block, what is the main thread and add some real world examples.

doc: Update wl_display_get_error() documentation

2012-10-17T21:29:04Z

wayland-server: Fix up error handling with client creation.

2012-10-17T20:46:15Z

wayland-egl: Drop ill-defined pixmap support

2012-10-16T19:30:56Z

We don't have a use case for this and the actual semantics and synchronization behavior of wl_egl_pixmap were never really well-defined. It also doesn't provide the cross-process buffer sharing that make window systems pixmaps useful in other window systems.

connection: Dereference id completely for comparasion.

2012-10-16T15:24:31Z

connection: Removed crashing code.

2012-10-16T15:15:02Z

scanner: Make sure arguments have names.

2012-10-16T15:14:24Z

connection: Don't call memcpy with null pointer.

2012-10-16T15:12:38Z

doc: Add doxygen documentation to wl_display_get_error()

2012-10-16T14:50:57Z

doc: Document change of return value of dispatch functions

2012-10-16T14:50:28Z

doc: Document the restriction of destroying queues before the display

2012-10-16T14:50:14Z

doc: Put wl_display_flush() documentation in the right place

2012-10-16T14:50:02Z

It seems a rebase error caused it to end up in the wrong place.

wayland-server: Add touch grab support

2012-10-15T23:44:08Z

Touch grabs allow the compositor to be placed into a mode where touch events temporarily bypass their default behavior and perform other operations. Wayland already supports keyboard and pointer grabs, but was lacking corresponding touch support. The default touch grab handlers here contain the client event delivery code that was previously called directly in weston. Signed-off-by: Matt Roper

wayland-client: forward fatal errors to caller

2012-10-15T23:23:40Z

If any callback or helper function fails with a fatal error, we now set the last_error flag and prevent all further I/O on the wl_display. We wake up all sleeping event-queues and notify the caller that they should shutdown wl_display. Signed-off-by: David Herrmann

wayland: Take ownership of fd in wl_display_connect_to_fd()

2012-10-15T21:50:36Z

This means we're free to close it when we want, which we'll use to wake up the main thread if we hit an error in a different thread.

wayland-client: link all event-queues of each display into a list

2012-10-15T21:27:59Z

We need access to all event-queues of a single wl_display object. For instance during connection-errors, we need to be able to wake up all event queues. Otherwise, they will be stuck waiting for incoming events. The API user is responsible to keep a wl_display object around until all event-queues that were created on it are destroyed. Signed-off-by: David Herrmann

connection: return error on buffer-overflow during read

2012-10-15T21:21:06Z

wl_connection_read() assumes that the caller dispatched all messages before calling it. wl_buffer_put_iov() does only provide enough room so we fill the buffer. So the only case when the buffer overflows, is when a previous read filled up the buffer but we couldn't parse a single message from it. In this case, the client sent a message bigger than our buffer and we should return an error and close the connection. krh: Edited from Davids original patch to just check that the buffer isn't full before we try reading into it. Signed-off-by: David Herrmann

connection: Use uin32_t for circular buffer indexes

2012-10-15T21:16:30Z

We rely on well-defined unsigned overflow behaviour so let's make the index fields actually unsigned. Signed ints aren't guaranteed to have the behavior we want (could be either ones or twos complement).

connection: fix leaking FDs on buffer-overflow during read

2012-10-15T20:25:19Z

If we read more FDs than we have room for, we currently leak FDs because we overwrite previous still pending FDs. Instead, we do now close incoming FDs if the buffer is full and return EOVERFLOW. Signed-off-by: David Herrmann

connection: fix buffer-overflow in build_cmsg()

2012-10-15T20:23:38Z

Same problem as we had with close_fds(). We cannot rely on the fds_out buffer being filled with less than MAX_FDS_OUT file descriptors. Therefore, write at most MAX_FDS_OUT file-descriptors to the outgoing buffer. Signed-off-by: David Herrmann

connection: close pending incoming FDs on shutdown

2012-10-15T20:16:24Z

Same problem as with outgoing FDs. We need to close these on shutdown, otherwise we leak open file descriptors. Signed-off-by: David Herrmann

connection: fix buffer-overflow in close_fds()

2012-10-15T20:15:41Z

If we push two messages via wl_connection_write() and both messages contain more than MAX_FDS_OUT file-descriptors combined, then wl_connection_flush() will write only MAX_FDS_OUT of them, but close all pending ones, too. Furthermore, close_fds() will copy more FDs out of the buffer than it can hold and cause a buffer overflow. Therefore, we simply pass a maximum limit to close_fds(). During shutdown, we simply close all available FDs. Signed-off-by: David Herrmann

connection: close pending outgoing fds on shutdown

2012-10-15T20:12:46Z

When destroying a wl_connection object, there might still be data in the queue. We would leak open file-descriptors so we must close them. Signed-off-by: David Herrmann

wayland-util: return 0 on OOM in wl_map_insert_new()

2012-10-15T20:08:27Z

If we cannot increase the array for new entries, we now return 0 instead of accessing invalid memory. krh: Edited to return 0 on failure instead. In the initialization path, we call wl_map_insert_new() to insert NULL at index 0, which also returns 0 but not as an error. Since we do that up front, every other case of returning 0 is an unambiguous error. Signed-off-by: David Herrmann

wayland-util: return -1 if wl_array_copy() fails

2012-10-15T20:06:15Z

We might have to perform memory allocations in wl_array_copy(), so catch out-of-memory errors in wl_array_add() and return -1 before changing any state. Signed-off-by: David Herrmann

wayland-client: add wl_display_get_error()

2012-10-15T20:06:00Z

A server may asynchronously send errors via wl_display.error() events. Instead of aborting we now the a "last_error" flag inside of wl_display objects. The user can retrieve these via wl_display_get_error(). Signed-off-by: David Herrmann

doc: Improve libwayland-client doxygen documentation

2012-10-15T17:07:42Z

Document wl_proxy, wl_display and wl_event_queue classes and add a description to all public entry points. Also fix some typos.

doc: Add some doxygen documentation to wayland-client entry points

2012-10-15T17:06:15Z

Add some brief documentation for the public libwayland-client entry points. This is by no means complete, some functions are still undocumented and some might need extra information. Signed-off-by: Ander Conselvan de Oliveira Signed-off-by: Tiago Vignatti

scanner: use printf format attributes for desc_dump

2012-10-15T17:04:07Z

scanner: fix writing i586 descriptions

2012-10-15T17:04:07Z

This moves desc as first argument of desc_dump(). Description writing was broken on i586 because desc_dump() used va_arg() after a vsnprintf() call to find the last argument. But after calling a function with a va_arg argument, this arguments is undefined.

scanner: remove useless desc_dump arguments

2012-10-15T17:04:07Z

This are remnant from the desc_dump generalization in commit 375cb418.

client: Return number of events dispatched from dispatch functions

2012-10-15T15:38:24Z

To let clients determine whether any events were dispatched, we return the number of dispatched events. An event source with an event queue (such as wl_display or an X connection) may queue up event as a result of processing a different event source (data on a network socket, timerfd etc). After dispatching data from fd (or just before blocking) we have to check such event sources, which is what wl_event_source_check() is used for. A checked event source will have its handler called with mask=0 just before blocking. If any work is done in any of these handlers, we have to check all the checked sources again, since the work could have queued up events in a different source. This is why the event handlers must return a positive number if events were handled. Which in turn is why we need the wl_display dispatch functions to return that as well.

client: Add wl_display_dispatch_pending() for dispatching without reading

2012-10-15T14:52:53Z

If the main thread ends up dispatching a non-main queue, and not in a wl_display_dispatch() callback, we may queue up main queue events and read all data from the socket fd. When we get back to the main loop, the socket fd is no longer readable and nothing will trigger dispatching of the queued up events. The new function wl_display_dispatch_pending() will dispatch any pending events, but not attempt to read from the socket. Clients that integrate the wayland socket fd into a main loop should call wl_display_dispatch_pending() and then wl_display_flush() before going back to blocking in poll(2) or similar mechanism.

client: Discard proxies with no implementation at dispatch time

2012-10-11T21:12:50Z

We need to queue up events even if a proxy doesn't have an implementation (listener). In case of server created new objects, the client haven't had a chance to set the listener when the first events to the new object come in. So now we always queue up events and discard them at dispatch time if they don't have a listener at that point.

client: Don't forget to init and destroy mutex

2012-10-11T21:11:54Z

These chunks were dropped at some point, thanks to David Herrmann for spotting the omission.

connection: Print object id for new-id arguments in deubug output

2012-10-11T21:08:29Z

We can't use the same behaviour in both the client and the server. In the client this is a wl_proxy pointer in the server it's a pointer to the uint32_t object id. This doesn't fix the problem, but it's a slightly more useful default, since we typically use WAYLAND_DEBUG on the client.

client: Fix double locking bug

2012-10-11T13:59:40Z

The function wl_proxy_create_for_id() would try to acquire the display lock, but the only call path leading to it would call it with the lock already acquired. This patch removes the attempt to acquire the lock and makes the function static. It was exported before because client had to create proxy's manually when the server sent a new object id, but since commit 9de9e39f [1] this is no longer necessary. [1] commit 9de9e39f87adfce1ea9755e394928756254c0ba2 Author: Kristian Høgsberg Date: Thu Jun 28 22:01:58 2012 -0400 Allocate client proxy automatically for new objects v2: Change the right function. Previous patch changed wl_proxy_create() instead of wl_proxy_create_for_id().

data-device: Don't fake an attach event on drag icon surface

2012-10-11T13:46:57Z

Emit a new drag icon signal instead and let the compositor handle the unmapping of the icon surface.

Fix typecheck in case of multiple instances of type meta data

2012-10-11T02:01:17Z

In most cases the pointer equality test is sufficient. However, in some cases, depending on how things are split across shared objects, we can end up with multiple instances of the interface metadata constants. So if the pointers match, the interfaces are equal, if they don't match we have to compare the interface names.

connection: Move object lookup out of wl_connection_demarshal()

2012-10-11T02:01:17Z

On the client side where we queue up multiple events before dispatching, we need to look up the receiving proxy and argument proxies immediately before calling the handler. Between queueing up multiple events and eventually invoking the handler, previous handlers may have destroyed some of the proxies.

Split the global registry into its own wl_registry object

2012-10-11T00:59:00Z

The only way to make the global object listener interface thread safe is to make it its own interface and make different listeners different wl_proxies. The core of the problem is the callback we do when a global show up or disappears, which we can't do with a lock held. On the other hand we can't iterate the global list or the listener list without a lock held as new globals or listeners may come and go during the iteration. Making a copy of the list under the lock and then iterating after dropping the lock wont work either. In case of the listener list, once we drop the lock another thread may unregister a listener and destroy the callbackk data, which means that when we eventually call that listener we'll pass it free memory and break everything. We did already solve the thread-safe callback problem, however. It's what we do for all protocol events. So we can just make the global registry functionality its own new interface and give each thread its own proxy. That way, the thread will do its own callbacks (with no locks held) and destroy the proxy when it's no longer interested in wl_registry events.

scanner: Generate client stubs for wl_display requests

2012-10-11T00:59:00Z

We used to special case this because of the untyped new-id argument in the bind request. Now that the scanner can handle that, we can remove the special case. Switching to the generated stubs does bring an API change since we now also take the interface version that the client expects as an argument. Previously we would take this from the interface struct, but the application may implement a lower version than what the interface struct provides. To make sure we don't try to dispatch event the client doesn't implement handlers for, we have to use a client supplied version number.

scanner: Send interface name and version for types new_id args

2012-10-11T00:59:00Z

This makes the scanner generate the code and meta data to send the interface name and version when we pass a typeless new_id. This way, the generic factory mechanism provided by wl_display.bind can be provided by any interface.

client: Add wl_event_queue for multi-thread dispatching

2012-10-11T00:59:00Z

This introduces wl_event_queue, which is what will make multi-threaded wayland clients possible and useful. The driving use case is that of a GL rendering thread that renders and calls eglSwapBuffer independently of a "main thread" that owns the wl_display and handles input events and everything else. In general, the EGL and GL APIs have a threading model that requires the wayland client library to be usable from several threads. Finally, the current callback model gets into trouble even in a single threaded scenario: if we have to block in eglSwapBuffers, we may end up doing unrelated callbacks from within EGL. The wl_event_queue mechanism lets the application (or middleware such as EGL or toolkits) assign a proxy to an event queue. Only events from objects associated with the queue will be put in the queue, and conversely, events from objects associated with the queue will not be queue up anywhere else. The wl_display struct has a built-in event queue, which is considered the main and default event queue. New proxies are associated with the same queue as the object that created them (either the object that a request with a new-id argument was sent to or the object that sent an event with a new-id argument). A proxy can be moved to a different event queue by calling wl_proxy_set_queue(). A subsystem, such as EGL, will then create its own event queue and associate the objects it expects to receive events from with that queue. If EGL needs to block and wait for a certain event, it can keep dispatching event from its queue until that events comes in. This wont call out to unrelated code with an EGL lock held. Similarly, we don't risk the main thread handling an event from an EGL object and then calling into EGL from a different thread without the lock held.

client: Make wl_display thread safe

2012-10-11T00:59:00Z

Not all entry points are thread safe: global listeners and global lookup is still only main thread.

client: Split event handling into demarshal and dispatch steps

2012-10-11T00:59:00Z

This lets us demarshal with a mutex held and then do dispatching after releasing the mutex.

Change filedescriptor API to be thread safe

2012-10-11T00:59:00Z

The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.

connection: Add missing free from error path

2012-10-10T03:01:42Z

On the error codepath that errors out on ENOMEM we should free the allocated closure. Signed-off-by: Rob Bradford

connection: Drop unused static closures

2012-10-01T17:21:29Z

event-loop: export wl_event_loop_dispatch_idle()

2012-09-12T16:28:54Z

When integrating the wayland event-loop into another event-loop, we currently have no chance of checking whether there are pending idle sources that have to be called. This patch exports the "dispatch_idle_sources()" call so other event loops can call this before going to sleep. This is what wl_event_loop_dispatch() currently does so we simply allow external event-loops to do the same now. To avoid breaking existing applications, we keep the call to dispatch_idle_sources() in wl_event_loop_dispatch() for now. However, if we want we can remove this later and require every application to call this manually. This needs to be discussed, but the overhead is negligible so we will probably leave it as it is. This finally allows to fully integrate the wayland-server API into existing event-loops without any nasty workarounds. Signed-off-by: David Herrmann

wayland-server: return new ID in wl_client_add_resource()

2012-09-11T01:44:47Z

wl_client_add_resource() used to return no error even though the new resource wasn't added to the client. This currently makes it very easy to DOS weston by simply posting thousands of "create_surface" requests with an invalid ID. Weston simply assumes the wl_client_add_resource() request succeeds but will never destroy the surface again as the "destroy" signal is never called (because the surface isn't linked into the wl_map). This change makes wl_client_add_resource() return the new ID of the added object and 0 on failure. Servers (like weston) can now correctly immediately destroy the surface when this call fails instead of leaving the surface around and producing memory-leaks. Instead of returning -1 on failure and 0 on success, I made it return the new ID as this seems more appropriate. We can directly use it when calling it with new_id==0. Signed-off-by: David Herrmann

event-loop: remove dead code

2012-09-11T01:28:34Z

There is really no need to increment "n" if we never read the value. The do-while() loop overwrites the value before it is read the first time. Signed-off-by: David Herrmann

Add wl_shm_buffer_create()

2012-08-16T14:49:48Z

client: Add wl_display_connect_to_fd() function

2012-08-16T14:49:48Z

This lets us connect a display to an already existing socket fd.

connection: zero out string padding

2012-08-04T02:39:51Z

We don't want to send random data to the client and this also keeps valgrind happy.

More consistent ID printing

2012-07-24T00:17:10Z

Use unsigned rather than signed for IDs, so they match up with what we see in other prints. Signed-off-by: Daniel Stone

Make NEW_IDs nullable

2012-07-24T00:16:57Z

The connection-handling code already allows this, so make it legal in the protocol definition too. Signed-off-by: Daniel Stone

Unstatic arg_count_for_signature and get_next_argument

2012-07-24T00:15:28Z

Expose these to other files using wayland-private.h, so wayland-client.c can walk NULLables properly. Signed-off-by: Daniel Stone

connection: reserve id on incoming new object

2012-07-22T18:09:51Z

If a new object id arrives ensure that there is an empty array entry created, otherwise we might get out of sync for new ids if object isn't created by interface implementation.

wayland-util: add method for reserving new object id

2012-07-22T18:09:48Z

wl_map_reserve_new() ensures that new id is valid and will point to an empty array entry.

wayland-server: send error on invalid new object id

2012-07-22T18:06:37Z

Creation of new client resources was silently ignored when wl_client_add_resource() was used on server side and new object id was out of range. An error is now send out to the client in such case. Also changed error message in wl_client_add_object, since wl_map_insert_at() returns -1 only at invalid new id.

wayland-shm: Commit the width/height getters that actually compile

2012-07-20T16:30:07Z

shm: Add shm_buffer getters for width and height

2012-07-20T16:04:42Z

wayland-client: Add missing newline from an error message

2012-07-20T16:04:05Z

remove listener from wl_data_source destroy_signal listener list

2012-07-17T20:54:07Z

I've found a bug during wayland exploration - if you make two drag'n'drops in weston client example, dnd - weston crashes with segfault. I've tried to investigate it and found a problem. In function drag_grab_button we first call data_device_end_drag_grab, which sets seat->drag_data_source to NULL. Then we remove listener from list only if drag_data_source is not NULL. So if client will not free wl_data_source and start another drag'n'drop, after the first one. Then two wl_data_source structures will be free'd on client exit (let's name them s1 and s2). next and prev pointer of wl_data_source.resource.destroy_signal.listener_list in both wl_data_source structures will be seat->drag_data_source_listener, but next and prev in seat->drag_data_source_listener.link point to listener_list in s2. So if you try to iterate over listener_list in s1 then you get drag_data_source_listener as first item and (struct wl_listener *)(&s2.resource.destroy_signal.listener_list) Iteration over that list occurs in wl_resource_destroy->destroy_resource->wl_signal_emit->wl_signal_emit and try to call function at address of wl_resource->client, so weston segfaults there.

server: fix wl_seat_set_keyboard

2012-07-10T18:08:01Z

This makes wl_seat_set_keyboard similar to wl_seat_set_pointer in that it's a no-op, if you try to set keyboard to NULL when it already is NULL, instead of refusing to set it to NULL ever. Signed-off-by: Pekka Paalanen

server: add lose_touch_focus()

2012-07-10T17:57:33Z

Just like wl_keyboard and wl_pointer, add a signal handler for losing touch focus. Signed-off-by: Pekka Paalanen

scanner: Include weston-client.h as the inline functions require it

2012-07-10T02:01:25Z

wayland-shm: Add return before we hit the error clean-up path

2012-07-10T01:50:39Z

Regression in c94c0946db694ec29b5aebb94a8be0501bacfbc7

Fixup source comment in wayland-util.h and fix typo in TODO

2012-07-09T22:11:06Z

shm: Plug leak in shm_create_pool()

2012-07-09T21:59:45Z

server: Don't crash for wl_seat_set_touch(seat, NULL)

2012-07-09T21:59:36Z

scanner: Plug memory leak in end_element()

2012-07-09T21:59:23Z

protocol: Add explicit nullable types

2012-07-02T17:53:02Z

Most of the time it does not make sense to pass a NULL object, string, or array to a protocol request. This commit adds an explicit “allow-null” attribute to mark the request arguments where NULL makes sense. Passing a NULL object, string, or array to a protocol request which is not marked as allow-null is now an error. An implementation will never receive a NULL value for these arguments from a client. Signed-off-by: Christopher James Halse Rogers

wayland-client: reject socket paths longer than 108 bytes

2012-06-30T19:58:36Z

Attempting to write anything longer into the embedded char array would create a non-null-terminated string, and all later reads would run off the end into invalid memory. This is a hard limitation of AF_LOCAL/AF_UNIX sockets.

wayland-server: reject socket paths longer than 108 bytes

2012-06-30T19:58:05Z

wayland-server: add more logging of errors

2012-06-30T19:57:22Z

wayland-server: fix socket ownership race condition

2012-06-30T19:50:09Z

Always unlink() the lock file before closing the file descriptor for it. Otherwise, there is a race like this: Process A closes fd, releasing the lock Process B opens the same file, taking the lock Process A unlinks the lock file Process C opens the same file, which now no longer exists, and takes the lock on the newly created lock file Process B and C both 'own' the same display socket. unlink()ing while holding the lock is effectively a better way to release the lock atomically.

wayland-server: fix fd leak on error path

2012-06-30T19:37:42Z

And restructure get_socket_lock() so it's clearer that it's allocating a new file descriptor. Uncovered by an upcoming test.

drop use of strerror()

2012-06-30T19:37:04Z

It isn't thread-safe. Use the %m conversion specifier instead, like the rest of the code already does.