开源软件构建与测试

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 2

_service:extract_file:wayland.spec Deleted

@@ -1,116 +0,0 @@
-Name:           wayland
-Version:        1.20.0
-Release:	3
-Summary:	Wayland Compositor Infrastructure
-License:	MIT
-URL:		http://wayland.freedesktop.org/
-Source0:	http://wayland.freedesktop.org/releases/%{name}-%{version}.tar.xz
-
-BuildRequires:  gcc gcc-c++ docbook-style-xsl doxygen expat-devel  
-BuildRequires:  libxml2-devel libxslt pkgconfig(libffi) xmlto graphviz meson
-
-Provides:       libwayland-client = %{version}-%{release} libwayland-cursor = %{version}-%{release}  
-Obsoletes:      libwayland-client < %{version}-%{release}  libwayland-cursor < %{version}-%{release}  
-Provides:       libwayland-egl = %{version}-%{release} libwayland-server = %{version}-%{release}  
-Obsoletes:      libwayland-egl < %{version}-%{release} libwayland-server < %{version}-%{release} 
-
-%description
-Wayland is a protocol for a compositor to talk to its clients as 
-well as a C library implementation of that protocol. The 
-compositor can be a standalone display server running on Linux 
-kernel modesetting and evdev input devices, an X application, or 
-a wayland client itself. The clients can be traditional 
-applications, X servers (rootless or fullscreen) or other display 
-servers.
-
-Part of the Wayland project is also the Weston reference 
-implementation of a Wayland compositor. Weston can run as an X 
-client or under Linux KMS and ships with a few demo clients. The 
-Weston compositor is a minimal and fast compositor and is 
-suitable for many embedded and mobile use cases.
-
-%package        devel
-Summary:        Development files for %{name}
-Requires:       libwayland-client = %{version}-%{release}
-Requires:       libwayland-cursor = %{version}-%{release}
-Requires:       libwayland-egl = %{version}-%{release}
-Requires:       libwayland-server = %{version}-%{release}
-# For upgrade path from F24
-Provides:       libwayland-client-devel = %{version}-%{release}
-Obsoletes:      libwayland-client-devel < %{version}-%{release}
-Provides:       libwayland-cursor-devel = %{version}-%{release}
-Obsoletes:      libwayland-cursor-devel < %{version}-%{release}
-Provides:       libwayland-server-devel = %{version}-%{release}
-Obsoletes:      libwayland-server-devel < %{version}-%{release}
-# For upgrade path from F27
-Provides:       libwayland-egl-devel = %{version}-%{release}
-Obsoletes:      libwayland-egl-devel < %{version}-%{release}
-Provides:       mesa-libwayland-egl-devel = %{version}-%{release} mesa-libwayland-egl-devel%{?_isa}
-Obsoletes:      mesa-libwayland-egl-devel < %{version}-%{release} 
-
-
-%description    devel
-The %{name}-devel package contains libraries and header files for
-developing applications that use %{name}.
-
-%package_help
-
-%prep
-%autosetup -n %{name}-%{version} -p1
-
-%build
-%meson
-%meson_build
-
-%install
-%meson_install
-
-%check
-%meson_test
-
-%files
-%defattr(-,root,root)
-%license COPYING
-%{_libdir}/libwayland-*.so.*
-
-%files devel
-%{_bindir}/wayland-scanner
-%{_includedir}/wayland-*.h
-%{_libdir}/pkgconfig/wayland-*.pc
-%{_libdir}/libwayland-*.so
-%{_datadir}/aclocal/wayland-scanner.m4
-%dir %{_datadir}/wayland
-%{_datadir}/wayland/wayland-scanner.mk
-%{_datadir}/wayland/wayland.xml
-%{_datadir}/wayland/wayland.dtd
-
-%files help
-%defattr(-,root,root)
-%doc README
-%{_mandir}/man3/*.3*
-%{_datadir}/doc/wayland/
-
-%changelog
-* Mon Mar 28 2022 lin zhang <lin.zhang@turbolinux.com.cn> - 1.20.0-3
-- upgrade to 1.20.0-3
-
-* Sat Dec 04 2021 wangkerong <wangkerong@huawei.com> - 1.19.91-1
-- update to 1.19.91
-
-* Fri Jul 17 2020 chengguipeng <chenguipeng1@huawei.com> - 1.18.0-1
-- upgrade to 1.18.0-1
-
-* Tue Jan 14 2020 openEuler Buildteam <buildteam@openeuler.org> - 1.17.0-2
-- Type:bugfix
-- Id:NA
-- SUG:NA
-- DESC:delete the isa in obsoletes
-
-* Fri Oct 11 2019 openEuler Buildteam <buildteam@openeuler.org> - 1.17.0-1
-- Type:bugfix
-- Id:NA
-- SUG:NA
-- DESC:update to 1.17.0
-
-* Thu Sep 12 2019 openEuler Buildteam <buildteam@openeuler.org> - 1:6.02-5
-- Package init

_service:tar_scm:wayland.spec Added

@@ -0,0 +1,132 @@
+Name:           wayland
+Version:        1.21.0
+Release:	2
+Summary:	Wayland Compositor Infrastructure
+License:	MIT
+URL:		https://wayland.freedesktop.org/
+Source0:	https://gitlab.freedesktop.org/wayland/wayland/-/archive/%{version}/%{name}-%{version}.tar.gz
+
+BuildRequires:  gcc gcc-c++ docbook-style-xsl doxygen expat-devel  
+BuildRequires:  libxml2-devel libxslt pkgconfig(libffi) xmlto graphviz meson chrpath
+
+Provides:       libwayland-client = %{version}-%{release} libwayland-cursor = %{version}-%{release}  
+Provides:       libwayland-client%{?_isa} = %{version}-%{release} libwayland-cursor%{?_isa} = %{version}-%{release}  
+Obsoletes:      libwayland-client < %{version}-%{release}  libwayland-cursor < %{version}-%{release}  
+Provides:       libwayland-egl = %{version}-%{release} libwayland-server = %{version}-%{release}  
+Obsoletes:      libwayland-egl < %{version}-%{release} libwayland-server < %{version}-%{release} 
+
+%description
+Wayland is a protocol for a compositor to talk to its clients as 
+well as a C library implementation of that protocol. The 
+compositor can be a standalone display server running on Linux 
+kernel modesetting and evdev input devices, an X application, or 
+a wayland client itself. The clients can be traditional 
+applications, X servers (rootless or fullscreen) or other display 
+servers.
+
+Part of the Wayland project is also the Weston reference 
+implementation of a Wayland compositor. Weston can run as an X 
+client or under Linux KMS and ships with a few demo clients. The 
+Weston compositor is a minimal and fast compositor and is 
+suitable for many embedded and mobile use cases.
+
+%package        devel
+Summary:        Development files for %{name}
+Requires:       libwayland-client = %{version}-%{release}
+Requires:       libwayland-cursor = %{version}-%{release}
+Requires:       libwayland-egl = %{version}-%{release}
+Requires:       libwayland-server = %{version}-%{release}
+# For upgrade path from F24
+Provides:       libwayland-client-devel = %{version}-%{release}
+Obsoletes:      libwayland-client-devel < %{version}-%{release}
+Provides:       libwayland-cursor-devel = %{version}-%{release}
+Obsoletes:      libwayland-cursor-devel < %{version}-%{release}
+Provides:       libwayland-server-devel = %{version}-%{release}
+Obsoletes:      libwayland-server-devel < %{version}-%{release}
+# For upgrade path from F27
+Provides:       libwayland-egl-devel = %{version}-%{release}
+Obsoletes:      libwayland-egl-devel < %{version}-%{release}
+Provides:       mesa-libwayland-egl-devel = %{version}-%{release} mesa-libwayland-egl-devel%{?_isa}
+Obsoletes:      mesa-libwayland-egl-devel < %{version}-%{release} 
+
+
+%description    devel
+The %{name}-devel package contains libraries and header files for
+developing applications that use %{name}.
+
+%package_help
+
+%prep
+%autosetup -n %{name}-%{version} -p1
+
+%build
+%meson
+%meson_build
+
+%install
+%meson_install
+chrpath -d %{buildroot}%{_libdir}/libwayland-cursor.so
+
+%check
+%meson_test
+
+%files
+%defattr(-,root,root)
+%license COPYING
+%{_libdir}/libwayland-*.so.*
+
+%files devel
+%{_bindir}/wayland-scanner
+%{_includedir}/wayland-*.h
+%{_libdir}/pkgconfig/wayland-*.pc
+%{_libdir}/libwayland-*.so
+%{_datadir}/aclocal/wayland-scanner.m4
+%dir %{_datadir}/wayland
+%{_datadir}/wayland/wayland-scanner.mk
+%{_datadir}/wayland/wayland.xml
+%{_datadir}/wayland/wayland.dtd
+
+%files help
+%defattr(-,root,root)
+%doc README
+%{_mandir}/man3/*.3*
+%{_datadir}/doc/wayland/
+
+%changelog
+* Fri Dec 30 2022 lin zhang <lin.zhang@turbolinux.com.cn> - 1.21.0-2
+- add  Provides:libwayland-client%{?_isa} and libwayland-cursor%{?_isa}   
+
+* Wed Dec 14 2022 lijian <lijian2@kylinos.cn> - 1.21.0-1
+- update to 1.21.0
+
+* Sat Aug 27 2022 tianlijing <tianlijing@kylinos.cn> - 1.20.92-1
+- update to 1.20.92
+
+* Thu Jun 16 2022 wangkerong <wangkerong@h-partners.com> - 1.20.0-4
+- CVE:NA
+- SUG:NA
+- DESC:remove rpath
+
+* Mon Mar 28 2022 lin zhang <lin.zhang@turbolinux.com.cn> - 1.20.0-3
+- upgrade to 1.20.0-3
+
+* Sat Dec 04 2021 wangkerong <wangkerong@huawei.com> - 1.19.91-1
+- update to 1.19.91
+
+* Fri Jul 17 2020 chengguipeng <chenguipeng1@huawei.com> - 1.18.0-1
+- upgrade to 1.18.0-1
+
+* Tue Jan 14 2020 openEuler Buildteam <buildteam@openeuler.org> - 1.17.0-2
+- Type:bugfix
+- Id:NA
+- SUG:NA
+- DESC:delete the isa in obsoletes
+
+* Fri Oct 11 2019 openEuler Buildteam <buildteam@openeuler.org> - 1.17.0-1
+- Type:bugfix
+- Id:NA
+- SUG:NA
+- DESC:update to 1.17.0
+
+* Thu Sep 12 2019 openEuler Buildteam <buildteam@openeuler.org> - 1:6.02-5
+- Package init

_service Changed

_service:extract_file:wayland-1.20.0.tar.xz Deleted

_service:extract_file:wayland.yaml Deleted

_service:tar_scm:wayland-1.21.0.tar.gz/.editorconfig Added

_service:tar_scm:wayland-1.21.0.tar.gz/.gitignore Added

_service:tar_scm:wayland-1.21.0.tar.gz/.gitlab Added

_service:tar_scm:wayland-1.21.0.tar.gz/.gitlab-ci.yml Added

@@ -0,0 +1,350 @@
+# This file uses the freedesktop ci-templates to build Wayland and run our
+# tests in CI.
+#
+# ci-templates uses a multi-stage build process. First, the base container
+# image is built which contains the core distribution, the toolchain, and
+# all our build dependencies. This container is aggressively cached; if a
+# container image matching $FDO_DISTRIBUTION_TAG is found in either the
+# upstream repo (wayland/weston) or the user's downstream repo, it is
+# reused for the build. This gives us predictability of build and far
+# quicker runtimes, however it means that any changes to the base container
+# must also change $FDO_DISTRIBUTION_TAG. When changing this, please use
+# the current date as well as a unique build identifier.
+#
+# After the container is either rebuilt (tag mismatch) or reused (tag
+# previously used), the build stage executes within this container.
+#
+# The final stage is used to expose documentation and coverage information,
+# including publishing documentation to the public site when built on the
+# main branch.
+#
+# Apart from the 'variables', 'include', and 'stages' top-level anchors,
+# everything not beginning with a dot ('.') is the name of a job which will
+# be executed as part of CI, unless the rules specify that it should not be
+# run.
+#
+# Variables prefixed with CI_ are generally provided by GitLab itself;
+# variables prefixed with FDO_ and templates prefixed by .fdo are provided
+# by the ci-templates.
+#
+# For more information on GitLab CI, including the YAML syntax, see:
+#   https://docs.gitlab.com/ee/ci/yaml/README.html
+#
+# Note that freedesktop.org uses the 'Community Edition' of GitLab, so features
+# marked as 'premium' or 'ultimate' are not available to us.
+#
+# For more information on ci-templates, see:
+#   - documentation at https://freedesktop.pages.freedesktop.org/ci-templates/
+#   - repo at https://gitlab.freedesktop.org/freedesktop/ci-templates/
+
+# Here we use a fixed ref in order to isolate ourselves from ci-templates
+# API changes. If you need new features from ci-templates you must bump
+# this to the current SHA you require from the ci-templates repo, however
+# be aware that you may need to account for API changes when doing so.
+.templates_sha: &template_sha 567700e483aabed992d0a4fea84994a0472deff6 # see https://docs.gitlab.com/ee/ci/yaml/#includefile
+
+include:
+  - project: 'freedesktop/ci-templates'
+    ref: *template_sha
+    file:
+      - '/templates/debian.yml'
+      - '/templates/freebsd.yml'
+      - '/templates/ci-fairy.yml'
+
+variables:
+  FDO_UPSTREAM_REPO: wayland/wayland
+  FDO_REPO_SUFFIX: "$BUILD_OS/$BUILD_ARCH"
+
+
+# Define the build stages. These are used for UI grouping as well as
+# dependencies.
+stages:
+  - "Merge request checks"
+  - "Base container"
+  - "Build and test"
+  - "Other build configurations"
+
+.ci-rules:
+  rules:
+    - when: on_success
+
+# Base variables used for anything using a Debian environment
+.os-debian:
+  variables:
+    BUILD_OS: debian
+    FDO_DISTRIBUTION_VERSION: buster
+    FDO_DISTRIBUTION_PACKAGES: 'build-essential pkg-config libexpat1-dev libffi-dev libxml2-dev doxygen graphviz xmlto xsltproc docbook-xsl python3-pip python3-setuptools ninja-build'
+    FDO_DISTRIBUTION_EXEC: 'pip3 install meson==0.56.0'
+    # bump this tag every time you change something which requires rebuilding the
+    # base image
+    FDO_DISTRIBUTION_TAG: "2022-02-05.0"
+
+.debian-x86_64:
+  extends:
+    - .os-debian
+  variables:
+    BUILD_ARCH: "x86-64"
+
+.debian-aarch64:
+  extends:
+    - .os-debian
+  variables:
+    BUILD_ARCH: "aarch64"
+
+.debian-armv7:
+  extends:
+    - .os-debian
+  variables:
+    BUILD_ARCH: "armv7"
+
+
+# Does not inherit .ci-rules as we only want it to run in MR context.
+check-commit:
+  extends:
+    - .fdo.ci-fairy
+  stage: "Merge request checks"
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+      when: always
+    - when: never
+  script:
+    - ci-fairy check-commits --signed-off-by --junit-xml=results.xml
+  variables:
+    GIT_DEPTH: 100
+  artifacts:
+    reports:
+      junit: results.xml
+
+
+# Build our base container image, which contains the core distribution, the
+# toolchain, and all our build dependencies. This will be reused in the build
+# stage.
+x86_64-debian-container_prep:
+  extends:
+    - .ci-rules
+    - .debian-x86_64
+    - .fdo.container-build@debian
+  stage: "Base container"
+  variables:
+    GIT_STRATEGY: none
+
+aarch64-debian-container_prep:
+  extends:
+    - .ci-rules
+    - .debian-aarch64
+    - .fdo.container-build@debian
+  tags:
+    - aarch64
+  stage: "Base container"
+  variables:
+    GIT_STRATEGY: none
+
+armv7-debian-container_prep:
+  extends:
+    - .ci-rules
+    - .debian-armv7
+    - .fdo.container-build@debian
+  tags:
+    - aarch64
+  stage: "Base container"
+  variables:
+    GIT_STRATEGY: none
+    FDO_BASE_IMAGE: "arm32v7/debian:$FDO_DISTRIBUTION_VERSION"
+
+
+# Core build environment.
+.build-env:
+  variables:
+    MESON_BUILD_TYPE: "-Dbuildtype=debug -Doptimization=0 -Db_sanitize=address,undefined"
+  before_script:
+    - export BUILD_ID="wayland-$CI_JOB_NAME"
+    - export PREFIX="${CI_PROJECT_DIR}/prefix-${BUILD_ID}"
+    - export BUILDDIR="${CI_PROJECT_DIR}/build-${BUILD_ID}"
+    - mkdir "$BUILDDIR" "$PREFIX"
+
+
+# Build variants to be stacked on as required.
+.build-release:
+  stage: "Other build configurations"
+  variables:
+    MESON_BUILD_TYPE: "-Dbuildtype=release"
+
+
+# OS/architecture-specific variants
+.build-env-debian-x86_64:
+  extends:
+    - .fdo.suffixed-image@debian
+    - .debian-x86_64
+    - .build-env
+  needs:
+    - job: x86_64-debian-container_prep
+      artifacts: false
+
+.build-env-debian-aarch64:
+  extends:
+    - .fdo.suffixed-image@debian
+    - .debian-aarch64
+    - .build-env
+  variables:
+    # At least with the versions we have, the LSan runtime makes fork unusably
+    # slow on AArch64, which is bad news since the test suite decides to fork
+    # for every single subtest. For now, in order to get AArch64 builds and
+    # tests into CI, just assume that we're not going to leak any more on
+    # AArch64 than we would on ARMv7 or x86-64.
+    ASAN_OPTIONS: "detect_leaks=0"
+  tags:
+    - aarch64
+  needs:
+    - job: aarch64-debian-container_prep
+      artifacts: false

_service:tar_scm:wayland-1.21.0.tar.gz/.gitlab/issue_templates Added

_service:tar_scm:wayland-1.21.0.tar.gz/.gitlab/issue_templates/Bug.md Added

_service:tar_scm:wayland-1.21.0.tar.gz/CONTRIBUTING.md Added

@@ -0,0 +1,344 @@
+Contributing to Wayland
+=======================
+
+Sending patches
+---------------
+
+Patches should be sent via
+GitLab merge requests(https://docs.gitlab.com/ce/gitlab-basics/add-merge-request.html).
+Wayland is
+hosted on freedesktop.org's GitLab(https://gitlab.freedesktop.org/wayland/wayland/):
+in order to submit code, you should create an account on this GitLab instance,
+fork the core Wayland repository, push your changes to a branch in your new
+repository, and then submit these patches for review through a merge request.
+
+Wayland formerly accepted patches via `git-send-email`, sent to
+**wayland-devel@lists.freedesktop.org**; these were
+tracked using Patchwork(https://patchwork.freedesktop.org/project/wayland/).
+Some old patches continue to be sent this way, and we may accept small new
+patches sent to the list, but please send all new patches through GitLab merge
+requests.
+
+
+Formatting and separating commits
+---------------------------------
+
+Unlike many projects using GitHub and GitLab, Wayland has a
+linear, 'recipe' style history(http://www.bitsnbites.eu/git-history-work-log-vs-recipe/).
+This means that every commit should be small, digestible, stand-alone, and
+functional. Rather than a purely chronological commit history like this:
+
+    connection: plug a fd leak
+    plug another fd leak
+    connection: init fds to -1
+    close all fds
+    refactor checks into a new function
+    don't close fds we handed out
+
+we aim to have a clean history which only reflects the final state, broken up
+into functional groupings:
+
+    connection: Refactor out closure allocation
+    connection: Clear fds we shouldn't close to -1
+    connection: Make wl_closure_destroy() close fds of undispatched closures
+
+This ensures that the final patch series only contains the final state,
+without the changes and missteps taken along the development process.
+
+The first line of a commit message should contain a prefix indicating
+what part is affected by the patch followed by one sentence that
+describes the change. For examples:
+
+    protocol: Support scaled outputs and surfaces
+
+and
+
+    doc: generate server documentation from XML too
+
+If in doubt what prefix to use, look at other commits that change the
+same file(s) as the patch being sent.
+
+The body of the commit message should describe what the patch changes
+and why, and also note any particular side effects. This shouldn't be
+empty on most of the cases. It shouldn't take a lot of effort to write
+a commit message for an obvious change, so an empty commit message
+body is only acceptable if the questions "What?" and "Why?" are already
+answered on the one-line summary.
+
+The lines of the commit message should have at most 76 characters, to
+cope with the way git log presents them.
+
+See notes on commit messages for a recommended reading on writing commit
+messages.
+
+Your patches should also include a Signed-off-by line with your name and
+email address.  If you're not the patch's original author, you should
+also gather S-o-b's by them (and/or whomever gave the patch to you.) The
+significance of this is that it certifies that you created the patch,
+that it was created under an appropriate open source license, or
+provided to you under those terms.  This lets us indicate a chain of
+responsibility for the copyright status of the code.
+
+We won't reject patches that lack S-o-b, but it is strongly recommended.
+
+When you re-send patches, revised or not, it would be very good to document the
+changes compared to the previous revision in the commit message and/or the
+merge request. If you have already received Reviewed-by or Acked-by tags, you
+should evaluate whether they still apply and include them in the respective
+commit messages. Otherwise the tags may be lost, reviewers miss the credit they
+deserve, and the patches may cause redundant review effort.
+
+
+Tracking patches and following up
+---------------------------------
+
+Once submitted to GitLab, your patches will be reviewed by the Wayland
+development team on GitLab. Review may be entirely positive and result in your
+code landing instantly, in which case, great! You're done. However, we may ask
+you to make some revisions: fixing some bugs we've noticed, working to a
+slightly different design, or adding documentation and tests.
+
+If you do get asked to revise the patches, please bear in mind the notes above.
+You should use `git rebase -i` to make revisions, so that your patches follow
+the clear linear split documented above. Following that split makes it easier
+for reviewers to understand your work, and to verify that the code you're
+submitting is correct.
+
+A common request is to split single large patch into multiple patches. This can
+happen, for example, if when adding a new feature you notice a bug elsewhere
+which you need to fix to progress. Separating these changes into separate
+commits will allow us to verify and land the bugfix quickly, pushing part of
+your work for the good of everyone, whilst revision and discussion continues on
+the larger feature part. It also allows us to direct you towards reviewers who
+best understand the different areas you are working on.
+
+When you have made any requested changes, please rebase the commits, verify
+that they still individually look good, then force-push your new branch to
+GitLab. This will update the merge request and notify everyone subscribed to
+your merge request, so they can review it again.
+
+There are also
+many GitLab CLI clients(https://about.gitlab.com/applications/#cli-clients),
+if you prefer to avoid the web interface. It may be difficult to follow review
+comments without using the web interface though, so we do recommend using this
+to go through the review process, even if you use other clients to track the
+list of available patches.
+
+
+Coding style
+------------
+
+You should follow the style of the file you're editing. In general, we
+try to follow the rules below.
+
+**Note: this file uses spaces due to markdown rendering issues for tabs.
+  Code must be implemented using tabs.**
+
+- indent with tabs, and a tab is always 8 characters wide
+- opening braces are on the same line as the if statement;
+- no braces in an if-body with just one statement;
+- if one of the branches of an if-else condition has braces, then the
+  other branch should also have braces;
+- there is always an empty line between variable declarations and the
+  code;
+
+```c
+static int
+my_function(void)
+{
+        int a = 0;
+
+        if (a)
+                b();
+        else
+                c();
+
+        if (a) {
+                b();
+                c();
+        } else {
+                d();
+        }
+}
+```
+
+- lines should be less than 80 characters wide;
+- when breaking lines with functions calls, the parameters are aligned
+  with the opening parentheses;
+- when assigning a variable with the result of a function call, if the
+  line would be longer we break it around the equal '=' sign if it makes
+  sense;
+
+```c
+        long_variable_name =
+                function_with_a_really_long_name(parameter1, parameter2,
+                                                 parameter3, parameter4);
+
+        x = function_with_a_really_long_name(parameter1, parameter2,
+                                             parameter3, parameter4);
+```
+
+Conduct
+=======
+
+As a freedesktop.org project, Wayland follows the Contributor Covenant,
+found at:
+https://www.freedesktop.org/wiki/CodeOfConduct
+
+Please conduct yourself in a respectful and civilised manner when
+interacting with community members on mailing lists, IRC, or bug
+trackers. The community represents the project as a whole, and abusive
+or bullying behaviour is not tolerated by the project.
+
+
+Licensing
+=========
+
+Wayland is licensed with the intention to be usable anywhere X.org is.
+Originally, X.org was covered under the MIT X11 license, but changed to
+the MIT Expat license.  Similarly, Wayland was covered initially as MIT

_service:tar_scm:wayland-1.21.0.tar.gz/COPYING Added

@@ -0,0 +1,29 @@
+Copyright © 2008-2012 Kristian Høgsberg
+Copyright © 2010-2012 Intel Corporation
+Copyright © 2011 Benjamin Franzke
+Copyright © 2012 Collabora, Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+---
+
+The above is the version of the MIT "Expat" License used by X.org:
+
+    http://cgit.freedesktop.org/xorg/xserver/tree/COPYING

_service:tar_scm:wayland-1.21.0.tar.gz/README Added

@@ -0,0 +1,34 @@
+What is Wayland?
+
+Wayland is a project to define a protocol for a compositor to talk to
+its clients as well as a library implementation of the protocol.  The
+compositor can be a standalone display server running on Linux kernel
+modesetting and evdev input devices, an X application, or a wayland
+client itself.  The clients can be traditional applications, X servers
+(rootless or fullscreen) or other display servers.
+
+The wayland protocol is essentially only about input handling and
+buffer management.  The compositor receives input events and forwards
+them to the relevant client.  The clients creates buffers and renders
+into them and notifies the compositor when it needs to redraw.  The
+protocol also handles drag and drop, selections, window management and
+other interactions that must go through the compositor.  However, the
+protocol does not handle rendering, which is one of the features that
+makes wayland so simple.  All clients are expected to handle rendering
+themselves, typically through cairo or OpenGL.
+
+The weston compositor is a reference implementation of a wayland
+compositor and the weston repository also includes a few example
+clients.
+
+Building the wayland libraries is fairly simple, aside from libffi,
+they don't have many dependencies:
+
+    $ git clone https://gitlab.freedesktop.org/wayland/wayland
+    $ cd wayland
+    $ meson build/ --prefix=PREFIX
+    $ ninja -C build/ install
+
+where PREFIX is where you want to install the libraries.  See
+https://wayland.freedesktop.org for more complete build instructions
+for wayland, weston, xwayland and various toolkits.

_service:tar_scm:wayland-1.21.0.tar.gz/cursor Added

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/convert_font.c Added

@@ -0,0 +1,547 @@
+/*
+ * Copyright © 2012 Philipp Brüschweiler
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * This is a small, hacky tool to extract cursors from a .pcf file.
+ * The information about the file format has been gathered from
+ * http://fontforge.org/pcf-format.html
+ */
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+struct glyph {
+	char *name;
+	int16_t left_bearing, right_bearing, ascent, descent;
+
+	int16_t width, height;
+	int16_t hotx, hoty;
+
+	int32_t data_format;
+	char *data;
+};
+
+static struct {
+	int count;
+	struct glyph *glyphs;
+} extracted_font = {0, NULL};
+
+#define PCF_PROPERTIES		    (1<<0)
+#define PCF_ACCELERATORS	    (1<<1)
+#define PCF_METRICS		    (1<<2)
+#define PCF_BITMAPS		    (1<<3)
+#define PCF_INK_METRICS		    (1<<4)
+#define	PCF_BDF_ENCODINGS	    (1<<5)
+#define PCF_SWIDTHS		    (1<<6)
+#define PCF_GLYPH_NAMES		    (1<<7)
+#define PCF_BDF_ACCELERATORS	    (1<<8)
+
+#define PCF_DEFAULT_FORMAT	0x00000000
+#define PCF_INKBOUNDS		0x00000200
+#define PCF_ACCEL_W_INKBOUNDS	0x00000100
+#define PCF_COMPRESSED_METRICS	0x00000100
+
+#define	PCF_FORMAT_MASK		0xffffff00
+
+struct pcf_header {
+	char header4;
+	int32_t table_count;
+	struct toc_entry {
+		int32_t type;
+		int32_t format;
+		int32_t size;
+		int32_t offset;
+	} tables0;
+};
+
+struct compressed_metrics {
+	uint8_t left_sided_bearing;
+	uint8_t right_side_bearing;
+	uint8_t character_width;
+	uint8_t character_ascent;
+	uint8_t character_descent;
+};
+
+struct uncompressed_metrics {
+	int16_t left_sided_bearing;
+	int16_t right_side_bearing;
+	int16_t character_width;
+	int16_t character_ascent;
+	int16_t character_descent;
+	uint16_t character_attributes;
+};
+
+struct metrics {
+	int32_t format;
+	union {
+		struct {
+			int16_t count;
+			struct compressed_metrics compressed_metrics0;
+		} compressed;
+		struct {
+			int32_t count;
+			struct uncompressed_metrics uncompressed_metrics0;
+		} uncompressed;
+	};
+};
+
+struct glyph_names {
+	int32_t format;
+	int32_t glyph_count;
+	int32_t offsets0;
+};
+
+struct bitmaps {
+	int32_t format;
+	int32_t glyph_count;
+	int32_t offsets0;
+};
+
+static void
+handle_compressed_metrics(int32_t count, struct compressed_metrics *m)
+{
+	printf("metrics count: %d\n", count);
+	extracted_font.count = count;
+	extracted_font.glyphs = calloc(count, sizeof(struct glyph));
+
+	int i;
+	for (i = 0; i < count; ++i) {
+		struct glyph *glyph = &extracted_font.glyphsi;
+		glyph->left_bearing =
+			((int16_t) mi.left_sided_bearing) - 0x80;
+		glyph->right_bearing =
+			((int16_t) mi.right_side_bearing) - 0x80;
+		glyph->width = ((int16_t) mi.character_width) - 0x80;
+		glyph->ascent = ((int16_t) mi.character_ascent) - 0x80;
+		glyph->descent = ((int16_t) mi.character_descent) - 0x80;
+
+		/* computed stuff */
+		glyph->height = glyph->ascent + glyph->descent;
+
+		glyph->hotx = -glyph->left_bearing;
+		glyph->hoty = glyph->ascent;
+	}
+}
+
+static void
+handle_metrics(void *metricbuf)
+{
+	struct metrics *metrics = metricbuf;
+	printf("metric format: %x\n", metrics->format);
+
+	if ((metrics->format & PCF_FORMAT_MASK) == PCF_DEFAULT_FORMAT) {
+		printf("todo...\n");
+	} else if ((metrics->format & PCF_FORMAT_MASK) ==
+		   PCF_COMPRESSED_METRICS) {
+		handle_compressed_metrics(
+		    metrics->compressed.count,
+		    &metrics->compressed.compressed_metrics0);
+	} else {
+		printf("incompatible format\n");
+		abort();
+	}
+}
+
+static void
+handle_glyph_names(struct glyph_names *names)
+{
+	printf("glyph count %d\n", names->glyph_count);
+
+	if (names->glyph_count != extracted_font.count) {
+		abort();
+	}
+
+	printf("glyph names format %x\n", names->format);
+
+	void *names_start = ((void*) names) + sizeof(struct glyph_names)
+		+ (names->glyph_count + 1) * sizeof(int32_t);
+
+	int i;
+	for (i = 0; i < names->glyph_count; ++i) {
+		int32_t start = names->offsetsi;
+		int32_t end = names->offsetsi+1;
+		char *name = names_start + start;
+		extracted_font.glyphsi.name = calloc(1, end - start + 1);
+		memcpy(extracted_font.glyphsi.name, name, end - start);
+	}
+}

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/cursor-data.h Added

@@ -0,0 +1,554 @@
+/*
+* Copyright 1999 SuSE, Inc.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice (including the
+* next paragraph) shall be included in all copies or substantial
+* portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+* NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*
+* Author:  Keith Packard, SuSE, Inc.
+*/
+
+#include <stdint.h>
+
+static uint32_t cursor_data = {
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xffffffff, 0xffffffff, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0xffffffff, 0xff000000,
+	0xffffffff, 0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xff000000,
+	0xffffffff, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff,
+	0xffffffff, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0xff000000,
+	0xffffffff, 0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0xffffffff, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xffffffff,
+	0xffffffff, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000,
+	0x00000000, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0xffffffff, 0xff000000, 0xffffffff, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0xffffffff, 0xff000000, 0xff000000, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xffffffff, 0xffffffff, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0xffffffff,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff, 0x00000000,
+	0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xff000000, 0xff000000,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff,
+	0xffffffff, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xffffffff, 0xffffffff, 0xffffffff, 0xff000000, 0xff000000,
+	0xffffffff, 0xffffffff, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff,
+	0xffffffff, 0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0xffffffff,
+	0x00000000, 0x00000000, 0xffffffff, 0xff000000, 0xffffffff, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xffffffff, 0x00000000, 0xffffffff,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0xffffffff, 0x00000000, 0xffffffff, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0xffffffff, 0x00000000, 0xffffffff, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
+	0xff000000, 0xff000000, 0xff000000, 0xff000000, 0xffffffff, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xff000000,
+	0xff000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+	0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/cursor.pcf Added

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/meson.build Added

@@ -0,0 +1,47 @@
+icondir = get_option('icon_directory')
+if icondir == ''
+	icondir = join_paths(get_option('prefix'), get_option('datadir'), 'icons')
+endif
+
+if wayland_version0 != '1'
+	# The versioning used for the shared libraries assumes that the major
+	# version of Wayland as a whole will increase to 2 if and only if there
+	# is an ABI break, at which point we should probably bump the SONAME of
+	# all libraries to .so.2. For more details see
+	# https://gitlab.freedesktop.org/wayland/wayland/-/merge_requests/177
+	error('We probably need to bump the SONAME of libwayland-cursor')
+endif
+
+wayland_cursor = library(
+	'wayland-cursor',
+	sources: 
+		'wayland-cursor.c',
+		'os-compatibility.c',
+		'xcursor.c',
+	,
+	# To avoid an unnecessary SONAME bump, wayland 1.x.y produces
+	# libwayland-cursor.so.0.x.y.
+	version: '.'.join('0', wayland_version1, wayland_version2),
+	dependencies:  wayland_client_dep ,
+	c_args:  '-DICONDIR="@0@"'.format(icondir) ,
+	install: true,
+)
+
+install_headers('wayland-cursor.h')
+
+pkgconfig.generate(
+	name: 'Wayland Cursor',
+	description: 'Wayland cursor helper library',
+	version: meson.project_version(),
+	libraries: wayland_cursor,
+	filebase: 'wayland-cursor',
+)
+
+wayland_cursor_dep = declare_dependency(
+	link_with: wayland_cursor,
+	include_directories:  root_inc, include_directories('.') ,
+)
+
+if meson.version().version_compare('>= 0.54.0')
+	meson.override_dependency('wayland-cursor', wayland_cursor_dep)
+endif

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/os-compatibility.c Added

@@ -0,0 +1,203 @@
+/*
+ * Copyright © 2012 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+
+#include "config.h"
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef HAVE_MEMFD_CREATE
+#include <sys/mman.h>
+#endif
+
+#include "os-compatibility.h"
+
+#ifndef HAVE_MKOSTEMP
+static int
+set_cloexec_or_close(int fd)
+{
+	long flags;
+
+	if (fd == -1)
+		return -1;
+
+	flags = fcntl(fd, F_GETFD);
+	if (flags == -1)
+		goto err;
+
+	if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1)
+		goto err;
+
+	return fd;
+
+err:
+	close(fd);
+	return -1;
+}
+#endif
+
+static int
+create_tmpfile_cloexec(char *tmpname)
+{
+	int fd;
+
+#ifdef HAVE_MKOSTEMP
+	fd = mkostemp(tmpname, O_CLOEXEC);
+	if (fd >= 0)
+		unlink(tmpname);
+#else
+	fd = mkstemp(tmpname);
+	if (fd >= 0) {
+		fd = set_cloexec_or_close(fd);
+		unlink(tmpname);
+	}
+#endif
+
+	return fd;
+}
+
+/*
+ * Create a new, unique, anonymous file of the given size, and
+ * return the file descriptor for it. The file descriptor is set
+ * CLOEXEC. The file is immediately suitable for mmap()'ing
+ * the given size at offset zero.
+ *
+ * The file should not have a permanent backing store like a disk,
+ * but may have if XDG_RUNTIME_DIR is not properly implemented in OS.
+ *
+ * The file name is deleted from the file system.
+ *
+ * The file is suitable for buffer sharing between processes by
+ * transmitting the file descriptor over Unix sockets using the
+ * SCM_RIGHTS methods.
+ *
+ * If the C library implements posix_fallocate(), it is used to
+ * guarantee that disk space is available for the file at the
+ * given size. If disk space is insufficient, errno is set to ENOSPC.
+ * If posix_fallocate() is not supported, program may receive
+ * SIGBUS on accessing mmap()'ed file contents instead.
+ *
+ * If the C library implements memfd_create(), it is used to create the
+ * file purely in memory, without any backing file name on the file
+ * system, and then sealing off the possibility of shrinking it.  This
+ * can then be checked before accessing mmap()'ed file contents, to
+ * make sure SIGBUS can't happen.  It also avoids requiring
+ * XDG_RUNTIME_DIR.
+ */
+int
+os_create_anonymous_file(off_t size)
+{
+	static const char template = "/wayland-cursor-shared-XXXXXX";
+	const char *path;
+	char *name;
+	size_t name_size;
+	int fd;
+
+#ifdef HAVE_MEMFD_CREATE
+	fd = memfd_create("wayland-cursor", MFD_CLOEXEC | MFD_ALLOW_SEALING);
+	if (fd >= 0) {
+		/* We can add this seal before calling posix_fallocate(), as
+		 * the file is currently zero-sized anyway.
+		 *
+		 * There is also no need to check for the return value, we
+		 * couldn't do anything with it anyway.
+		 */
+		fcntl(fd, F_ADD_SEALS, F_SEAL_SHRINK | F_SEAL_SEAL);
+	} else
+#endif
+	{
+		path = getenv("XDG_RUNTIME_DIR");
+		if (!path || path0 != '/') {
+			errno = ENOENT;
+			return -1;
+		}
+
+		name_size = strlen(path) + sizeof(template);
+		name = malloc(name_size);
+		if (!name)
+			return -1;
+
+		snprintf(name, name_size, "%s%s", path, template);
+
+		fd = create_tmpfile_cloexec(name);
+
+		free(name);
+
+		if (fd < 0)
+			return -1;
+	}
+
+	if (os_resize_anonymous_file(fd, size) < 0) {
+		close(fd);
+		return -1;
+	}
+
+	return fd;
+}
+
+int
+os_resize_anonymous_file(int fd, off_t size)
+{
+#ifdef HAVE_POSIX_FALLOCATE
+	sigset_t mask;
+	sigset_t old_mask;
+
+	/*
+	 * posix_fallocate() might be interrupted, so we need to check
+	 * for EINTR and retry in that case.
+	 * However, in the presence of an alarm, the interrupt may trigger
+	 * repeatedly and prevent a large posix_fallocate() to ever complete
+	 * successfully, so we need to first block SIGALRM to prevent
+	 * this.
+	 */
+	sigemptyset(&mask);
+	sigaddset(&mask, SIGALRM);
+	sigprocmask(SIG_BLOCK, &mask, &old_mask);
+	/*
+	 * Filesystems that do not support fallocate will return EINVAL or
+	 * EOPNOTSUPP. In this case we need to fall back to ftruncate
+	 */
+	do {
+		errno = posix_fallocate(fd, 0, size);
+	} while (errno == EINTR);
+	sigprocmask(SIG_SETMASK, &old_mask, NULL);
+	if (errno == 0)
+		return 0;
+	else if (errno != EINVAL && errno != EOPNOTSUPP)
+		return -1;
+#endif
+	if (ftruncate(fd, size) < 0)

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/os-compatibility.h Added

@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2012 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef OS_COMPATIBILITY_H
+#define OS_COMPATIBILITY_H
+
+#include <sys/types.h>
+
+int
+os_create_anonymous_file(off_t size);
+
+int
+os_resize_anonymous_file(int fd, off_t size);
+
+#endif /* OS_COMPATIBILITY_H */

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/wayland-cursor.c Added

@@ -0,0 +1,516 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "config.h"
+#include "xcursor.h"
+#include "wayland-cursor.h"
+#include "wayland-client.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "os-compatibility.h"
+
+#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)0)
+
+struct shm_pool {
+	struct wl_shm_pool *pool;
+	int fd;
+	unsigned int size;
+	unsigned int used;
+	char *data;
+};
+
+static struct shm_pool *
+shm_pool_create(struct wl_shm *shm, int size)
+{
+	struct shm_pool *pool;
+
+	pool = malloc(sizeof *pool);
+	if (!pool)
+		return NULL;
+
+	pool->fd = os_create_anonymous_file(size);
+	if (pool->fd < 0)
+		goto err_free;
+
+	pool->data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+			  pool->fd, 0);
+
+	if (pool->data == MAP_FAILED)
+		goto err_close;
+
+	pool->pool = wl_shm_create_pool(shm, pool->fd, size);
+	pool->size = size;
+	pool->used = 0;
+
+	return pool;
+
+err_close:
+	close(pool->fd);
+err_free:
+	free(pool);
+	return NULL;
+}
+
+static int
+shm_pool_resize(struct shm_pool *pool, int size)
+{
+	if (os_resize_anonymous_file(pool->fd, size) < 0)
+		return 0;
+
+	wl_shm_pool_resize(pool->pool, size);
+
+	munmap(pool->data, pool->size);
+
+	pool->data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+			  pool->fd, 0);
+	if (pool->data == MAP_FAILED)
+		return 0;
+	pool->size = size;
+
+	return 1;
+}
+
+static int
+shm_pool_allocate(struct shm_pool *pool, int size)
+{
+	int offset;
+
+	if (pool->used + size > pool->size)
+		if (!shm_pool_resize(pool, 2 * pool->size + size))
+			return -1;
+
+	offset = pool->used;
+	pool->used += size;
+
+	return offset;
+}
+
+static void
+shm_pool_destroy(struct shm_pool *pool)
+{
+	munmap(pool->data, pool->size);
+	wl_shm_pool_destroy(pool->pool);
+	close(pool->fd);
+	free(pool);
+}
+
+
+struct wl_cursor_theme {
+	unsigned int cursor_count;
+	struct wl_cursor **cursors;
+	struct wl_shm *shm;
+	struct shm_pool *pool;
+	int size;
+};
+
+struct cursor_image {
+	struct wl_cursor_image image;
+	struct wl_cursor_theme *theme;
+	struct wl_buffer *buffer;
+	int offset; /* data offset of this image in the shm pool */
+};
+
+struct cursor {
+	struct wl_cursor cursor;
+	uint32_t total_delay; /* length of the animation in ms */
+};
+
+/** Get an shm buffer for a cursor image
+ *
+ * \param image The cursor image
+ * \return An shm buffer for the cursor image. The user should not destroy
+ * the returned buffer.
+ */
+WL_EXPORT struct wl_buffer *
+wl_cursor_image_get_buffer(struct wl_cursor_image *_img)
+{
+	struct cursor_image *image = (struct cursor_image *) _img;
+	struct wl_cursor_theme *theme = image->theme;
+
+	if (!image->buffer) {
+		image->buffer =
+			wl_shm_pool_create_buffer(theme->pool->pool,
+						  image->offset,
+						  _img->width, _img->height,
+						  _img->width * 4,
+						  WL_SHM_FORMAT_ARGB8888);
+	};
+
+	return image->buffer;
+}
+
+static void
+wl_cursor_image_destroy(struct wl_cursor_image *_img)
+{
+	struct cursor_image *image = (struct cursor_image *) _img;
+
+	if (image->buffer)
+		wl_buffer_destroy(image->buffer);
+
+	free(image);
+}
+
+static void
+wl_cursor_destroy(struct wl_cursor *cursor)
+{
+	unsigned int i;
+
+	for (i = 0; i < cursor->image_count; i++)
+		wl_cursor_image_destroy(cursor->imagesi);
+
+	free(cursor->images);
+	free(cursor->name);
+	free(cursor);
+}
+
+#include "cursor-data.h"
+
+static struct wl_cursor *
+wl_cursor_create_from_data(struct cursor_metadata *metadata,
+			   struct wl_cursor_theme *theme)

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/wayland-cursor.h Added

@@ -0,0 +1,96 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_CURSOR_H
+#define WAYLAND_CURSOR_H
+
+#include <stdint.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct wl_cursor_theme;
+struct wl_buffer;
+struct wl_shm;
+
+/** A still image part of a cursor
+ *
+ * Use `wl_cursor_image_get_buffer()` to get the corresponding `struct
+ * wl_buffer` to attach to your `struct wl_surface`. */
+struct wl_cursor_image {
+	/** Actual width */
+	uint32_t width;
+
+	/** Actual height */
+	uint32_t height;
+
+	/** Hot spot x (must be inside image) */
+	uint32_t hotspot_x;
+
+	/** Hot spot y (must be inside image) */
+	uint32_t hotspot_y;
+
+	/** Animation delay to next frame (ms) */
+	uint32_t delay;
+};
+
+/** A cursor, as returned by `wl_cursor_theme_get_cursor()` */
+struct wl_cursor {
+	/** How many images there are in this cursor’s animation */
+	unsigned int image_count;
+
+	/** The array of still images composing this animation */
+	struct wl_cursor_image **images;
+
+	/** The name of this cursor */
+	char *name;
+};
+
+struct wl_cursor_theme *
+wl_cursor_theme_load(const char *name, int size, struct wl_shm *shm);
+
+void
+wl_cursor_theme_destroy(struct wl_cursor_theme *theme);
+
+struct wl_cursor *
+wl_cursor_theme_get_cursor(struct wl_cursor_theme *theme,
+			   const char *name);
+
+struct wl_buffer *
+wl_cursor_image_get_buffer(struct wl_cursor_image *image);
+
+int
+wl_cursor_frame(struct wl_cursor *cursor, uint32_t time);
+
+int
+wl_cursor_frame_and_duration(struct wl_cursor *cursor, uint32_t time,
+			     uint32_t *duration);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/xcursor.c Added

@@ -0,0 +1,783 @@
+/*
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+#include "xcursor.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+
+/*
+ * Cursor files start with a header.  The header
+ * contains a magic number, a version number and a
+ * table of contents which has type and offset information
+ * for the remaining tables in the file.
+ *
+ * File minor versions increment for compatible changes
+ * File major versions increment for incompatible changes (never, we hope)
+ *
+ * Chunks of the same type are always upward compatible.  Incompatible
+ * changes are made with new chunk types; the old data can remain under
+ * the old type.  Upward compatible changes can add header data as the
+ * header lengths are specified in the file.
+ *
+ *  File:
+ *	FileHeader
+ *	LISTofChunk
+ *
+ *  FileHeader:
+ *	CARD32		magic	    magic number
+ *	CARD32		header	    bytes in file header
+ *	CARD32		version	    file version
+ *	CARD32		ntoc	    number of toc entries
+ *	LISTofFileToc   toc	    table of contents
+ *
+ *  FileToc:
+ *	CARD32		type	    entry type
+ *	CARD32		subtype	    entry subtype (size for images)
+ *	CARD32		position    absolute file position
+ */
+
+#define XCURSOR_MAGIC 0x72756358 /* "Xcur" LSBFirst */
+
+/*
+ * This version number is stored in cursor files; changes to the
+ * file format require updating this version number
+ */
+#define XCURSOR_FILE_MAJOR 1
+#define XCURSOR_FILE_MINOR 0
+#define XCURSOR_FILE_VERSION ((XCURSOR_FILE_MAJOR << 16) | (XCURSOR_FILE_MINOR))
+#define XCURSOR_FILE_HEADER_LEN (4 * 4)
+#define XCURSOR_FILE_TOC_LEN (3 * 4)
+
+struct xcursor_file_toc {
+	uint32_t type; /* chunk type */
+	uint32_t subtype; /* subtype (size for images) */
+	uint32_t position; /* absolute position in file */
+};
+
+struct xcursor_file_header {
+	uint32_t magic; /* magic number */
+	uint32_t header; /* byte length of header */
+	uint32_t version; /* file version number */
+	uint32_t ntoc; /* number of toc entries */
+	struct xcursor_file_toc *tocs; /* table of contents */
+};
+
+/*
+ * The rest of the file is a list of chunks, each tagged by type
+ * and version.
+ *
+ *  Chunk:
+ *	ChunkHeader
+ *	<extra type-specific header fields>
+ *	<type-specific data>
+ *
+ *  ChunkHeader:
+ *	CARD32	    header	bytes in chunk header + type header
+ *	CARD32	    type	chunk type
+ *	CARD32	    subtype	chunk subtype
+ *	CARD32	    version	chunk type version
+ */
+
+#define XCURSOR_CHUNK_HEADER_LEN (4 * 4)
+
+struct xcursor_chunk_header {
+	uint32_t header; /* bytes in chunk header */
+	uint32_t type; /* chunk type */
+	uint32_t subtype; /* chunk subtype (size for images) */
+	uint32_t version; /* version of this type */
+};
+
+/*
+ * Each cursor image occupies a separate image chunk.
+ * The length of the image header follows the chunk header
+ * so that future versions can extend the header without
+ * breaking older applications
+ *
+ *  Image:
+ *	ChunkHeader	header	chunk header
+ *	CARD32		width	actual width
+ *	CARD32		height	actual height
+ *	CARD32		xhot	hot spot x
+ *	CARD32		yhot	hot spot y
+ *	CARD32		delay	animation delay
+ *	LISTofCARD32	pixels	ARGB pixels
+ */
+
+#define XCURSOR_IMAGE_TYPE 0xfffd0002
+#define XCURSOR_IMAGE_VERSION 1
+#define XCURSOR_IMAGE_HEADER_LEN (XCURSOR_CHUNK_HEADER_LEN + (5*4))
+#define XCURSOR_IMAGE_MAX_SIZE 0x7fff /* 32767x32767 max cursor size */
+
+/*
+ * From libXcursor/src/file.c
+ */
+
+static struct xcursor_image *
+xcursor_image_create(int width, int height)
+{
+	struct xcursor_image *image;
+
+	if (width < 0 || height < 0)
+		return NULL;
+	if (width > XCURSOR_IMAGE_MAX_SIZE || height > XCURSOR_IMAGE_MAX_SIZE)
+		return NULL;
+
+	image = malloc(sizeof(struct xcursor_image) +
+		       width * height * sizeof(uint32_t));
+	if (!image)
+		return NULL;
+	image->version = XCURSOR_IMAGE_VERSION;
+	image->pixels = (uint32_t *) (image + 1);
+	image->size = width > height ? width : height;
+	image->width = width;
+	image->height = height;
+	image->delay = 0;
+	return image;
+}
+
+static void
+xcursor_image_destroy(struct xcursor_image *image)
+{
+	free(image);
+}
+
+static struct xcursor_images *
+xcursor_images_create(int size)
+{
+	struct xcursor_images *images;
+
+	images = malloc(sizeof(struct xcursor_images) +
+			size * sizeof(struct xcursor_image *));
+	if (!images)
+		return NULL;
+	images->nimage = 0;
+	images->images = (struct xcursor_image **) (images + 1);
+	images->name = NULL;
+	return images;
+}
+
+void
+xcursor_images_destroy(struct xcursor_images *images)
+{
+	int n;
+
+	if (!images)
+		return;
+
+	for (n = 0; n < images->nimage; n++)
+		xcursor_image_destroy(images->imagesn);
+	free(images->name);
+	free(images);
+}
+
+static bool

_service:tar_scm:wayland-1.21.0.tar.gz/cursor/xcursor.h Added

@@ -0,0 +1,58 @@
+/*
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef XCURSOR_H
+#define XCURSOR_H
+
+#include <stdint.h>
+
+struct xcursor_image {
+	uint32_t version; /* version of the image data */
+	uint32_t size; /* nominal size for matching */
+	uint32_t width; /* actual width */
+	uint32_t height; /* actual height */
+	uint32_t xhot; /* hot spot x (must be inside image) */
+	uint32_t yhot; /* hot spot y (must be inside image) */
+	uint32_t delay; /* animation delay to next frame (ms) */
+	uint32_t *pixels; /* pointer to pixels */
+};
+
+/*
+ * Other data structures exposed by the library API
+ */
+struct xcursor_images {
+	int nimage; /* number of images */
+	struct xcursor_image **images; /* array of XcursorImage pointers */
+	char *name; /* name used to load images */
+};
+
+void
+xcursor_images_destroy(struct xcursor_images *images);
+
+void
+xcursor_load_theme(const char *theme, int size,
+		   void (*load_callback)(struct xcursor_images *, void *),
+		   void *user_data);
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/doc Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/.gitignore Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/dot Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/dot/wayland-architecture.gv Added

@@ -0,0 +1,36 @@
+digraph arch_wayland {
+    edge
+        fontname="DejaVu Sans",
+        dir="both",
+        arrowtail="dot",
+        arrowsize=.5,
+        fontname="DejaVu Sans",
+        fontsize="18",
+    
+
+    node
+        color=none,
+        margin=0,
+        fontname="DejaVu Sans",
+        fontsize="18",
+   
+
+    c1 label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD>Wayland Client</TD></TR></TABLE>>, URL="#c1"
+    c2 label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD>Wayland Client</TD></TR></TABLE>>, URL="#c2"
+
+    comp tooltip="Wayland Compositor", label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD><BR/>Wayland<BR/>Compositor<BR/><BR/></TD></TR></TABLE>>, URL="#comp"
+
+    impl tooltip="KMS evdev Kernel", label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD>KMS</TD><TD>evdev</TD></TR><TR><TD COLSPAN="2">Kernel</TD></TR></TABLE>>, URL="#impl"
+
+    c1 -> comp taillabel="③", labeldistance=2.5, URL="#step_3";
+    c2 -> comp;
+
+    comp -> c1 label="②", URL="#step_2";
+    comp -> c2;
+
+    comp -> impl xlabel = "④", URL="#step_4";
+    comp -> impl style = invis, label="    ";
+    impl -> comp xlabel = "①", URL="#step_1";
+
+    c1 -> c2 style=invis;
+}

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/dot/x-architecture.gv Added

@@ -0,0 +1,53 @@
+digraph arch_x {
+    edge
+        fontname="DejaVu Sans",
+        dir="both",
+        arrowtail="dot",
+        arrowsize=.5,
+        fontname="DejaVu Sans",
+        fontsize="18",
+    
+
+    node
+        shape="none",
+        color=none,
+        margin=0,
+        fontname="DejaVu Sans",
+        fontsize="18",
+    
+
+    {
+        rank=same;
+        c1 label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD>X Client</TD></TR></TABLE>>, URL="#c1"
+        c3 label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD>X Client</TD></TR></TABLE>>, URL="#c3"
+    }
+    c2 label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD>X Client</TD></TR></TABLE>>, URL="#c2"
+
+    {
+        rank=same;
+        xserver tooltip="X Server", label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD><BR/>X Server<BR/><BR/></TD></TR></TABLE>>, URL="#xserver"
+        comp tooltip="Compositor", label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD><BR/>Compositor<BR/><BR/></TD></TR></TABLE>>, URL="#comp"
+    }
+
+    impl tooltip="KMS evdev Kernel", label=<<TABLE STYLE="rounded" BGCOLOR="#ffbc00"><TR><TD>KMS</TD><TD>evdev</TD></TR><TR><TD COLSPAN="2">Kernel</TD></TR></TABLE>>, URL="#impl"
+
+    c1 -> xserver taillabel="③", labeldistance=2, URL="#step_3";
+    c2 -> xserver;
+    c3 -> xserver;
+
+    xserver -> c1 taillabel="②", labeldistance=2, URL="#step_2";
+    xserver -> c2;
+    xserver -> c3;
+
+    xserver -> impl taillabel="⑥", labeldistance=1.75, URL="#step_6";
+    xserver -> impl style=invis, label="    ";
+    impl -> xserver taillabel="①", labeldistance=1.75, URL="#step_1";
+
+    xserver -> comp style=invis;
+    xserver -> comp taillabel="④", labeldistance=1.75, labelangle=-45, URL="#step_4";
+    comp -> xserver taillabel="⑤", URL="#step_5";
+    comp -> xserver style=invis
+
+    c1 -> c2 style=invis;
+    c3 -> c2 style=invis;
+ }

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/gen-doxygen.py Added

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+
+import argparse
+import datetime
+import errno
+import os
+import subprocess
+import sys
+
+# Custom configuration for each documentation format
+doxygen_templates = {
+    'xml': 
+        'GENERATE_XML=YES\n',
+        'XML_OUTPUT={format}/{section}\n',
+        'INPUT= {files}\n',
+    ,
+    'html': 
+        'GENERATE_HTML=YES\n',
+        'HTML_OUTPUT={format}/{section}\n',
+        'PROJECT_NAME=\"Wayland {section} API\"\n',
+        'INPUT= {files}\n',
+    ,
+    'man': 
+        'GENERATE_MAN=YES\n',
+        'MAN_OUTPUT={format}\n',
+        'MAN_SUBDIR=.\n',
+        'JAVADOC_AUTOBRIEF=NO\n',
+        'INPUT= {files}\n',
+    ,
+}
+
+def load_doxygen_file(doxyfile):
+    with open(doxyfile, 'r') as f:
+        res = f.readlines()
+    return res
+
+def get_template(outformat):
+    for (k,v) in doxygen_templates.items():
+        if outformat.startswith(k):
+            return v
+
+def gen_doxygen_file(data, outformat, section, files):
+    for l in get_template(outformat):
+        data.append(l.format(format=outformat, section=section, files=' '.join(files)))
+    return data
+
+parser = argparse.ArgumentParser(description='Generate docs with Doxygen')
+parser.add_argument('doxygen_file',
+                    help='The doxygen file to use')
+parser.add_argument('files',
+                    help='The list of files to parse',
+                    metavar='FILES',
+                    nargs='+')
+parser.add_argument('--builddir',
+                    help='The build directory',
+                    metavar='DIR',
+                    default='.')
+parser.add_argument('--section',
+                    help='The section to build',
+                    metavar='NAME',
+                    default='Client')
+parser.add_argument('--output-format',
+                    help='The output format: xml, html, man',
+                    metavar='FORMAT',
+                    default='xml')
+parser.add_argument('--stamp',
+                    help='Stamp file to output',
+                    metavar='STAMP_FILE',
+                    nargs='?',
+                    type=argparse.FileType('w'))
+
+args = parser.parse_args()
+
+# Merge the doxyfile with our custom templates
+conf = load_doxygen_file(args.doxygen_file)
+conf = gen_doxygen_file(conf, args.output_format, args.section, args.files)
+
+# Doxygen is not clever enough to create the directories it
+# needs beforehand
+try:
+    os.makedirs(os.path.join(args.builddir, args.output_format))
+except OSError as e:
+    if e.errno != errno.EEXIST:
+        raise e
+
+# Run Doxygen with the generated doxyfile
+cmd = subprocess.Popen('doxygen', '-', stdin=subprocess.PIPE)
+cmd.stdin.write(''.join(conf).encode('utf-8'))
+cmd.stdin.close()
+if cmd.wait() != 0:
+    sys.exit(1)
+
+# This is a bit of a hack; Doxygen will generate way more files than we
+# want to install, but there's no way to know how many at configuration
+# time. Since we want to install only the wl_* man pages anyway, we can
+# delete the other files and let Meson install the whole man3 subdirectory
+if args.output_format.startswith('man'):
+    manpath = os.path.join(args.builddir, args.output_format)
+    for filename in os.listdir(manpath):
+        full_path = os.path.join(manpath, filename)
+        if not filename.startswith('wl_'):
+            os.remove(full_path)
+
+if args.stamp:
+   args.stamp.write(str(datetime.datetime.now()))

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/mainpage.dox Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/meson.build Added

@@ -0,0 +1,117 @@
+# Here be dragons
+
+dot_gv = {
+	'wayland-architecture': files('dot/wayland-architecture.gv'),
+	'x-architecture': files('dot/x-architecture.gv'),
+}
+
+# This is a workaround for Meson's custom_target() directive, which
+# currently does not support outputs pointing to a sub-directory
+# XXX: try turning these into maps, so they can be indexed with picture name
+dot_png = 
+dot_map = 
+
+doxygen_conf = configuration_data()
+doxygen_conf.set('VERSION', meson.project_version())
+doxygen_conf.set('top_builddir', meson.project_build_root())
+wayland_doxygen = configure_file(
+	input: 'wayland.doxygen.in',
+	output: 'wayland.doxygen',
+	configuration: doxygen_conf,
+)
+
+shared_files = files(
+	'../../src/wayland-util.h',
+)
+
+client_files = files(
+	'../../src/wayland-client.c',
+	'../../src/wayland-client.h',
+	'../../src/wayland-client-core.h',
+)
+
+server_files = files(
+	'../../src/event-loop.c',
+	'../../src/wayland-server.c',
+	'../../src/wayland-server.h',
+	'../../src/wayland-server-core.h',
+	'../../src/wayland-shm.c',
+)
+
+cursor_files = files(
+	'../../cursor/wayland-cursor.c',
+	'../../cursor/wayland-cursor.h',
+)
+
+extra_client_files = 
+	'mainpage.dox',
+	wayland_client_protocol_h,
+
+
+extra_server_files = 
+	'mainpage.dox',
+	wayland_server_protocol_h,
+
+
+extra_cursor_files = 
+	'mainpage.dox',
+
+
+gen_doxygen = find_program('gen-doxygen.py')
+
+subdir('xml')
+
+formats = {
+	'html': {
+		'Client': shared_files + client_files + extra_client_files,
+		'Server': shared_files + server_files + extra_server_files,
+		'Cursor': shared_files + cursor_files + extra_cursor_files,
+	},
+}
+
+foreach f_name, sections: formats
+	foreach s_name, s_files: sections
+		t_name = '@0@-@1@-doc'.format(f_name, s_name)
+
+		# We do not really need an output file, but Meson
+		# will complain if one is not set, so we use a
+		# dummy 'stamp' file
+		stamp = join_paths(meson.current_build_dir(), '@0@.stamp'.format(t_name))
+		custom_target(
+			t_name,
+			command: 
+				gen_doxygen,
+				# XXX pass doxygen path as argument
+				'--builddir=@OUTDIR@',
+				'--section=@0@'.format(s_name),
+				'--output-format=@0@'.format(f_name),
+				'--stamp=@0@'.format(stamp),
+				wayland_doxygen,
+				'@INPUT@',
+			,
+			input: s_files,
+			output: '@0@.stamp'.format(t_name),
+			depends: dot_png, dot_map,
+			build_by_default: true,
+		)
+	endforeach
+endforeach
+
+man_files = shared_files + server_files + client_files + cursor_files
+stamp = join_paths(meson.current_build_dir(), 'man3.stamp')
+custom_target(
+	'man-pages-3',
+	command: 
+		gen_doxygen,
+		'--builddir=@OUTDIR@',
+		'--output-format=man3',
+		'--stamp=@0@'.format(stamp),
+		wayland_doxygen,
+		'@INPUT@',
+	,
+	input: man_files,
+	output: 'man3',
+	build_by_default: true,
+	install: true,
+	install_dir: join_paths(get_option('prefix'), get_option('mandir')),
+)

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/wayland.doxygen.in Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/xml/Client Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/xml/Client/meson.build Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/xml/Server Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/xml/Server/meson.build Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/doxygen/xml/meson.build Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/meson.build Added

@@ -0,0 +1,41 @@
+if not get_option('libraries')
+	error('-Ddocumentation=true requires -Dlibraries=true')
+endif
+
+dot = find_program('dot')
+doxygen = find_program('doxygen')
+xsltproc = find_program('xsltproc')
+xmlto = find_program('xmlto')
+
+cmd = run_command(doxygen, '--version', check: true)
+message('doxygen: ' + cmd.stdout().strip())
+vers = cmd.stdout().strip()
+if vers.version_compare('< 1.6.0')
+	error('Doxygen 1.6 or later is required for building documentation, found @0@.'.format(vers))
+endif
+
+cmd = run_command(dot, '-V', check: true)
+message('dot: ' + cmd.stderr().strip())
+vers = cmd.stderr().split('version')1.strip().split(' ')0
+if vers.version_compare('< 2.26.0')
+	error('Dot (Graphviz) 2.26 or later is required for building documentation, found @0@.'.format(vers))
+endif
+
+manpage_xsl = 'http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl'
+cmd = run_command(xsltproc, '--nonet', manpage_xsl, check: false)
+if cmd.returncode() != 0
+	error('The style sheet for man pages providing "@0@" was not found.'.format(manpage_xsl))
+endif
+
+publican_install_prefix = join_paths(
+	get_option('prefix'),
+	get_option('datadir'),
+	'doc',
+	meson.project_name(),
+	'Wayland', 'en-US'
+)
+
+publican_html_dir = 'html'
+
+subdir('doxygen')
+subdir('publican')

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/.gitignore Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/doxygen-to-publican.xsl Added

@@ -0,0 +1,147 @@
+<?xml version="1.0" ?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="xml" encoding="UTF-8" indent="yes" />
+<xsl:param name="which" />
+
+<xsl:template match="/">
+  <xsl:apply-templates select="/doxygen/compounddef@kind!='file' and @kind!='dir'" />
+
+  <section id="{$which}-Functions">
+    <title>Functions</title>
+    <para />
+    <variablelist>
+      <xsl:apply-templates select="/doxygen/compounddef@kind='file'/sectiondef/memberdef" />
+    </variablelist>
+  </section>
+
+</xsl:template>
+
+<xsl:template match="parameteritem">
+    <varlistentry>
+        <term>
+          <xsl:apply-templates select="parameternamelist/parametername"/>
+        </term>
+      <listitem>
+        <simpara><xsl:apply-templates select="parameterdescription"/></simpara>
+      </listitem>
+    </varlistentry>
+</xsl:template>
+
+<xsl:template match="parameterlist">
+  <xsl:if test="parameteritem">
+      <variablelist>
+        <xsl:apply-templates select="parameteritem" />
+      </variablelist>
+  </xsl:if>
+</xsl:template>
+
+<xsl:template match="ref">
+  <link linkend="{$which}-{@refid}"><xsl:value-of select="." /></link>
+</xsl:template>
+
+<xsl:template match="simplesect@kind='return'">
+  <variablelist>
+    <varlistentry>
+      <term>Returns:</term>
+      <listitem>
+        <simpara><xsl:apply-templates /></simpara>
+      </listitem>
+    </varlistentry>
+  </variablelist>
+</xsl:template>
+
+<xsl:template match="simplesect@kind='see'">
+  See also: <xsl:apply-templates />
+</xsl:template>
+
+<xsl:template match="simplesect@kind='since'">
+  Since: <xsl:apply-templates />
+</xsl:template>
+
+<xsl:template match="simplesect@kind='note'">
+  <emphasis>Note: <xsl:apply-templates /></emphasis>
+</xsl:template>
+
+<xsl:template match="sp">
+  <xsl:text> </xsl:text>
+</xsl:template>
+
+<xsl:template match="programlisting">
+  <programlisting><xsl:apply-templates /></programlisting>
+</xsl:template>
+
+<xsl:template match="itemizedlist">
+  <itemizedlist><xsl:apply-templates select="listitem" /></itemizedlist>
+</xsl:template>
+
+<xsl:template match="listitem">
+  <listitem><simpara><xsl:apply-templates /></simpara></listitem>
+</xsl:template>
+
+
+<xsl:template match="briefdescription">
+  <xsl:value-of select="." />
+</xsl:template>
+
+
+<xsl:template match="detaileddescription/para">
+  <para><xsl:apply-templates /></para>
+</xsl:template>
+
+<xsl:template match="detaileddescription">
+  <xsl:apply-templates select="para" />
+</xsl:template>
+
+
+<xsl:template match="memberdef" >
+  <xsl:if test="@kind = 'function' and @static = 'no' and @prot = 'public' or
+                @kind !='function' and normalize-space(briefdescription) != ''">
+    <varlistentry id="{$which}-{@id}">
+        <term>
+          <xsl:value-of select="name"/>
+          <xsl:if test="normalize-space(briefdescription) != ''">
+            - <xsl:apply-templates select="briefdescription" />
+          </xsl:if>
+        </term>
+        <listitem>
+          <synopsis>
+            <xsl:apply-templates select="definition"/><xsl:apply-templates select="argsstring"/>
+          </synopsis>
+          <xsl:apply-templates select="detaileddescription" />
+        </listitem>
+    </varlistentry>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match="compounddef" >
+    <section id="{$which}-{@id}">
+        <title>
+            <xsl:value-of select="compoundname" />
+            <xsl:if test="normalize-space(briefdescription) != ''">
+                - <xsl:apply-templates select="briefdescription" />
+            </xsl:if>
+        </title>
+        <xsl:choose>
+          <xsl:when test="normalize-space(detaileddescription) != ''">
+            <xsl:apply-templates select="detaileddescription" />
+          </xsl:when>
+          <xsl:otherwise>
+            <para />
+          </xsl:otherwise>
+        </xsl:choose>
+        <xsl:if test="sectiondef/memberdef@kind='function' and @static='no'">
+          <variablelist>
+            <xsl:apply-templates select="sectiondef/memberdef" />
+          </variablelist>
+        </xsl:if>
+    </section>
+</xsl:template>
+</xsl:stylesheet>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/merge-mapcoords.xsl Added

@@ -0,0 +1,64 @@
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:param name="basedir"/>
+  <xsl:output method="xml" encoding="utf-8" indent="yes"/>
+  
+  
+  <xsl:template match="/">
+    <xsl:text disable-output-escaping="yes"><!CDATA<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+<!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+></xsl:text>
+    <xsl:apply-templates select="@*|node()"/>
+  </xsl:template>
+  
+  <xsl:template match="@*|node()">
+    <xsl:copy>
+      <xsl:apply-templates select="@*|node()"/>
+    </xsl:copy>
+  </xsl:template>
+  
+  
+  <xsl:template match="area"/>
+  
+  <xsl:template match="areaspecareaname(..)='imageobjectco'">
+    <xsl:element name="areaspec">
+      <xsl:apply-templates select="@*"/>
+      <xsl:text>&#xa;</xsl:text>
+      <xsl:variable name="pngfile" select="../imageobject/imagedata/@fileref"/>
+      <xsl:variable name="mapfile" select="concat(substring($pngfile, 1, string-length($pngfile)-3), 'map')"/>
+      <xsl:variable name="maproot" select="document(concat($basedir, '/', $mapfile))"/>
+      
+      
+      <xsl:for-each select="area">
+	<xsl:variable name="anchor" select="."/>
+	<xsl:variable name="other" select="($maproot)//area@href=($anchor)/@x_steal"/>
+	<xsl:choose>
+	  <xsl:when test="$other">
+	    <xsl:text>&#x9;    </xsl:text>
+	    <xsl:element name="area">
+	      <xsl:attribute name="id">
+		<xsl:value-of select="@id"/>
+	      </xsl:attribute>
+	      <xsl:attribute name="linkends">
+		<xsl:value-of select="@linkends"/>
+	      </xsl:attribute>
+	      <xsl:attribute name="coords">
+		<xsl:value-of select="($other)/@coords"/>
+	      </xsl:attribute>
+	    </xsl:element>
+	  </xsl:when>
+	  <xsl:otherwise>
+	    <xsl:text>&#x9;    </xsl:text>
+	    <xsl:comment>
+	      <xsl:value-of select="concat('Warning: unable to locate area tagged ', ($anchor)/@x_steal)"/>
+	    </xsl:comment>
+	  </xsl:otherwise>
+	</xsl:choose>
+	<xsl:text>&#xa;</xsl:text>
+      </xsl:for-each>
+      
+      <xsl:text>&#x9;  </xsl:text>
+    </xsl:element>
+  </xsl:template>
+</xsl:stylesheet>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/meson.build Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/protocol-interfaces-to-docbook.xsl Added

@@ -0,0 +1,51 @@
+<?xml version="1.0" ?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="xml" encoding="UTF-8" indent="yes" />
+
+<xsl:template match="/">
+  
+    <xsl:text disable-output-escaping = "yes"><!CDATA
+<!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+  <!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+></xsl:text>
+
+  <section id="sect-Protocol-Interfaces">
+    <title>Interfaces</title>
+    <para>
+      The protocol includes several interfaces which are used for
+      interacting with the server.  Each interface provides requests,
+      events, and errors (which are really just special events) as described
+      above.  Specific compositor implementations may have their own
+      interfaces provided as extensions, but there are several which are
+      always expected to be present.
+    </para>
+
+    <para>
+      Core interfaces:
+      <variablelist>
+        <xsl:apply-templates select="protocol/interface" />
+      </variablelist>
+    </para>
+  </section>
+</xsl:template>
+
+
+<xsl:template match="interface" >
+<varlistentry>
+  <term>
+    <link linkend="protocol-spec-{@name}">
+      <xsl:value-of select="@name" />
+    </link>
+  </term>
+  <listitem>
+    <simpara>
+      <xsl:value-of select="description/@summary" />
+    </simpara>
+  </listitem>
+</varlistentry>
+</xsl:template>
+
+</xsl:stylesheet>
+

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/protocol-to-docbook.xsl Added

@@ -0,0 +1,223 @@
+<?xml version="1.0" ?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="xml" encoding="UTF-8" indent="yes" />
+
+<xsl:template match="/">
+  
+    <xsl:text disable-output-escaping = "yes"><!CDATA
+<!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+  <!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+></xsl:text>
+
+  <appendix id="appe-Wayland-Protocol">
+    <title>Wayland Protocol Specification</title>
+    <xsl:apply-templates select="protocol/copyright" />
+
+    <xsl:apply-templates select="protocol/interface" />
+  </appendix>
+</xsl:template>
+
+
+<xsl:template name="break">
+     <xsl:param name="text" />
+     <xsl:param name="linebreak" select="'&#10;&#10;'" />
+     <xsl:choose>
+       <xsl:when test="contains($text,$linebreak)">
+         <para>
+           <xsl:value-of select="substring-before($text,$linebreak)" />
+         </para>
+         <xsl:call-template name="break">
+           <xsl:with-param name="text" select="substring-after($text,$linebreak)" />
+         </xsl:call-template>
+       </xsl:when>
+       <xsl:otherwise>
+         <para><xsl:value-of select="$text" /></para>
+       </xsl:otherwise>
+     </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match="copyright">
+  <para>
+    <literallayout>
+      <xsl:value-of select="." disable-output-escaping="yes"/>
+    </literallayout>
+  </para>
+</xsl:template>
+
+
+<xsl:template match="interface" >
+  <section id="protocol-spec-{@name}">
+    <title>
+      <xsl:value-of select="@name" />
+      
+      <xsl:if test="description/@summary">
+	- <xsl:value-of select="description/@summary" />
+      </xsl:if>
+    </title>
+    <xsl:call-template name="break">
+      <xsl:with-param name="text" select="description" />
+    </xsl:call-template>
+    <xsl:if test="request">
+      <section>
+        <title>Requests provided by <xsl:value-of select="@name" /></title>
+        <xsl:apply-templates select="request" />
+      </section>
+    </xsl:if>
+    <xsl:if test="event">
+      <section>
+        <title>Events provided by <xsl:value-of select="@name" /></title>
+        <xsl:apply-templates select="event" />
+      </section>
+    </xsl:if>
+    <xsl:if test="enum">
+      <section>
+        <title>Enums provided by <xsl:value-of select="@name" /></title>
+      <xsl:apply-templates select="enum" />
+      </section>
+    </xsl:if>
+  </section>
+</xsl:template>
+
+
+<xsl:template match="entry">
+  <varlistentry>
+    <term><xsl:value-of select="@name"/></term>
+    <listitem>
+      <simpara>
+        <xsl:value-of select="@value"/>
+        <xsl:if test="@summary" >
+          - <xsl:value-of select="@summary"/>
+        </xsl:if>
+      </simpara>
+    </listitem>
+  </varlistentry>
+</xsl:template>
+
+
+<xsl:template match="arg">
+  <varlistentry>
+    <term><xsl:value-of select="@name"/></term>
+    <listitem>
+        <simpara>
+          <xsl:value-of select="@type"/>
+          <xsl:if test="@summary" >
+            - <xsl:value-of select="@summary"/>
+          </xsl:if>
+        </simpara>
+    </listitem>
+  </varlistentry>
+</xsl:template>
+
+
+<xsl:template match="arg@type='object' and @interface">
+  <varlistentry>
+    <term><xsl:value-of select="@name"/></term>
+    <listitem>
+        <simpara>
+          <link linkend="protocol-spec-{@interface}">
+            <xsl:value-of select="@interface"/>
+          </link>
+          <xsl:if test="@summary" >
+            - <xsl:value-of select="@summary"/>
+          </xsl:if>
+        </simpara>
+    </listitem>
+  </varlistentry>
+</xsl:template>
+
+
+<xsl:template match="arg@type='new_id' and @interface">
+  <varlistentry>
+    <term><xsl:value-of select="@name"/></term>
+    <listitem>
+        <simpara>
+          id for the new
+          <link linkend="protocol-spec-{@interface}">
+            <xsl:value-of select="@interface"/>
+          </link>
+          <xsl:if test="@summary" >
+            - <xsl:value-of select="@summary"/>
+          </xsl:if>
+        </simpara>
+    </listitem>
+  </varlistentry>
+</xsl:template>
+
+
+<xsl:template match="arg@enum">
+  <varlistentry>
+    <term><xsl:value-of select="@name"/></term>
+    <listitem>
+        <simpara>
+          <xsl:choose>
+            <xsl:when test="contains(@enum, '.')">
+              <link linkend="protocol-spec-{substring-before(@enum, '.')}-enum-{substring-after(@enum, '.')}">
+                <xsl:value-of select="substring-before(@enum, '.')"/>
+                <xsl:text>::</xsl:text>
+                <xsl:value-of select="substring-after(@enum, '.')"/>
+              </link>
+            </xsl:when>
+            <xsl:otherwise>
+              <link linkend="protocol-spec-{../../@name}-enum-{@enum}">
+                <xsl:value-of select="../../@name"/>
+                <xsl:text>::</xsl:text>
+                <xsl:value-of select="@enum"/>
+              </link>
+            </xsl:otherwise>
+          </xsl:choose>
+          (<xsl:value-of select="@type"/>)
+          <xsl:if test="@summary" >
+            - <xsl:value-of select="@summary"/>
+          </xsl:if>
+        </simpara>
+    </listitem>
+  </varlistentry>
+</xsl:template>
+
+
+<xsl:template match="request|event">
+  <section id="protocol-spec-{../@name}-{name()}-{@name}">
+    <title>
+      <xsl:value-of select="../@name"/>::<xsl:value-of select="@name" />
+      <xsl:if test="description/@summary">
+        - <xsl:value-of select="description/@summary" />
+      </xsl:if>
+    </title>
+    <para>
+      <variablelist>
+        <xsl:apply-templates select="arg"/>
+      </variablelist>
+    </para>
+    <xsl:call-template name="break">
+      <xsl:with-param name="text" select="description" />
+    </xsl:call-template>
+  </section>
+</xsl:template>
+

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Architecture.xml Added

@@ -0,0 +1,344 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+<!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+<chapter id="chap-Wayland-Architecture">
+  <title>Wayland Architecture</title>
+  <section id="sect-Wayland-Architecture-wayland_architecture">
+    <title>X vs. Wayland Architecture</title>
+    <para>
+      A good way to understand the Wayland architecture
+      and how it is different from X is to follow an event
+      from the input device to the point where the change
+      it affects appears on screen.
+    </para>
+    <para>
+      This is where we are now with X:
+    </para>
+    <figure>
+      <title>X architecture diagram</title>
+      <mediaobjectco>
+	<imageobjectco>
+	  <areaspec id="map1" units="other" otherunits="imagemap">
+	    <area id="area1_1" linkends="x_flow_1" x_steal="#step_1"/>
+	    <area id="area1_2" linkends="x_flow_2" x_steal="#step_2"/>
+	    <area id="area1_3" linkends="x_flow_3" x_steal="#step_3"/>
+	    <area id="area1_4" linkends="x_flow_4" x_steal="#step_4"/>
+	    <area id="area1_5" linkends="x_flow_5" x_steal="#step_5"/>
+	    <area id="area1_6" linkends="x_flow_6" x_steal="#step_6"/>
+	  </areaspec>
+	  <imageobject>
+	    <imagedata fileref="images/x-architecture.png" format="PNG" />
+	  </imageobject>
+	</imageobjectco>
+      </mediaobjectco>
+    </figure>
+    <para>
+      <orderedlist>
+	<listitem id="x_flow_1">
+	  <para>
+	    The kernel gets an event from an input
+	    device and sends it to X through the evdev
+	    input driver. The kernel does all the hard
+	    work here by driving the device and
+	    translating the different device specific
+	    event protocols to the linux evdev input
+	    event standard.
+	  </para>
+	</listitem>
+	<listitem id="x_flow_2">
+	  <para>
+	    The X server determines which window the
+	    event affects and sends it to the clients
+	    that have selected for the event in question
+	    on that window. The X server doesn't
+	    actually know how to do this right, since
+	    the window location on screen is controlled
+	    by the compositor and may be transformed in
+	    a number of ways that the X server doesn't
+	    understand (scaled down, rotated, wobbling,
+	    etc).
+	  </para>
+	</listitem>
+	<listitem id="x_flow_3">
+	  <para>
+	    The client looks at the event and decides
+	    what to do. Often the UI will have to change
+	    in response to the event - perhaps a check
+	    box was clicked or the pointer entered a
+	    button that must be highlighted. Thus the
+	    client sends a rendering request back to the
+	    X server.
+	  </para>
+	</listitem>
+	<listitem id="x_flow_4">
+	  <para>
+	    When the X server receives the rendering
+	    request, it sends it to the driver to let it
+	    program the hardware to do the rendering.
+	    The X server also calculates the bounding
+	    region of the rendering, and sends that to
+	    the compositor as a damage event.
+	  </para>
+	</listitem>
+	<listitem id="x_flow_5">
+	  <para>
+	    The damage event tells the compositor that
+	    something changed in the window and that it
+	    has to recomposite the part of the screen
+	    where that window is visible. The compositor
+	    is responsible for rendering the entire
+	    screen contents based on its scenegraph and
+	    the contents of the X windows. Yet, it has
+	    to go through the X server to render this.
+	  </para>
+	</listitem>
+	<listitem id="x_flow_6">
+	  <para>
+	    The X server receives the rendering requests
+	    from the compositor and either copies the
+	    compositor back buffer to the front buffer
+	    or does a pageflip. In the general case, the
+	    X server has to do this step so it can
+	    account for overlapping windows, which may
+	    require clipping and determine whether or
+	    not it can page flip. However, for a
+	    compositor, which is always fullscreen, this
+	    is another unnecessary context switch.
+	  </para>
+	</listitem>
+      </orderedlist>
+    </para>
+    <para>
+      As suggested above, there are a few problems with this
+      approach. The X server doesn't have the information to
+      decide which window should receive the event, nor can it
+      transform the screen coordinates to window-local
+      coordinates. And even though X has handed responsibility for
+      the final painting of the screen to the compositing manager,
+      X still controls the front buffer and modesetting. Most of
+      the complexity that the X server used to handle is now
+      available in the kernel or self contained libraries (KMS,
+      evdev, mesa, fontconfig, freetype, cairo, Qt etc). In
+      general, the X server is now just a middle man that
+      introduces an extra step between applications and the
+      compositor and an extra step between the compositor and the
+      hardware.
+    </para>
+    <para>
+      In Wayland the compositor is the display server. We transfer
+      the control of KMS and evdev to the compositor. The Wayland
+      protocol lets the compositor send the input events directly
+      to the clients and lets the client send the damage event
+      directly to the compositor:
+    </para>
+    <figure>
+      <title>Wayland architecture diagram</title>
+      <mediaobjectco>
+	<imageobjectco>
+	  <areaspec id="mapB" units="other" otherunits="imagemap">
+	    <area id="areaB_1" linkends="wayland_flow_1" x_steal="#step_1"/>
+	    <area id="areaB_2" linkends="wayland_flow_2" x_steal="#step_2"/>
+	    <area id="areaB_3" linkends="wayland_flow_3" x_steal="#step_3"/>
+	    <area id="areaB_4" linkends="wayland_flow_4" x_steal="#step_4"/>
+	  </areaspec>
+	  <imageobject>
+	    <imagedata fileref="images/wayland-architecture.png" format="PNG" />
+	  </imageobject>
+	</imageobjectco>
+      </mediaobjectco>
+    </figure>
+    <para>
+      <orderedlist>
+	<listitem id="wayland_flow_1">
+	  <para>
+	    The kernel gets an event and sends
+	    it to the compositor. This
+	    is similar to the X case, which is
+	    great, since we get to reuse all the
+	    input drivers in the kernel.
+	  </para>
+	</listitem>
+	<listitem id="wayland_flow_2">
+	  <para>
+	    The compositor looks through its
+	    scenegraph to determine which window
+	    should receive the event. The
+	    scenegraph corresponds to what's on
+	    screen and the compositor
+	    understands the transformations that
+	    it may have applied to the elements
+	    in the scenegraph. Thus, the
+	    compositor can pick the right window
+	    and transform the screen coordinates
+	    to window-local coordinates, by
+	    applying the inverse
+	    transformations. The types of
+	    transformation that can be applied
+	    to a window is only restricted to
+	    what the compositor can do, as long
+	    as it can compute the inverse
+	    transformation for the input events.
+	  </para>
+	</listitem>
+	<listitem id="wayland_flow_3">
+	  <para>
+	    As in the X case, when the client
+	    receives the event, it updates the
+	    UI in response. But in the Wayland
+	    case, the rendering happens in the
+	    client, and the client just sends a
+	    request to the compositor to
+	    indicate the region that was
+	    updated.
+	  </para>
+	</listitem>
+	<listitem id="wayland_flow_4">
+	  <para>
+	    The compositor collects damage

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Author_Group.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Book_Info.xml Added

@@ -0,0 +1,71 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE bookinfo PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+<!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+<bookinfo id="book-Wayland-Wayland">
+  <title>Wayland</title>
+  <subtitle>The Wayland Protocol</subtitle>
+  <productname>Documentation</productname>
+  <productnumber>0.1</productnumber>
+  <edition>1</edition>
+  <pubsnumber>0</pubsnumber>
+  <abstract>
+    <para>
+      Wayland is a protocol for a compositor to talk to
+      its clients as well as a C library implementation of
+      that protocol. The compositor can be a standalone
+      display server running on Linux kernel modesetting
+      and evdev input devices, an X application, or a
+      Wayland client itself. The clients can be
+      traditional applications, X servers (rootless or
+      fullscreen) or other display servers.
+    </para>
+  </abstract>
+  <corpauthor>
+    <inlinemediaobject>
+      <imageobject>
+	<imagedata fileref="images/wayland.png" format="PNG" />
+      </imageobject>
+      <textobject>
+	<phrase>
+	  Wayland logo
+	</phrase>
+      </textobject>
+    </inlinemediaobject>
+  </corpauthor>
+
+  <legalnotice lang="en-US">
+    <para>
+      Copyright <trademark class="copyright"></trademark> &YEAR; &HOLDER;
+    </para>
+
+	<para>
+	  Permission is hereby granted, free of charge, to any person obtaining a
+	  copy of this software and associated documentation files (the "Software"),
+	  to deal in the Software without restriction, including without limitation
+	  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+	  and/or sell copies of the Software, and to permit persons to whom the
+	  Software is furnished to do so, subject to the following conditions:
+	</para>
+
+	<para>
+	  The above copyright notice and this permission notice (including the next
+	  paragraph) shall be included in all copies or substantial portions of the
+	  Software.
+	</para>
+
+	<para>
+	  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+	  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+	  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+	  DEALINGS IN THE SOFTWARE.
+	</para>
+  </legalnotice>
+
+
+  <xi:include href="Author_Group.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+</bookinfo>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Client.xml Added

@@ -0,0 +1,92 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+  <!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+  <!ENTITY doxygen SYSTEM "ClientAPI.xml">
+%BOOK_ENTITIES;
+>
+<appendix id="sect-Library-Client">
+  <title>Client API</title>
+  <section><title>Introduction</title>
+  <para>
+    The open-source reference implementation of Wayland protocol is
+    split in two C libraries, libwayland-client and <link
+    linkend="sect-Library-Server">libwayland-server</link>. Their main
+    responsibility is to handle the Inter-process communication
+    (<emphasis>IPC</emphasis>) with each other, therefore guaranteeing
+    the protocol objects marshaling and messages synchronization.
+  </para>
+  <para>
+    A client uses libwayland-client to communicate with one or more
+    wayland servers. A <link
+    linkend="Client-classwl__display">wl_display</link> object is
+    created and manages each open connection to a server. At least one
+    <link linkend="Client-classwl__event__queue">wl_event_queue</link>
+    object is created for each wl_display, this holds events as they
+    are received from the server until they can be
+    processed. Multi-threading is supported by creating an additional
+    wl_event_queue for each additional thread, each object can have
+    it's events placed in a particular queue, so potentially a
+    different thread could be made to handle the events for each
+    object created.
+  </para>
+  <para>
+    Though some convenience functions are provided, libwayland-client
+    is designed to allow the calling code to wait for events, so that
+    different polling mechanisms can be used. A file descriptor is
+    provided, when it becomes ready for reading the calling code can
+    ask libwayland-client to read the available events from it into
+    the wl_event_queue objects.
+  </para>
+  <para>
+    The library only provides low-level access to the wayland objects.
+    Each object created by the client is represented by a <link
+    linkend="Client-classwl__proxy">wl_proxy</link> object that this
+    library creates. This includes the id that is actually
+    communicated over the socket to the server, a void* data pointer
+    that is intended to point at a client's representation of the
+    object, and a pointer to a static <link
+    linkend="Client-structwl__interface">wl_interface</link> object,
+    which is generated from the xml and identifies the object's class
+    and can be used for introspection into the messages and events.
+  </para>
+  <para>
+    Messages are sent by calling wl_proxy_marshal. This will write a
+    message to the socket, by using the message id and the
+    wl_interface to identify the types of each argument and convert
+    them into stream format.  Most software will call type-safe
+    wrappers generated from the xml description of the <link
+    linkend="appe-Wayland-Protocol">Wayland protocols</link>. For
+    instance the C header file generated from the xml defines the
+    following inline function to transmit the <link
+    linkend="protocol-spec-wl_surface-request-attach">wl_surface::attach</link>
+    message:
+  </para>
+  <programlisting>static inline void
+wl_surface_attach(struct wl_surface *wl_surface, struct wl_buffer *buffer, int32_t x, int32_t y)
+{
+  wl_proxy_marshal((struct wl_proxy *) wl_surface, WL_SURFACE_ATTACH, buffer, x, y);
+}</programlisting>
+  <para>
+    Events (messages from the server) are handled by calling a
+    "dispatcher" callback the client stores in the wl_proxy for each
+    event. A language binding for a string-based interpreter, such as
+    CPython, might have a dispatcher that uses the event name from the
+    wl_interface to identify the function to call. The default
+    dispatcher uses the message id number to index an array of
+    functions pointers, called a wl_listener, and the wl_interface to
+    convert data from the stream into arguments to the function. The
+    C header file generated from the xml defines a per-class structure
+    that forces the function pointers to be of the correct type, for
+    instance the <link
+    linkend="protocol-spec-wl_surface-event-enter">wl_surface::enter</link>
+    event defines this pointer in the wl_surface_listener object:
+  </para>
+  <programlisting>struct wl_surface_listener {
+  void (*enter)(void *data, struct wl_surface *, struct wl_output *);
+  ...
+}</programlisting>
+  <para>
+  </para>
+  </section>
+  &doxygen;
+</appendix>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Compositors.xml Added

@@ -0,0 +1,128 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+<!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+<chapter id="chap-Compositors">
+  <title>Types of Compositors</title>
+
+  <para>
+    Compositors come in different types, depending on which
+    role they play in the overall architecture of the OS.
+    For instance, a
+    <link linkend="sect-Compositors-System-Compositor">system compositor</link>
+    can be used for booting the system, handling multiple user switching, a
+    possible console terminal emulator and so forth. A different compositor, a
+    <link linkend="sect-Compositors-Session-Compositor">session compositor</link>
+    would provide the actual desktop environment. There are many ways for
+    different types of compositors to co-exist.
+  </para>
+  <para>
+    In this section, we introduce three types of Wayland compositors relying
+    on <link linkend="sect-Library-Server">libwayland-server</link>.
+  </para>
+
+  <section id="sect-Compositors-System-Compositor">
+    <title>System Compositor</title>
+    <para>
+      A system compositor can run from early boot until shutdown.
+      It effectively replaces the kernel vt system, and can tie in
+      with the systems graphical boot setup and multiseat support.
+    </para>
+    <para>
+      A system compositor can host different types of session
+      compositors, and let us switch between multiple sessions
+      (fast user switching, or secure/personal desktop switching).
+    </para>
+    <para>
+      A linux implementation of a system compositor will typically
+      use libudev, egl, kms, evdev and cairo.
+    </para>
+    <para>
+      For fullscreen clients, the system compositor can reprogram the
+      video scanout address to read directly from the client provided
+      buffer.
+    </para>
+  </section>
+  <section id="sect-Compositors-Session-Compositor">
+    <title>Session Compositor</title>
+    <para>
+      A session compositor is responsible for a single user session.
+      If a system compositor is present, the session compositor will
+      run nested under the system compositor. Nesting is feasible because
+      the protocol is asynchronous; roundtrips would be too expensive
+      when nesting is involved. If no system compositor is present, a
+      session compositor can run directly on the hardware.
+     </para>
+     <para>
+      X applications can continue working under a session compositor
+      by means of a root-less X server that is activated on demand.
+     </para>
+    <para>
+       Possible examples for session compositors include
+      <itemizedlist>
+	<listitem>
+	  <para>
+	    gnome-shell
+	  </para>
+	</listitem>
+	<listitem>
+	  <para>
+	    moblin
+	  </para>
+	</listitem>
+	<listitem>
+	  <para>
+	    kwin
+	  </para>
+	</listitem>
+	<listitem>
+	  <para>
+	    kmscon
+	  </para>
+	</listitem>
+	<listitem>
+	  <para>
+	    rdp session
+	  </para>
+	</listitem>
+	<listitem>
+	  <para>
+	    Weston with X11 or Wayland backend is a session compositor nested
+	    in another session compositor.
+	  </para>
+	</listitem>
+	<listitem>
+	  <para>
+	    fullscreen X session under Wayland
+	  </para>
+	</listitem>
+      </itemizedlist>
+    </para>
+  </section>
+  <section id="sect-Compositors-Embedding-Compositor">
+    <title>Embedding Compositor</title>
+    <para>
+      X11 lets clients embed windows from other clients, or lets clients
+      copy pixmap contents rendered by another client into their window.
+      This is often used for applets in a panel, browser plugins and similar.
+      Wayland doesn't directly allow this, but clients can communicate GEM
+      buffer names out-of-band, for example, using D-Bus, or command line
+      arguments when the panel launches the applet.  Another option is to
+      use a nested Wayland instance.  For this, the Wayland server will have
+      to be a library that the host application links to.  The host
+      application will then pass the Wayland server socket name to the
+      embedded application, and will need to implement the Wayland
+      compositor interface.  The host application composites the client
+      surfaces as part of it's window, that is, in the web page or in the
+      panel.  The benefit of nesting the Wayland server is that it provides
+      the requests the embedded client needs to inform the host about buffer
+      updates and a mechanism for forwarding input events from the host
+      application.
+    </para>
+    <para>
+      An example for this kind of setup is firefox embedding the flash
+      player as a kind of special-purpose compositor.
+    </para>
+  </section>
+</chapter>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Foreword.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Introduction.xml Added

@@ -0,0 +1,116 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+<!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+<chapter id="chap-Introduction">
+  <title>Introduction</title>
+  <section id="sect-Motivation">
+    <title>Motivation</title>
+    <para>
+      Most Linux and Unix-based systems rely on the X Window System (or
+      simply <emphasis>X</emphasis>) as the low-level protocol for building
+      bitmap graphics interfaces. On these systems, the X stack has grown to
+      encompass functionality arguably belonging in client libraries,
+      helper libraries, or the host operating system kernel.  Support for
+      things like PCI resource management, display configuration management,
+      direct rendering, and memory management has been integrated into the X
+      stack, imposing limitations like limited support for standalone
+      applications, duplication in other projects (e.g. the Linux fb layer
+      or the DirectFB project), and high levels of complexity for systems
+      combining multiple elements (for example radeon memory map handling
+      between the fb driver and X driver, or VT switching).
+    </para>
+    <para>
+      Moreover, X has grown to incorporate modern features like offscreen
+      rendering and scene composition, but subject to the limitations of the
+      X architecture.  For example, the X implementation of composition adds
+      additional context switches and makes things like input redirection
+      difficult.
+    </para>
+    <mediaobject>
+      <imageobject>
+	<imagedata fileref="images/x-architecture.png" format="PNG" />
+      </imageobject>
+      <textobject>
+	<phrase>
+	  X architecture diagram
+	</phrase>
+      </textobject>
+    </mediaobject>
+    <para>
+      The diagram above illustrates the central role of the X server and
+      compositor in operations, and the steps required to get contents on to
+      the screen.
+    </para>
+    <para>
+      Over time, X developers came to understand the shortcomings of this
+      approach and worked to split things up.  Over the past several years,
+      a lot of functionality has moved out of the X server and into
+      client-side libraries or kernel drivers. One of the first components
+      to move out was font rendering, with freetype and fontconfig providing
+      an alternative to the core X fonts.  Direct rendering OpenGL as a
+      graphics driver in a client side library went through some iterations,
+      ending up as DRI2, which abstracted most of the direct rendering
+      buffer management from client code. Then cairo came along and provided
+      a modern 2D rendering library independent of X, and compositing
+      managers took over control of the rendering of the desktop as toolkits
+      like GTK+ and Qt moved away from using X APIs for rendering. Recently,
+      memory and display management have moved to the Linux kernel, further
+      reducing the scope of X and its driver stack.  The end result is a
+      highly modular graphics stack.
+    </para>
+
+  </section>
+
+  <section id="sect-Compositing-manager-display-server">
+    <title>The compositing manager as the display server</title>
+    <para>
+      Wayland is a new display server and compositing protocol, and Weston
+      is the implementation of this protocol which builds on top of all the
+      components above. We are trying to distill out the functionality in
+      the X server that is still used by the modern Linux desktop. This
+      turns out to be not a whole lot. Applications can allocate their own
+      off-screen buffers and render their window contents directly, using
+      hardware accelerated libraries like libGL, or high quality software
+      implementations like those found in Cairo. In the end, what’s needed
+      is a way to present the resulting window surface for display, and a
+      way to receive and arbitrate input among multiple clients. This is
+      what Wayland provides, by piecing together the components already in
+      the eco-system in a slightly different way.
+    </para>
+    <para>
+      X will always be relevant, in the same way Fortran compilers and VRML
+      browsers are, but it’s time that we think about moving it out of the
+      critical path and provide it as an optional component for legacy
+      applications.
+    </para>
+    <para>
+      Overall, the philosophy of Wayland is to provide clients with a way to
+      manage windows and how their contents is displayed.  Rendering is left
+      to clients, and system wide memory management interfaces are used to
+      pass buffer handles between clients and the compositing manager.
+    </para>
+    <mediaobject>
+      <imageobject>
+	<imagedata fileref="images/wayland-architecture.png" format="PNG" />
+      </imageobject>
+      <textobject>
+	<phrase>
+	  Wayland architecture diagram
+	</phrase>
+      </textobject>
+    </mediaobject>
+    <para>
+      The figure above illustrates how Wayland clients interact with a
+      Wayland server.  Note that window management and composition are
+      handled entirely in the server, significantly reducing complexity
+      while marginally improving performance through reduced context
+      switching.  The resulting system is easier to build and extend than a
+      similar X system, because often changes need only be made in one
+      place.  Or in the case of protocol extensions, two (rather than 3 or 4
+      in the X case where window management and/or composition handling may
+      also need to be updated).
+    </para>
+  </section>
+</chapter>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Preface.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Protocol.xml Added

@@ -0,0 +1,587 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+<!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+<chapter id="chap-Protocol">
+  <title>Wayland Protocol and Model of Operation</title>
+  <section id="sect-Protocol-Basic-Principles">
+    <title>Basic Principles</title>
+    <para>
+      The Wayland protocol is an asynchronous object oriented protocol.  All
+      requests are method invocations on some object.  The requests include
+      an object ID that uniquely identifies an object on the server.  Each
+      object implements an interface and the requests include an opcode that
+      identifies which method in the interface to invoke.
+    </para>
+    <para>
+      The protocol is message-based.  A message sent by a client to the server
+      is called request.  A message from the server to a client is called event.
+      A message has a number of arguments, each of which has a certain type (see
+      <xref linkend="sect-Protocol-Wire-Format"/> for a list of argument types).
+    </para>
+    <para>
+      Additionally, the protocol can specify <type>enum</type>s which associate
+      names to specific numeric enumeration values.  These are primarily just
+      descriptive in nature: at the wire format level enums are just integers.
+      But they also serve a secondary purpose to enhance type safety or
+      otherwise add context for use in language bindings or other such code.
+      This latter usage is only supported so long as code written before these
+      attributes were introduced still works after; in other words, adding an
+      enum should not break API, otherwise it puts backwards compatibility at
+      risk.
+    </para>
+    <para>
+      <type>enum</type>s can be defined as just a set of integers, or as
+      bitfields.  This is specified via the <type>bitfield</type> boolean
+      attribute in the <type>enum</type> definition.  If this attribute is true,
+      the enum is intended to be accessed primarily using bitwise operations,
+      for example when arbitrarily many choices of the enum can be ORed
+      together; if it is false, or the attribute is omitted, then the enum
+      arguments are a just a sequence of numerical values.
+    </para>
+    <para>
+      The <type>enum</type> attribute can be used on either <type>uint</type>
+      or <type>int</type> arguments, however if the <type>enum</type> is
+      defined as a <type>bitfield</type>, it can only be used on
+      <type>uint</type> args.
+    </para>
+    <para>
+      The server sends back events to the client, each event is emitted from
+      an object.  Events can be error conditions.  The event includes the
+      object ID and the event opcode, from which the client can determine
+      the type of event.  Events are generated both in response to requests
+      (in which case the request and the event constitutes a round trip) or
+      spontaneously when the server state changes.
+    </para>
+    <para>
+      <itemizedlist>
+	<listitem>
+	  <para>
+	    State is broadcast on connect, events are sent
+	    out when state changes. Clients must listen for
+	    these changes and cache the state.
+	    There is no need (or mechanism) to query server state.
+	  </para>
+	</listitem>
+	<listitem>
+	  <para>
+	    The server will broadcast the presence of a number of global objects,
+	    which in turn will broadcast their current state.
+	  </para>
+	</listitem>
+      </itemizedlist>
+    </para>
+  </section>
+  <section id="sect-Protocol-Code-Generation">
+    <title>Code Generation</title>
+    <para>
+      The interfaces, requests and events are defined in
+      <filename>protocol/wayland.xml</filename>.
+      This xml is used to generate the function prototypes that can be used by
+      clients and compositors.
+    </para>
+    <para>
+      The protocol entry points are generated as inline functions which just
+      wrap the <function>wl_proxy_*</function> functions.  The inline functions aren't
+      part of the library ABI and language bindings should generate their
+      own stubs for the protocol entry points from the xml.
+    </para>
+  </section>
+  <section id="sect-Protocol-Wire-Format">
+    <title>Wire Format</title>
+    <para>
+      The protocol is sent over a UNIX domain stream socket, where the endpoint
+      usually is named <systemitem class="service">wayland-0</systemitem>
+      (although it can be changed via <emphasis>WAYLAND_DISPLAY</emphasis>
+      in the environment). Beginning in Wayland 1.15, implementations can
+      optionally support server socket endpoints located at arbitrary
+      locations in the filesystem by setting <emphasis>WAYLAND_DISPLAY</emphasis>
+      to the absolute path at which the server endpoint listens.
+    </para>
+    <para>
+      Every message is structured as 32-bit words; values are represented in the
+      host's byte-order.  The message header has 2 words in it:
+      <itemizedlist>
+	<listitem>
+	  <para>
+	    The first word is the sender's object ID (32-bit).
+	  </para>
+	</listitem>
+	<listitem>
+	  <para>
+	    The second has 2 parts of 16-bit.  The upper 16-bits are the message
+	    size in bytes, starting at the header (i.e. it has a minimum value of 8).The lower is the request/event opcode.
+	  </para>
+	</listitem>
+      </itemizedlist>
+      The payload describes the request/event arguments.  Every argument is always
+      aligned to 32-bits. Where padding is required, the value of padding bytes is
+      undefined. There is no prefix that describes the type, but it is
+      inferred implicitly from the xml specification.
+    </para>
+    <para>
+
+      The representation of argument types are as follows:
+      <variablelist>
+	<varlistentry>
+	  <term>int</term>
+	  <term>uint</term>
+	  <listitem>
+	    <para>
+	      The value is the 32-bit value of the signed/unsigned
+	      int.
+	    </para>
+	  </listitem>
+	</varlistentry>
+	<varlistentry>
+	  <term>fixed</term>
+	  <listitem>
+	    <para>
+	      Signed 24.8 decimal numbers. It is a signed decimal type which
+	      offers a sign bit, 23 bits of integer precision and 8 bits of
+	      decimal precision. This is exposed as an opaque struct with
+	      conversion helpers to and from double and int on the C API side.
+	    </para>
+	  </listitem>
+	</varlistentry>
+	<varlistentry>
+	  <term>string</term>
+	  <listitem>
+	    <para>
+	      Starts with an unsigned 32-bit length (including null terminator),
+	      followed by the string contents, including terminating null byte,
+	      then padding to a 32-bit boundary.
+	    </para>
+	  </listitem>
+	</varlistentry>
+	<varlistentry>
+	  <term>object</term>
+	  <listitem>
+	    <para>
+	      32-bit object ID.
+	    </para>
+	  </listitem>
+	</varlistentry>
+	<varlistentry>
+	  <term>new_id</term>
+	  <listitem>
+	    <para>
+	      The 32-bit object ID.  Generally, the interface used for the new
+	      object is inferred from the xml, but in the case where it's not
+	      specified, a new_id is preceded by a <code>string</code> specifying
+	      the interface name, and a <code>uint</code> specifying the version.
+	    </para>
+	  </listitem>
+	</varlistentry>
+	<varlistentry>
+	  <term>array</term>
+	  <listitem>
+	    <para>
+	      Starts with 32-bit array size in bytes, followed by the array
+	      contents verbatim, and finally padding to a 32-bit boundary.
+	    </para>
+	  </listitem>
+	</varlistentry>
+	<varlistentry>
+	  <term>fd</term>
+	  <listitem>
+	    <para>
+	      The file descriptor is not stored in the message buffer, but in
+	      the ancillary data of the UNIX domain socket message (msg_control).
+	    </para>
+	  </listitem>
+	</varlistentry>
+      </variablelist>
+    </para>
+    <para>
+      The protocol does not specify the exact position of the ancillary data
+      in the stream, except that the order of file descriptors is the same as

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Revision_History.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Server.xml Added

@@ -0,0 +1,49 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+  <!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+  <!ENTITY doxygen SYSTEM "ServerAPI.xml">
+%BOOK_ENTITIES;
+>
+<appendix id="sect-Library-Server">
+  <title>Server API</title>
+  <section><title>Introduction</title>
+  <para>
+    The open-source reference implementation of Wayland protocol is
+    split in two C libraries, <link
+    linkend="sect-Library-Client">libwayland-client</link> and
+    libwayland-server. Their main responsibility is to handle the
+    Inter-process communication (<emphasis>IPC</emphasis>) with each
+    other, therefore guaranteeing the protocol objects marshaling and
+    messages synchronization.
+  </para>
+  <para>
+    The server library is designed to work much like libwayland-client,
+    although it is considerably complicated due to the server needing
+    to support multiple versions of the protocol. It is best to learn
+    libwayland-client first.
+  </para>
+  <para>
+    Each open socket to a client is represented by a <link
+    linkend="Server-structwl__client">wl_client</link>.  The equivalent
+    of the <link linkend="Client-classwl__proxy">wl_proxy</link> that
+    libwayland-client uses to represent an object is <link
+    linkend="Server-structwl__resource">wl_resource</link> for
+    client-created objects, and <link
+    linkend="Server-structwl__global">wl_global</link> for objects
+    created by the server.
+  </para>
+  <para>
+    Often a server is also a client for another Wayland server, and
+    thus must link with both libwayland-client and libwayland-server.
+    This produces some type name conflicts (such as the <link
+    linkend="Client-classwl__display">client wl_display</link> and
+    <link linkend="Server-structwl__display">server wl_display</link>,
+    but the duplicate-but-not-the-same types are opaque, and accessed
+    only inside the correct library where it came from. Naturally that
+    means that the program writer needs to always know if a pointer to
+    a wl_display is for the server or client side and use the
+    corresponding functions.
+  </para>
+  </section>
+  &doxygen;
+</appendix>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Wayland.ent Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Wayland.xml Added

@@ -0,0 +1,18 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+<!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+<book>
+  <xi:include href="Book_Info.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="Foreword.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="Preface.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="Introduction.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="Compositors.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="Architecture.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="Protocol.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="Xwayland.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="ProtocolSpec.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
+  <xi:include href="Client.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+  <xi:include href="Server.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+</book>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/Xwayland.xml Added

@@ -0,0 +1,170 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" 
+<!ENTITY % BOOK_ENTITIES SYSTEM "Wayland.ent">
+%BOOK_ENTITIES;
+>
+<chapter id="chap-X11-Application-Support">
+  <title>X11 Application Support</title>
+  <section id="sect-X11-Application-Support-introduction">
+    <title>Introduction</title>
+    <para>
+      Being able to run existing X11 applications is crucial for the adoption
+      of Wayland, especially on desktops, as there will always be X11
+      applications that have not been or cannot be converted into Wayland
+      applications, and throwing them all away would be prohibitive.
+      Therefore a Wayland compositor often needs to support running X11
+      applications.
+    </para>
+    <para>
+      X11 and Wayland are different enough that there is no "simple" way to
+      translate between them. Most of X11 is uninteresting to a Wayland
+      compositor. That, combined with the gigantic implementation effort needed
+      to support X11, makes it intractable to just write X11 support directly in
+      a Wayland compositor. The implementation would be nothing short of a
+      real X11 server.
+    </para>
+    <para>
+      Therefore, Wayland compositors should use Xwayland, the X11 server that
+      lives in the Xorg server source code repository and shares most of the
+      implementation with the Xorg server. Xwayland is a complete X11 server,
+      just like Xorg is, but instead of driving the displays and opening input
+      devices, it acts as a Wayland client. The rest of this chapter talks
+      about how Xwayland works.
+    </para>
+    <para>
+      For integration and architecture reasons, while Xwayland is a Wayland
+      client of the Wayland compositor, the Wayland compositor is an X11 client
+      of Xwayland. This circular dependency requires special care from the
+      Wayland compositor.
+    </para>
+  </section>
+  <section id="sect-X11-Application-Support-two-modes">
+    <title>Two Modes for Foreign Windows</title>
+    <para>
+      In general, windows from a foreign window system can be presented in one
+      of two ways: rootless and rootful (not rootless).
+    </para>
+    <para>
+      In rootful mode, the foreign window system as a whole is represented as a
+      window (or more) of its own. You have a native window, inside which all
+      the foreign windows are. The advantage of this approach in Xwayland's
+      case is that you can run your favourite X11 window manager to manage your
+      X11 applications. The disadvantage is that the foreign windows do not
+      integrate with the native desktop. Therefore this mode is not usually
+      used.
+    </para>
+    <para>
+      In rootless mode, each foreign window is a first-class resident among the
+      native windows. Foreign windows are not confined inside a native window
+      but act as if they were native windows. The advantage is that one can
+      freely stack and mix native and foreign windows, which is not possible in
+      rootful mode. The disadvantage is that this mode is harder to implement
+      and fundamental differences in window systems may prevent some things
+      from working. With rootless Xwayland, the Wayland compositor must take
+      the role as the X11 window manager, and one cannot use any other X11
+      window manager in its place.
+    </para>
+    <para>
+      This chapter concentrates on the rootless mode, and ignores the rootful
+      mode.
+    </para>
+  </section>
+  <section id="sect-X11-Application-Support-architecture">
+    <title>Architecture</title>
+    <para>
+      A Wayland compositor usually takes care of launching Xwayland.
+      Xwayland works in cooperation with a Wayland compositor as follows:
+    </para>
+    <figure>
+      <title>Xwayland architecture diagram</title>
+      <mediaobjectco>
+	<imageobjectco>
+	  <imageobject>
+	    <imagedata fileref="images/xwayland-architecture.png" format="PNG" />
+	  </imageobject>
+	</imageobjectco>
+      </mediaobjectco>
+    </figure>
+    <para>
+      An X11 application connects to Xwayland just like it would connect to any
+      X server. Xwayland processes all the X11 requests. On the other end,
+      Xwayland is a Wayland client that connects to the Wayland compositor.
+    </para>
+    <para>
+      The X11 window manager (XWM) is an integral part of the Wayland
+      compositor. XWM uses the usual X11 window management protocol to manage
+      all X11 windows in Xwayland. Most importantly, XWM acts as a bridge
+      between Xwayland window state and the Wayland compositor's window manager
+      (WWM). This way WWM can manage all windows, both native Wayland and X11
+      (Xwayland) windows. This is very important for a coherent user
+      experience.
+    </para>
+    <para>
+      Since Xwayland uses Wayland for input and output, it does not have any
+      use for the device drivers that Xorg uses. None of the xf86-video-* or
+      xf86-input-* modules are used. There also is no configuration file for
+      the Xwayland server. For optional hardware accelerated rendering,
+      Xwayland uses GLAMOR.
+    </para>
+    <para>
+      A Wayland compositor usually spawns only one Xwayland instance. This is
+      because many X11 applications assume they can communicate with other X11
+      applications through the X server, and this requires a shared X server
+      instance. This also means that Xwayland does not protect nor isolate X11
+      clients from each other, unless the Wayland compositor specifically
+      chooses to break the X11 client intercommunications by spawning
+      application specific Xwayland instances. X11 clients are naturally
+      isolated from Wayland clients.
+    </para>
+    <para>
+      Xwayland compatibility compared to a native X server will probably never
+      reach 100%. Desktop environment (DE) components, specifically X11 window
+      managers, are practically never supported. An X11 window manager would
+      not know about native Wayland windows, so it could manage only X11
+      windows. On the other hand, there must be an XWM that reserves the
+      exclusive window manager role so that the Wayland compositor could show
+      the X11 windows appropriately. For other DE components, like pagers and
+      panels, adding the necessary interfaces to support them in WWM through XWM
+      is often considered not worthwhile.
+    </para>
+  </section>
+  <section id="sect-X11-Application-Support-xwm">
+    <title>X Window Manager (XWM)</title>
+    <para>
+      From the X11 point of view, the X window manager (XWM) living inside a
+      Wayland compositor is just like any other window manager. The difference
+      is mostly in which process it resides in, and the few extra conventions
+      in the X11 protocol to support Wayland window management (WWM)
+      specifically.
+    </para>
+    <para>
+      There are two separate asynchronous communication channels between
+      Xwayland and a Wayland compositor: one uses the Wayland protocol, and the
+      other one, solely for XWM, uses X11 protocol. This setting demands great
+      care from the XWM implementation to avoid (random) deadlocks with
+      Xwayland. It is often nearly impossible to prove that synchronous or
+      blocking X11 calls from XWM cannot cause a deadlock, and therefore it is
+      strongly recommended to make all X11 communications asynchronous. All
+      Wayland communications are already asynchronous by design.
+    </para>
+    <section id="sect-X11-Application-Support-xwm-window-identification">
+      <title>Window identification</title>
+      <para>
+	In Xwayland, an X11 window may have a corresponding wl_surface object
+	in Wayland. The wl_surface object is used for input and output: it is
+	referenced by input events and used to provide the X11 window content
+	to the Wayland compositor. The X11 window and the wl_surface live in
+	different protocol streams, and they need to be matched for XWM to do
+	its job.
+      </para>
+      <para>
+	When Xwayland creates a wl_surface on Wayland, it will also send an X11
+	ClientMessage of type atom "WL_SURFACE_ID" to the X11 window carrying
+	the wl_surface Wayland object ID as the first 32-bit data element. This
+	is how XWM can associate a wl_surface with an X11 window. Note that
+	the request to create a wl_surface and the ID message may arrive in any
+	order in the Wayland compositor.
+      </para>
+    </section>
+  </section>
+</chapter>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/css Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/css/brand.css Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/css/common.css Added

@@ -0,0 +1,1769 @@
+* {
+	widows: 4 !important;
+	orphans: 4 !important;
+}
+
+body, h1, h2, h3, h4, h5, h6, pre, li, div {
+	line-height: 1.29em;
+}
+
+body {
+	background-color: white;
+	margin:0 auto;
+	font-family: "liberation sans", "Myriad ", "Bitstream Vera Sans", "Lucida Grande", "Luxi Sans", "Trebuchet MS", helvetica, verdana, arial, sans-serif;
+	font-size: 14px;
+	max-width: 770px;
+	color: black;
+}
+
+body.toc_embeded {
+	/*for web hosting system only*/
+	margin-left: 300px;
+}
+
+object.toc, iframe.toc {
+	/*for web hosting system only*/
+	border-style: none;
+	position: fixed;
+	width: 290px;
+	height: 99.99%;
+	top: 0;
+	left: 0;
+	z-index: 100;
+	border-style: none;
+	border-right:1px solid #999;
+}
+
+/* Hide web menu */
+
+body.notoc {
+	margin-left: 3em;
+}
+
+iframe.notoc {
+	border-style:none;
+	border: none;
+	padding: 0px;
+	position:fixed;
+	width: 21px;
+	height: 29px;
+	top: 0px;
+	left:0;
+	overflow: hidden;
+	margin: 0px;
+	margin-left: -3px;
+}
+/* End hide web menu */
+
+/* desktop styles */
+body.desktop {
+	margin-left: 26em;
+}
+
+body.desktop .book > .toc {
+	display:block;
+	width:24em;
+	height:99.99%;
+	position:fixed;
+	overflow:auto;
+	top:0px;
+	left:0px;
+/*	padding-left:1em; */
+	background-color:#EEEEEE;
+	font-size: 12px;
+}
+
+body.pdf {
+	max-width: 100%;
+}
+
+.toc {
+	line-height:1.35em;
+}
+
+.toc .glossary,
+.toc .chapter, .toc .appendix {
+	margin-top:1em;
+}
+
+.toc .part {
+	margin-top:1em;
+	display:block;
+}
+
+span.glossary,
+span.appendix {
+	display:block;
+	margin-top:0.5em;
+}
+
+div {
+	padding-top:0px;
+}
+
+div.section {
+	page-break-inside: avoid;
+}
+
+p, div.para {
+	padding-top: 0px;
+	margin-top: 1em;
+	padding-bottom: 0px;
+	margin-bottom: 1em;
+}
+
+div.formalpara {
+	padding-top: 0px;
+	margin-top: 1em;
+	padding-bottom: 0px;
+	margin-bottom: 1em;
+}
+
+.varlistentry div.para {
+	page-break-before: avoid;
+
+}
+
+/*Links*/
+a {
+	outline: none;
+}
+
+a:link {
+	text-decoration: none;
+	border-bottom: 1px dotted ;
+	color:#3366cc;
+}
+
+body.pdf a:link {
+	word-wrap: break-word;
+}
+
+a:visited {
+	text-decoration:none;
+	border-bottom: 1px dotted ;
+	color:#003366;
+}
+
+div.longdesc-link {
+	float:right;
+	color:#999;
+}
+
+.toc a, .qandaset a {
+	font-weight:normal;
+	border:none;
+}
+
+.toc a:hover, .qandaset a:hover
+{
+	border-bottom: 1px dotted;
+}
+
+/*headings*/
+h1, h2, h3, h4, h5, h6 {
+	color: #336699;
+	margin-top: 0px;
+	margin-bottom: 0px;
+	background-color: transparent;
+	margin-bottom: 0px;
+	margin-top: 20px;
+	page-break-inside: avoid;
+	page-break-after: avoid;
+	word-wrap: break-word;
+}
+
+h1 {
+	font-size: 22px;
+}
+
+.titlepage h1.title {
+	text-align:left;
+}
+
+.book > .titlepage h1.title {
+	text-align: center;
+}
+
+.article > .titlepage h1.title,
+.article > .titlepage h2.title {
+	text-align: center;
+}
+
+.set .titlepage > div > div > h1.title {
+	text-align: center;
+}
+
+.part > .titlepage h1.title {
+	text-align: center;
+	font-size: 24px;

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/css/default.css Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/css/epub.css Added

@@ -0,0 +1,115 @@
+/*headings*/
+h1, h2, h3, h4, h5, h6,
+div.producttitle,
+div.subtitle,
+div.author div.author,
+div.translator div.translator,
+div.othercredit div.othercredit,
+div.editor div.editor,
+div.contrib div.contrib,
+.title,
+.titlepage .edition {
+}
+
+div.para {
+	margin-top: 1em;
+}
+/* inline syntax highlighting */
+.perl_Alert {
+	color: #0000ff;
+}
+
+.perl_BaseN {
+	color: #007f00;
+}
+
+.perl_BString {
+	color: #5C3566;
+}
+
+.perl_Char {
+	color: #ff00ff;
+}
+
+.perl_Comment {
+	color: #888888;
+}
+
+
+.perl_DataType {
+	color: #0000ff;
+}
+
+
+.perl_DecVal {
+	color: #00007f;
+}
+
+
+.perl_Error {
+	color: #ff0000;
+}
+
+
+.perl_Float {
+	color: #00007f;
+}
+
+
+.perl_Function {
+	color: #007f00;
+}
+
+
+.perl_IString {
+	color: #5C3566;
+}
+
+
+.perl_Keyword {
+	color: #002F5D;
+}
+
+
+.perl_Operator {
+	color: #ffa500;
+}
+
+
+.perl_Others {
+	color: #b03060;
+}
+
+
+.perl_RegionMarker {
+	color: #96b9ff;
+}
+
+
+.perl_Reserved {
+	color: #9b30ff;
+}
+
+
+.perl_String {
+	color: #5C3566;
+}
+
+
+.perl_Variable {
+	color: #0000ff;
+}
+
+
+.perl_Warning {
+	color: #0000ff;
+}
+
+b, strong {
+	font-weight: bolder;
+}
+
+code.command {
+	font-family: monospace;
+	font-weight: bolder;
+}

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/css/print.css Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/images Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/images/icon.svg Added

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.0" width="32" height="32" id="svg3017">
+  <defs id="defs3019">
+    <linearGradient id="linearGradient2381">
+      <stop id="stop2383" style="stop-color:#ffffff;stop-opacity:1" offset="0"/>
+      <stop id="stop2385" style="stop-color:#ffffff;stop-opacity:0" offset="1"/>
+    </linearGradient>
+    <linearGradient x1="296.4996" y1="188.81061" x2="317.32471" y2="209.69398" id="linearGradient2371" xlink:href="#linearGradient2381" gradientUnits="userSpaceOnUse" gradientTransform="matrix(0.90776,0,0,0.90776,24.35648,49.24131)"/>
+  </defs>
+  <g transform="matrix(0.437808,-0.437808,0.437808,0.437808,-220.8237,43.55311)" id="g5089">
+    <path d="m 8.4382985,-6.28125 c -0.6073916,0 -4.3132985,5.94886271 -4.3132985,8.25 l 0,26.71875 c 0,0.846384 0.5818159,1.125 1.15625,1.125 l 25.5625,0 c 0.632342,0 1.125001,-0.492658 1.125,-1.125 l 0,-5.21875 0.28125,0 c 0.49684,0 0.906249,-0.409411 0.90625,-0.90625 l 0,-27.9375 c 0,-0.4968398 -0.40941,-0.90625 -0.90625,-0.90625 l -23.8117015,0 z" transform="translate(282.8327,227.1903)" id="path5091" style="fill:#5c5c4f;stroke:#000000;stroke-width:3.23021388;stroke-miterlimit:4;stroke-dasharray:none"/>
+    <rect width="27.85074" height="29.369793" rx="1.1414107" ry="1.1414107" x="286.96509" y="227.63805" id="rect5093" style="fill:#032c87"/>
+    <path d="m 288.43262,225.43675 25.2418,0 0,29.3698 -26.37615,0.0241 1.13435,-29.39394 z" id="rect5095" style="fill:#ffffff"/>
+    <path d="m 302.44536,251.73726 c 1.38691,7.85917 -0.69311,11.28365 -0.69311,11.28365 2.24384,-1.60762 3.96426,-3.47694 4.90522,-5.736 0.96708,2.19264 1.83294,4.42866 4.27443,5.98941 0,0 -1.59504,-7.2004 -1.71143,-11.53706 l -6.77511,0 z" id="path5097" style="fill:#a70000;fill-opacity:1;stroke-width:2"/>
+    <rect width="25.241802" height="29.736675" rx="0.89682275" ry="0.89682275" x="290.73544" y="220.92249" id="rect5099" style="fill:#809cc9"/>
+    <path d="m 576.47347,725.93939 6.37084,0.41502 0.4069,29.51809 c -1.89202,-1.31785 -6.85427,-3.7608 -8.26232,-1.68101 l 0,-26.76752 c 0,-0.82246 0.66212,-1.48458 1.48458,-1.48458 z" transform="matrix(0.499065,-0.866565,0,1,0,0)" id="rect5101" style="fill:#4573b3;fill-opacity:1"/>
+    <path d="m 293.2599,221.89363 20.73918,0 c 0.45101,0 0.8141,0.3631 0.8141,0.81411 0.21547,6.32836 -19.36824,21.7635 -22.36739,17.59717 l 0,-17.59717 c 0,-0.45101 0.3631,-0.81411 0.81411,-0.81411 z" id="path5103" style="opacity:0.65536726;fill:url(#linearGradient2371);fill-opacity:1"/>
+  </g>
+</svg>

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/images/wayland.png Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/images/xwayland-architecture.png Added

_service:tar_scm:wayland-1.21.0.tar.gz/doc/publican/sources/meson.build Added

@@ -0,0 +1,113 @@
+ProtocolSpec_xml = custom_target(
+	'ProtocolSpec.xml',
+	command:  xsltproc, '-o', '@OUTPUT@', files('../protocol-to-docbook.xsl'), '@INPUT@' ,
+	input: wayland_protocol_xml,
+	output: 'ProtocolSpec.xml'
+)
+
+ProtocolInterfaces_xml = custom_target(
+	'ProtocolInterfaces.xml',
+	command:  xsltproc, '-o', '@OUTPUT@', files('../protocol-interfaces-to-docbook.xsl'), '@INPUT@' ,
+	input: wayland_protocol_xml,
+	output: 'ProtocolInterfaces.xml'
+)
+
+ClientAPI_combined = custom_target(
+	'ClientAPI-combined',
+	command:  xsltproc, '-o', '@OUTPUT@', '@INPUT@' ,
+	input:  doxygen_Client_combine_xslt, doxygen_Client_index_xml ,
+	output: 'ClientAPI-combined.xml'
+)
+
+to_publican_xsl = files('../doxygen-to-publican.xsl')
+
+ClientAPI_xml = custom_target(
+	'ClientAPI.xml',
+	command:  xsltproc, '-o', '@OUTPUT@', '--stringparam', 'which', 'Client', to_publican_xsl, '@INPUT@' ,
+	input: ClientAPI_combined,
+	output: 'ClientAPI.xml'
+)
+
+ServerAPI_combined = custom_target(
+	'ServerAPI-combined',
+	command:  xsltproc, '-o', '@OUTPUT@', '@INPUT@' ,
+	input:  doxygen_Server_combine_xslt, doxygen_Server_index_xml ,
+	output: 'ServerAPI-combined.xml'
+)
+
+ServerAPI_xml = custom_target(
+	'ServerAPI.xml',
+	command:  xsltproc, '-o', '@OUTPUT@', '--stringparam', 'which', 'Server', to_publican_xsl, '@INPUT@' ,
+	input: ServerAPI_combined,
+	output: 'ServerAPI.xml'
+)
+
+
+publican_sources = 
+	'Wayland.ent',
+	# 'Wayland.xml', # handled specially
+	'Book_Info.xml',
+	'Author_Group.xml',
+	'Foreword.xml',
+	'Preface.xml',
+	'Revision_History.xml',
+	'Protocol.xml',
+	'Xwayland.xml',
+	'Compositors.xml',
+	'Client.xml',
+	'Server.xml'
+
+
+publican_processed_main = configure_file(
+	input: 'Wayland.xml',
+	output: 'Wayland.xml',
+	copy: true
+)
+
+publican_copied_sources = 
+foreach src: publican_sources
+	publican_copied_sources += configure_file(
+		input: src,
+		output: src,
+		copy: true
+	)
+endforeach
+
+publican_processed_sources = 
+	'Architecture.xml',
+	'Introduction.xml'
+
+
+publican_processed_targets = 
+foreach src: publican_processed_sources
+	publican_processed_targets += custom_target(
+		src,
+		command:  xsltproc, '-o', '@OUTPUT@', '--stringparam', 'basedir', '.', merge_mapcoords_xsl, '@INPUT@' ,
+		input: src,
+		output: src
+	)
+endforeach
+
+publican_css_sources = files(
+	'css/brand.css',
+	'css/common.css',
+	'css/default.css',
+	'css/epub.css',
+	'css/print.css'
+)
+
+install_data(
+	publican_css_sources,
+	install_dir: join_paths(publican_install_prefix, publican_html_dir, 'css')
+)
+
+publican_img_sources = files(
+	'images/icon.svg',
+	'images/wayland.png',
+	'images/xwayland-architecture.png'
+)
+
+install_data(
+	publican_img_sources,
+	install_dir: join_paths(publican_install_prefix, publican_html_dir, 'images')
+)

_service:tar_scm:wayland-1.21.0.tar.gz/egl Added

_service:tar_scm:wayland-1.21.0.tar.gz/egl/meson.build Added

@@ -0,0 +1,52 @@
+wayland_egl = library(
+	'wayland-egl',
+	sources: 
+		'wayland-egl.c',
+		wayland_client_protocol_h
+	,
+	include_directories: src_inc,
+	version: meson.project_version(),
+	install: true
+)
+
+executable('wayland-egl-abi-check', 'wayland-egl-abi-check.c')
+
+nm_path = find_program('nm').full_path()
+
+test(
+	'wayland-egl symbols check',
+	find_program('wayland-egl-symbols-check'),
+	env: 
+		'WAYLAND_EGL_LIB=@0@'.format(wayland_egl.full_path()),
+		'NM=@0@'.format(nm_path)
+	
+)
+
+install_headers(
+	'wayland-egl.h',
+	'wayland-egl-core.h',
+	'wayland-egl-backend.h'
+)
+
+pkgconfig.generate(
+	name: 'wayland-egl',
+	description: 'Frontend wayland-egl library',
+	version: '18.1.0',
+	requires: 'wayland-client',
+	libraries: wayland_egl
+)
+
+pkgconfig.generate(
+	name: 'wayland-egl-backend',
+	description: 'Backend wayland-egl interface',
+	version: '3'
+)
+
+wayland_egl_dep = declare_dependency(
+	link_with: wayland_egl,
+	include_directories:  root_inc, include_directories('.') ,
+)
+
+if meson.version().version_compare('>= 0.54.0')
+	meson.override_dependency('wayland-egl', wayland_egl_dep)
+endif

_service:tar_scm:wayland-1.21.0.tar.gz/egl/wayland-egl-abi-check.c Added

@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stddef.h> /* offsetof */
+#include <stdio.h>  /* printf */
+
+#include "wayland-egl-backend.h" /* Current struct wl_egl_window implementation */
+
+/*
+ * Following are previous implementations of wl_egl_window.
+ *
+ * DO NOT EVER CHANGE!
+ */
+
+/* From: 214fc6e850 - Benjamin Franzke : egl: Implement libwayland-egl */
+struct wl_egl_window_v0 {
+    struct wl_surface *surface;
+
+    int width;
+    int height;
+    int dx;
+    int dy;
+
+    int attached_width;
+    int attached_height;
+};
+
+/* From: ca3ed3e024 - Ander Conselvan de Oliveira : egl/wayland: Don't invalidate drawable on swap buffers */
+struct wl_egl_window_v1 {
+    struct wl_surface *surface;
+
+    int width;
+    int height;
+    int dx;
+    int dy;
+
+    int attached_width;
+    int attached_height;
+
+    void *private;
+    void (*resize_callback)(struct wl_egl_window *, void *);
+};
+
+/* From: 690ead4a13 - Stencel, Joanna : egl/wayland-egl: Fix for segfault in dri2_wl_destroy_surface. */
+#define WL_EGL_WINDOW_VERSION_v2 2
+struct wl_egl_window_v2 {
+    struct wl_surface *surface;
+
+    int width;
+    int height;
+    int dx;
+    int dy;
+
+    int attached_width;
+    int attached_height;
+
+    void *private;
+    void (*resize_callback)(struct wl_egl_window *, void *);
+    void (*destroy_window_callback)(void *);
+};
+
+/* From: 2d5d61bc49 - Miguel A. Vico : wayland-egl: Make wl_egl_window a versioned struct */
+#define WL_EGL_WINDOW_VERSION_v3 3
+struct wl_egl_window_v3 {
+    const intptr_t version;
+
+    int width;
+    int height;
+    int dx;
+    int dy;
+
+    int attached_width;
+    int attached_height;
+
+    void *driver_private;
+    void (*resize_callback)(struct wl_egl_window *, void *);
+    void (*destroy_window_callback)(void *);
+
+    struct wl_surface *surface;
+};
+
+
+/* This program checks we keep a backwards-compatible struct wl_egl_window
+ * definition whenever it is modified in wayland-egl-backend.h.
+ *
+ * The previous definition should be added above as a new struct
+ * wl_egl_window_vN, and the appropriate checks should be added below
+ */
+
+#define MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+
+#define CHECK_RENAMED_MEMBER(a_ver, b_ver, a_member, b_member)                      \
+    do {                                                                            \
+        if (offsetof(struct wl_egl_window ## a_ver, a_member) !=                    \
+            offsetof(struct wl_egl_window ## b_ver, b_member)) {                    \
+            printf("Backwards incompatible change detected!\n   "                    \
+                   "offsetof(struct wl_egl_window" #a_ver "::" #a_member ") != "    \
+                   "offsetof(struct wl_egl_window" #b_ver "::" #b_member ")\n");    \
+            return 1;                                                               \
+        }                                                                           \
+                                                                                    \
+        if (MEMBER_SIZE(struct wl_egl_window ## a_ver, a_member) !=                 \
+            MEMBER_SIZE(struct wl_egl_window ## b_ver, b_member)) {                 \
+            printf("Backwards incompatible change detected!\n   "                    \
+                   "MEMBER_SIZE(struct wl_egl_window" #a_ver "::" #a_member ") != " \
+                   "MEMBER_SIZE(struct wl_egl_window" #b_ver "::" #b_member ")\n"); \
+            return 1;                                                               \
+        }                                                                           \
+    } while (0)
+
+#define CHECK_MEMBER(a_ver, b_ver, member) CHECK_RENAMED_MEMBER(a_ver, b_ver, member, member)
+#define CHECK_MEMBER_CURRENT(a_ver, member) CHECK_MEMBER(a_ver,, member)
+
+#define CHECK_SIZE(a_ver, b_ver)                                                    \
+    do {                                                                            \
+        if (sizeof(struct wl_egl_window ## a_ver) >                                 \
+            sizeof(struct wl_egl_window ## b_ver)) {                                \
+            printf("Backwards incompatible change detected!\n   "                    \
+                   "sizeof(struct wl_egl_window" #a_ver ") > "                      \
+                   "sizeof(struct wl_egl_window" #b_ver ")\n");                     \
+            return 1;                                                               \
+        }                                                                           \
+    } while (0)
+
+#define CHECK_SIZE_CURRENT(a_ver)                                                   \
+    do {                                                                            \
+        if (sizeof(struct wl_egl_window ## a_ver) !=                                \
+            sizeof(struct wl_egl_window)) {                                         \
+            printf("Backwards incompatible change detected!\n   "                    \
+                   "sizeof(struct wl_egl_window" #a_ver ") != "                     \
+                   "sizeof(struct wl_egl_window)\n");                               \
+            return 1;                                                               \
+        }                                                                           \
+    } while (0)
+
+#define CHECK_VERSION(a_ver, b_ver)                                                 \
+    do {                                                                            \
+        if ((WL_EGL_WINDOW_VERSION ## a_ver) >=                                     \
+            (WL_EGL_WINDOW_VERSION ## b_ver)) {                                     \
+            printf("Backwards incompatible change detected!\n   "                    \
+                   "WL_EGL_WINDOW_VERSION" #a_ver " >= "                            \
+                   "WL_EGL_WINDOW_VERSION" #b_ver "\n");                            \
+            return 1;                                                               \
+        }                                                                           \
+    } while (0)
+
+#define CHECK_VERSION_CURRENT(a_ver)                                                \
+    do {                                                                            \
+        if ((WL_EGL_WINDOW_VERSION ## a_ver) !=                                     \
+            (WL_EGL_WINDOW_VERSION)) {                                              \
+            printf("Backwards incompatible change detected!\n   "                    \
+                   "WL_EGL_WINDOW_VERSION" #a_ver " != "                            \
+                   "WL_EGL_WINDOW_VERSION\n");                                      \
+            return 1;                                                               \
+        }                                                                           \
+    } while (0)
+
+int main(int argc, char **argv)
+{
+    /* Check wl_egl_window_v1 ABI against wl_egl_window_v0 */
+    CHECK_MEMBER(_v0, _v1, surface);
+    CHECK_MEMBER(_v0, _v1, width);
+    CHECK_MEMBER(_v0, _v1, height);
+    CHECK_MEMBER(_v0, _v1, dx);
+    CHECK_MEMBER(_v0, _v1, dy);
+    CHECK_MEMBER(_v0, _v1, attached_width);
+    CHECK_MEMBER(_v0, _v1, attached_height);
+
+    CHECK_SIZE(_v0, _v1);
+
+    /* Check wl_egl_window_v2 ABI against wl_egl_window_v1 */
+    CHECK_MEMBER(_v1, _v2, surface);
+    CHECK_MEMBER(_v1, _v2, width);
+    CHECK_MEMBER(_v1, _v2, height);
+    CHECK_MEMBER(_v1, _v2, dx);
+    CHECK_MEMBER(_v1, _v2, dy);
+    CHECK_MEMBER(_v1, _v2, attached_width);
+    CHECK_MEMBER(_v1, _v2, attached_height);
+    CHECK_MEMBER(_v1, _v2, private);
+    CHECK_MEMBER(_v1, _v2, resize_callback);

_service:tar_scm:wayland-1.21.0.tar.gz/egl/wayland-egl-backend.h Added

@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2011 Benjamin Franzke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Benjamin Franzke <benjaminfranzke@googlemail.com>
+ */
+
+#ifndef _WAYLAND_EGL_PRIV_H
+#define _WAYLAND_EGL_PRIV_H
+
+#include <stdint.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * NOTE: This version must be kept in sync with the version field in the
+ * wayland-egl-backend pkgconfig file generated in meson.build.
+ */
+#define WL_EGL_WINDOW_VERSION 3
+
+struct wl_surface;
+
+struct wl_egl_window {
+	const intptr_t version;
+
+	int width;
+	int height;
+	int dx;
+	int dy;
+
+	int attached_width;
+	int attached_height;
+
+	void *driver_private;
+	void (*resize_callback)(struct wl_egl_window *, void *);
+	void (*destroy_window_callback)(void *);
+
+	struct wl_surface *surface;
+};
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/egl/wayland-egl-core.h Added

@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2011 Kristian Høgsberg
+ * Copyright © 2011 Benjamin Franzke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_EGL_CORE_H
+#define WAYLAND_EGL_CORE_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#define WL_EGL_PLATFORM 1
+
+struct wl_egl_window;
+struct wl_surface;
+
+struct wl_egl_window *
+wl_egl_window_create(struct wl_surface *surface,
+		     int width, int height);
+
+void
+wl_egl_window_destroy(struct wl_egl_window *egl_window);
+
+void
+wl_egl_window_resize(struct wl_egl_window *egl_window,
+		     int width, int height,
+		     int dx, int dy);
+
+void
+wl_egl_window_get_attached_size(struct wl_egl_window *egl_window,
+				int *width, int *height);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/egl/wayland-egl-symbols-check Added

@@ -0,0 +1,51 @@
+#!/bin/sh
+set -eu
+
+RET=0
+LIB=${WAYLAND_EGL_LIB}
+
+if ! test -f "$LIB"; then
+	echo "Test binary \"$LIB\" does not exist"
+	exit 99
+fi
+
+if ! test -n "$NM"; then
+	echo "nm environment variable not set"
+	exit 99
+fi
+
+AVAIL_FUNCS="$($NM -D --format=bsd --defined-only $LIB | awk '{print $3}')"
+
+# Official ABI, taken from the header.
+REQ_FUNCS="wl_egl_window_resize
+wl_egl_window_create
+wl_egl_window_destroy
+wl_egl_window_get_attached_size
+"
+
+NEW_ABI=$(echo "$AVAIL_FUNCS" | while read func; do
+    echo "$func" | grep -q "^_" && continue
+    echo "$REQ_FUNCS" | grep -q "^$func$" && continue
+
+    echo $func
+done)
+
+if test -n "$NEW_ABI"; then
+	echo "New ABI detected - If intentional, update the test."
+	echo "$NEW_ABI"
+	RET=1
+fi
+
+REMOVED_ABI=$(echo "$REQ_FUNCS" | while read func; do
+    echo "$AVAIL_FUNCS" | grep -q "^$func$" && continue
+
+    echo $func
+done)
+
+if test -n "$REMOVED_ABI"; then
+	echo "ABI break detected - Required symbol(s) no longer exported!"
+	echo "$REMOVED_ABI"
+	RET=1
+fi
+
+exit $RET

_service:tar_scm:wayland-1.21.0.tar.gz/egl/wayland-egl.c Added

@@ -0,0 +1,118 @@
+/*
+ * Copyright © 2011 Kristian Høgsberg
+ * Copyright © 2011 Benjamin Franzke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Kristian Høgsberg <krh@bitplanet.net>
+ *    Benjamin Franzke <benjaminfranzke@googlemail.com>
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "wayland-egl.h"
+#include "wayland-egl-backend.h"
+#include "wayland-util.h"
+
+
+/** Resize the EGL window
+ *
+ * \param egl_window A pointer to a struct wl_egl_window
+ * \param width The new width
+ * \param height The new height
+ * \param dx Offset on the X axis
+ * \param dy Offset on the Y axis
+ *
+ * Note that applications should prefer using the wl_surface.offset request if
+ * the associated wl_surface has the interface version 5 or higher.
+ *
+ * If the wl_surface.offset request is used, applications MUST pass 0 to both
+ * dx and dy.
+ */
+WL_EXPORT void
+wl_egl_window_resize(struct wl_egl_window *egl_window,
+		     int width, int height,
+		     int dx, int dy)
+{
+	if (width <= 0 || height <= 0)
+		return;
+
+	egl_window->width  = width;
+	egl_window->height = height;
+	egl_window->dx     = dx;
+	egl_window->dy     = dy;
+
+	if (egl_window->resize_callback)
+		egl_window->resize_callback(egl_window, egl_window->driver_private);
+}
+
+WL_EXPORT struct wl_egl_window *
+wl_egl_window_create(struct wl_surface *surface,
+		     int width, int height)
+{
+	struct wl_egl_window *egl_window;
+
+	if (width <= 0 || height <= 0)
+		return NULL;
+
+	egl_window = calloc(1, sizeof *egl_window);
+	if (!egl_window)
+		return NULL;
+
+	/* Cast away the constness to set the version number.
+	 *
+	 * We want the const notation since it gives an explicit
+	 * feedback to the backend implementation, should it try to
+	 * change it.
+	 *
+	 * The latter in itself is not too surprising as these days APIs
+	 * tend to provide bidirectional version field.
+	 */
+	intptr_t *version = (intptr_t *)&egl_window->version;
+	*version = WL_EGL_WINDOW_VERSION;
+
+	egl_window->surface = surface;
+
+	egl_window->width  = width;
+	egl_window->height = height;
+
+	return egl_window;
+}
+
+WL_EXPORT void
+wl_egl_window_destroy(struct wl_egl_window *egl_window)
+{
+	if (egl_window->destroy_window_callback)
+		egl_window->destroy_window_callback(egl_window->driver_private);
+	free(egl_window);
+}
+
+WL_EXPORT void
+wl_egl_window_get_attached_size(struct wl_egl_window *egl_window,
+				int *width, int *height)
+{
+	if (width)
+		*width = egl_window->attached_width;
+	if (height)
+		*height = egl_window->attached_height;
+}

_service:tar_scm:wayland-1.21.0.tar.gz/egl/wayland-egl.h Added

@@ -0,0 +1,33 @@
+/*
+ * Copyright © 2011 Kristian Høgsberg
+ * Copyright © 2011 Benjamin Franzke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_EGL_H
+#define WAYLAND_EGL_H
+
+#include <wayland-client.h>
+#include "wayland-egl-core.h"
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/meson.build Added

@@ -0,0 +1,140 @@
+project(
+	'wayland', 'c',
+	version: '1.21.0',
+	license: 'MIT',
+	meson_version: '>= 0.56.0',
+	default_options: 
+		'warning_level=2',
+		'buildtype=debugoptimized',
+		'c_std=c99',
+	
+)
+wayland_version = meson.project_version().split('.')
+
+config_h = configuration_data()
+config_h.set_quoted('PACKAGE', meson.project_name())
+config_h.set_quoted('PACKAGE_VERSION', meson.project_version())
+
+cc_args = 
+if host_machine.system() != 'freebsd'
+	cc_args += '-D_POSIX_C_SOURCE=200809L'
+endif
+add_project_arguments(cc_args, language: 'c')
+
+compiler_flags = 
+	'-Wno-unused-parameter',
+	'-Wstrict-prototypes',
+	'-Wmissing-prototypes',
+	'-fvisibility=hidden',
+
+
+cc = meson.get_compiler('c')
+add_project_arguments(
+	cc.get_supported_arguments(compiler_flags),
+	language: 'c'
+)
+
+foreach h:  'sys/prctl.h', 'sys/procctl.h', 'sys/ucred.h' 
+	config_h.set('HAVE_' + h.underscorify().to_upper(), cc.has_header(h))
+endforeach
+
+have_funcs = 
+	'accept4',
+	'mkostemp',
+	'posix_fallocate',
+	'prctl',
+	'memfd_create',
+	'mremap',
+	'strndup',
+
+foreach f: have_funcs
+	config_h.set('HAVE_' + f.underscorify().to_upper(), cc.has_function(f))
+endforeach
+config_h.set10('HAVE_XUCRED_CR_PID', cc.has_member('struct xucred', 'cr_pid', prefix : '#include <sys/ucred.h>'))
+have_broken_msg_cmsg_cloexec = false
+if host_machine.system() == 'freebsd'
+	have_broken_msg_cmsg_cloexec = not cc.compiles('''
+#include <sys/param.h> /* To get __FreeBSD_version. */
+#if __FreeBSD_version < 1300502 || \
+    (__FreeBSD_version >= 1400000 && __FreeBSD_version < 1400006)
+/*
+ * FreeBSD had a broken implementation of MSG_CMSG_CLOEXEC between 2015 and
+ * 2021. Check if we are compiling against a version that includes the fix
+ * (https://cgit.freebsd.org/src/commit/?id=6ceacebdf52211).
+ */
+#error "Broken MSG_CMSG_CLOEXEC"
+#endif
+''', name : 'MSG_CMSG_CLOEXEC works correctly')
+endif
+config_h.set10('HAVE_BROKEN_MSG_CMSG_CLOEXEC', have_broken_msg_cmsg_cloexec)
+
+if get_option('libraries')
+	if host_machine.system() == 'freebsd'
+		# When building for FreeBSD, epoll(7) is provided by a userspace
+		# wrapper around kqueue(2).
+		epoll_dep = dependency('epoll-shim')
+	else
+		# Otherwise, assume that epoll(7) is supported natively.
+		epoll_dep = 
+	endif
+	ffi_dep = dependency('libffi')
+
+	decls = 
+		{ 'header': 'sys/signalfd.h', 'symbol': 'SFD_CLOEXEC' },
+		{ 'header': 'sys/timerfd.h', 'symbol': 'TFD_CLOEXEC' },
+		{ 'header': 'time.h', 'symbol': 'CLOCK_MONOTONIC' },
+	
+
+	foreach d: decls
+		if not cc.has_header_symbol(d'header', d'symbol', dependencies: epoll_dep, args: cc_args)
+			error('@0@ is needed to compile Wayland libraries'.format(d'symbol'))
+		endif
+	endforeach
+
+	rt_dep = 
+	if not cc.has_function('clock_gettime', prefix: '#include <time.h>')
+		rt_dep = cc.find_library('rt')
+		if not cc.has_function('clock_gettime', prefix: '#include <time.h>', dependencies: rt_dep, args: cc_args)
+			error('clock_gettime not found')
+		endif
+	endif
+endif
+
+configure_file(
+	output: 'config.h',
+	configuration: config_h,
+)
+
+pkgconfig = import('pkgconfig')
+
+wayland_protocol_xml = files('protocol/wayland.xml')
+
+root_inc = include_directories('.')
+protocol_inc = include_directories('protocol')
+src_inc = include_directories('src')
+
+subdir('src')
+
+if get_option('libraries')
+	subdir('cursor')
+	subdir('egl')
+endif
+if get_option('tests')
+	subdir('tests')
+endif
+if get_option('documentation')
+	subdir('doc')
+endif
+
+if get_option('scanner')
+	install_data(
+		'wayland-scanner.mk',
+		'protocol/wayland.xml',
+		'protocol/wayland.dtd',
+	)
+
+	install_data(
+		 'wayland-scanner.m4' ,
+		install_dir: join_paths(get_option('prefix'), get_option('datadir'), 'aclocal'),
+	)
+endif

_service:tar_scm:wayland-1.21.0.tar.gz/meson_options.txt Added

_service:tar_scm:wayland-1.21.0.tar.gz/protocol Added

_service:tar_scm:wayland-1.21.0.tar.gz/protocol/.gitignore Added

_service:tar_scm:wayland-1.21.0.tar.gz/protocol/generate-shm-formats.py Added

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+
+# This script synchronizes wayland.xml's wl_shm.format enum with drm_fourcc.h.
+# Invoke it to update wayland.xml, then manually check the changes applied.
+#
+# Requires Python 3, python-lxml, a C compiler and pkg-config.
+
+import os
+import subprocess
+import sys
+import tempfile
+# We need lxml instead of the standard library because we want
+# Element.sourceline
+from lxml import etree as ElementTree
+
+proto_dir = os.path.dirname(os.path.realpath(__file__))
+wayland_proto = proto_dir + "/wayland.xml"
+
+cc = os.getenv("CC", "cc")
+pkg_config = os.getenv("PKG_CONFIG", "pkg-config")
+
+# Find drm_fourcc.h
+version = subprocess.check_output(pkg_config, "libdrm",
+    "--modversion").decode().strip()
+cflags = subprocess.check_output(pkg_config, "libdrm",
+    "--cflags-only-I").decode().strip().split()
+libdrm_include = None
+for include_flag in cflags:
+    if not include_flag.startswith("-I"):
+        raise Exception("Expected one include dir for libdrm")
+    include_dir = include_flag2:
+    if include_dir.endswith("/libdrm"):
+        libdrm_include = include_dir
+        fourcc_include = libdrm_include + "/drm_fourcc.h"
+if libdrm_include == None:
+    raise Exception("Failed to find libdrm include dir")
+
+print("Using libdrm " + version, file=sys.stderr)
+
+def drm_format_to_wl(ident):
+    return ident.replace("DRM_FORMAT_", "").lower()
+
+# Collect DRM format constant names
+ident_list = 
+descriptions = {}
+prev_comment = None
+with open(fourcc_include) as input_file:
+    for l in input_file.readlines():
+        l = l.strip()
+
+        # Collect comments right before format definitions
+        if l.startswith("/*") and l.endswith("*/"):
+            prev_comment = l2:-2
+            continue
+        desc = prev_comment
+        prev_comment = None
+
+        # Recognize format definitions
+        parts = l.split()
+        if len(parts) < 3 or parts0 != "#define":
+            continue
+        ident = parts1
+        if not ident.startswith("DRM_FORMAT_") or ident.startswith(
+                "DRM_FORMAT_MOD_"):
+            continue
+
+        ident_list.append(ident)
+
+        # Prefer in-line comments
+        if l.endswith("*/"):
+            desc = ll.rfind("/*") + 2:-2
+        if desc != None:
+            descriptionsdrm_format_to_wl(ident) = desc.strip()
+
+# Collect DRM format values
+idents = {}
+with tempfile.TemporaryDirectory() as work_dir:
+    c_file_name = work_dir + "/print-formats.c"
+    exe_file_name = work_dir + "/print-formats"
+
+    with open(c_file_name, "w+") as c_file:
+        c_file.write('#include <inttypes.h>\n')
+        c_file.write('#include <stdint.h>\n')
+        c_file.write('#include <stdio.h>\n')
+        c_file.write('#include <drm_fourcc.h>\n')
+        c_file.write('\n')
+        c_file.write('int main(void) {\n')
+        for ident in ident_list:
+            c_file.write('printf("0x%" PRIX64 "\\n", (uint64_t)' + ident + ');\n')
+        c_file.write('}\n')
+
+    subprocess.check_call(cc, "-Wall", "-Wextra", "-o", exe_file_name,
+        c_file_name + cflags)
+    output = subprocess.check_output(exe_file_name).decode().strip()
+    for i, val in enumerate(output.splitlines()):
+        identsident_listi = val
+
+# We don't need those
+del idents"DRM_FORMAT_BIG_ENDIAN"
+del idents"DRM_FORMAT_INVALID"
+del idents"DRM_FORMAT_RESERVED"
+
+# Convert from DRM constants to Wayland wl_shm.format entries
+formats = {}
+for ident, val in idents.items():
+    formatsdrm_format_to_wl(ident) = val.lower()
+# Special case for ARGB8888 and XRGB8888
+formats"argb8888" = "0"
+formats"xrgb8888" = "1"
+
+print("Loaded {} formats from drm_fourcc.h".format(len(formats)), file=sys.stderr)
+
+tree = ElementTree.parse("wayland.xml")
+root = tree.getroot()
+wl_shm_format = root.find("./interface@name='wl_shm'/enum@name='format'")
+if wl_shm_format == None:
+    raise Exception("wl_shm.format not found in wayland.xml")
+
+# Remove formats we already know about
+last_line = None
+for node in wl_shm_format:
+    if node.tag != "entry":
+        continue
+    fmt = node.attrib"name"
+    val = node.attrib"value"
+    if fmt not in formats:
+        raise Exception("Format present in wl_shm.formats but not in "
+            "drm_fourcc.h: " + fmt)
+    if val != formatsfmt:
+        raise Exception("Format value in wl_shm.formats ({}) differs "
+            "from value in drm_fourcc.h ({}) for format {}"
+            .format(val, formatsfmt, fmt))
+    del formatsfmt
+    last_line = node.sourceline
+if last_line == None:
+    raise Exception("Expected at least one existing wl_shm.format entry")
+
+print("Adding {} formats to wayland.xml...".format(len(formats)), file=sys.stderr)
+
+# Append new formats
+new_wayland_proto = wayland_proto + ".new"
+with open(new_wayland_proto, "w+") as output_file, \
+        open(wayland_proto) as input_file:
+    for i, l in enumerate(input_file.readlines()):
+        output_file.write(l)
+        if i + 1 == last_line:
+            for fmt, val in formats.items():
+                output_file.write('      <entry name="{}" value="{}"'
+                    .format(fmt, val))
+                if fmt in descriptions:
+                    output_file.write(' summary="{}"'.format(descriptionsfmt))
+                output_file.write('/>\n')
+os.rename(new_wayland_proto, wayland_proto)

_service:tar_scm:wayland-1.21.0.tar.gz/protocol/tests.xml Added

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="build_time_wayland_tests">
+
+  <copyright>
+    Copyright © 2017 Samsung Electronics Co., Ltd
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation files
+    (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the
+    next paragraph) shall be included in all copies or substantial
+    portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  </copyright>
+
+  <interface name="fd_passer" version="2">
+    <description summary="Sends an event with an fd">
+      A trivial interface for fd passing tests.
+    </description>
+
+    <request name="destroy" type="destructor"/>
+
+    <event name="pre_fd"/>
+
+    <event name="fd">
+      <description summary="passes a file descriptor"/>
+      <arg name="fd" type="fd" summary="file descriptor"/>
+    </event>
+
+    
+    <request name="conjoin" since="2">
+      <description summary="register another fd passer with this one">
+	Tells this fd passer object about another one to send events
+	to for more complicated fd leak tests.
+      </description>
+      <arg name="passer" type="object" interface="fd_passer"/>
+    </request>
+  </interface>
+</protocol>

_service:tar_scm:wayland-1.21.0.tar.gz/protocol/wayland.dtd Added

@@ -0,0 +1,32 @@
+<!ELEMENT protocol (copyright?, description?, interface+)>
+  <!ATTLIST protocol name CDATA #REQUIRED>
+<!ELEMENT copyright (#PCDATA)>
+<!ELEMENT interface (description?,(request|event|enum)+)>
+  <!ATTLIST interface name CDATA #REQUIRED>
+  <!ATTLIST interface version CDATA #REQUIRED>
+<!ELEMENT request (description?,arg*)>
+  <!ATTLIST request name CDATA #REQUIRED>
+  <!ATTLIST request type CDATA #IMPLIED>
+  <!ATTLIST request since CDATA #IMPLIED>
+<!ELEMENT event (description?,arg*)>
+  <!ATTLIST event name CDATA #REQUIRED>
+  <!ATTLIST event type CDATA #IMPLIED>
+  <!ATTLIST event since CDATA #IMPLIED>
+<!ELEMENT enum (description?,entry*)>
+  <!ATTLIST enum name CDATA #REQUIRED>
+  <!ATTLIST enum since CDATA #IMPLIED>
+  <!ATTLIST enum bitfield CDATA #IMPLIED>
+<!ELEMENT entry (description?)>
+  <!ATTLIST entry name CDATA #REQUIRED>
+  <!ATTLIST entry value CDATA #REQUIRED>
+  <!ATTLIST entry summary CDATA #IMPLIED>
+  <!ATTLIST entry since CDATA #IMPLIED>
+<!ELEMENT arg (description?)>
+  <!ATTLIST arg name CDATA #REQUIRED>
+  <!ATTLIST arg type CDATA #REQUIRED>
+  <!ATTLIST arg summary CDATA #IMPLIED>
+  <!ATTLIST arg interface CDATA #IMPLIED>
+  <!ATTLIST arg allow-null CDATA #IMPLIED>
+  <!ATTLIST arg enum CDATA #IMPLIED>
+<!ELEMENT description (#PCDATA)>
+  <!ATTLIST description summary CDATA #REQUIRED>

_service:tar_scm:wayland-1.21.0.tar.gz/protocol/wayland.xml Added

@@ -0,0 +1,3058 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wayland">
+
+  <copyright>
+    Copyright © 2008-2011 Kristian Høgsberg
+    Copyright © 2010-2011 Intel Corporation
+    Copyright © 2012-2013 Collabora, Ltd.
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation files
+    (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the
+    next paragraph) shall be included in all copies or substantial
+    portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  </copyright>
+
+  <interface name="wl_display" version="1">
+    <description summary="core global object">
+      The core global object.  This is a special singleton object.  It
+      is used for internal Wayland protocol features.
+    </description>
+
+    <request name="sync">
+      <description summary="asynchronous roundtrip">
+	The sync request asks the server to emit the 'done' event
+	on the returned wl_callback object.  Since requests are
+	handled in-order and events are delivered in-order, this can
+	be used as a barrier to ensure all previous requests and the
+	resulting events have been handled.
+
+	The object returned by this request will be destroyed by the
+	compositor after the callback is fired and as such the client must not
+	attempt to use it after that point.
+
+	The callback_data passed in the callback is the event serial.
+      </description>
+      <arg name="callback" type="new_id" interface="wl_callback"
+	   summary="callback object for the sync request"/>
+    </request>
+
+    <request name="get_registry">
+      <description summary="get global registry object">
+	This request creates a registry object that allows the client
+	to list and bind the global objects available from the
+	compositor.
+
+	It should be noted that the server side resources consumed in
+	response to a get_registry request can only be released when the
+	client disconnects, not when the client side proxy is destroyed.
+	Therefore, clients should invoke get_registry as infrequently as
+	possible to avoid wasting memory.
+      </description>
+      <arg name="registry" type="new_id" interface="wl_registry"
+	   summary="global registry object"/>
+    </request>
+
+    <event name="error">
+      <description summary="fatal error event">
+	The error event is sent out when a fatal (non-recoverable)
+	error has occurred.  The object_id argument is the object
+	where the error occurred, most often in response to a request
+	to that object.  The code identifies the error and is defined
+	by the object interface.  As such, each interface defines its
+	own set of error codes.  The message is a brief description
+	of the error, for (debugging) convenience.
+      </description>
+      <arg name="object_id" type="object" summary="object where the error occurred"/>
+      <arg name="code" type="uint" summary="error code"/>
+      <arg name="message" type="string" summary="error description"/>
+    </event>
+
+    <enum name="error">
+      <description summary="global error values">
+	These errors are global and can be emitted in response to any
+	server request.
+      </description>
+      <entry name="invalid_object" value="0"
+	     summary="server couldn't find object"/>
+      <entry name="invalid_method" value="1"
+	     summary="method doesn't exist on the specified interface or malformed request"/>
+      <entry name="no_memory" value="2"
+	     summary="server is out of memory"/>
+      <entry name="implementation" value="3"
+	     summary="implementation error in compositor"/>
+    </enum>
+
+    <event name="delete_id">
+      <description summary="acknowledge object ID deletion">
+	This event is used internally by the object ID management
+	logic. When a client deletes an object that it had created,
+	the server will send this event to acknowledge that it has
+	seen the delete request. When the client receives this event,
+	it will know that it can safely reuse the object ID.
+      </description>
+      <arg name="id" type="uint" summary="deleted object ID"/>
+    </event>
+  </interface>
+
+  <interface name="wl_registry" version="1">
+    <description summary="global registry object">
+      The singleton global registry object.  The server has a number of
+      global objects that are available to all clients.  These objects
+      typically represent an actual object in the server (for example,
+      an input device) or they are singleton objects that provide
+      extension functionality.
+
+      When a client creates a registry object, the registry object
+      will emit a global event for each global currently in the
+      registry.  Globals come and go as a result of device or
+      monitor hotplugs, reconfiguration or other events, and the
+      registry will send out global and global_remove events to
+      keep the client up to date with the changes.  To mark the end
+      of the initial burst of events, the client can use the
+      wl_display.sync request immediately after calling
+      wl_display.get_registry.
+
+      A client can bind to a global object by using the bind
+      request.  This creates a client-side handle that lets the object
+      emit events to the client and lets the client invoke requests on
+      the object.
+    </description>
+
+    <request name="bind">
+      <description summary="bind an object to the display">
+	Binds a new, client-created object to the server using the
+	specified name as the identifier.
+      </description>
+      <arg name="name" type="uint" summary="unique numeric name of the object"/>
+      <arg name="id" type="new_id" summary="bounded object"/>
+    </request>
+
+    <event name="global">
+      <description summary="announce global object">
+	Notify the client of global objects.
+
+	The event notifies the client that a global object with
+	the given name is now available, and it implements the
+	given version of the given interface.
+      </description>
+      <arg name="name" type="uint" summary="numeric name of the global object"/>
+      <arg name="interface" type="string" summary="interface implemented by the object"/>
+      <arg name="version" type="uint" summary="interface version"/>
+    </event>
+
+    <event name="global_remove">
+      <description summary="announce removal of global object">
+	Notify the client of removed global objects.
+
+	This event notifies the client that the global identified
+	by name is no longer available.  If the client bound to
+	the global using the bind request, the client should now
+	destroy that object.
+
+	The object remains valid and requests to the object will be
+	ignored until the client destroys it, to avoid races between
+	the global going away and a client sending a request to it.
+      </description>
+      <arg name="name" type="uint" summary="numeric name of the global object"/>
+    </event>
+  </interface>
+
+  <interface name="wl_callback" version="1">
+    <description summary="callback object">
+      Clients can handle the 'done' event to get notified when
+      the related request is done.
+    </description>
+
+    <event name="done" type="destructor">
+      <description summary="done event">
+	Notify the client when the related request is done.
+      </description>
+      <arg name="callback_data" type="uint" summary="request-specific data for the callback"/>
+    </event>
+  </interface>
+
+  <interface name="wl_compositor" version="5">
+    <description summary="the compositor singleton">
+      A compositor.  This object is a singleton global.  The
+      compositor is in charge of combining the contents of multiple
+      surfaces into one displayable output.
+    </description>
+
+    <request name="create_surface">
+      <description summary="create new surface">
+	Ask the compositor to create a new surface.

_service:tar_scm:wayland-1.21.0.tar.gz/releasing.txt Added

@@ -0,0 +1,78 @@
+To make a release of Wayland, follow these steps.
+
+  0.  Verify the test suites and codebase checks pass.  All of the
+      tests should either pass or skip.
+
+      $ ninja -C build/ test
+
+  1.  Update the first stanza of meson.build to the intended version.
+
+      Then commit your changes:
+
+      $ export RELEASE_NUMBER="x.y.z"
+      $ export RELEASE_NAME="alpha|beta|RC1|RC2|official|point"
+      $ git status
+      $ git commit meson.build -m "build: bump to version $RELEASE_NUMBER for the $RELEASE_NAME release"
+      $ git push
+
+  2.  Run the release.sh script to generate the tarballs, sign and
+      upload them, and generate a release announcement template.
+      This script can be obtained from X.org's modular package:
+
+        http://cgit.freedesktop.org/xorg/util/modular/tree/release.sh
+
+      The script supports a --dry-run option to test it without actually
+      doing a release.  If the script fails on the distcheck step due to
+      a testsuite error that can't be fixed for some reason, you can
+      skip testsuite by specifying the --dist argument.  Pass --help to
+      see other supported options.
+
+      $ release.sh .
+
+      For Wayland official and point releases, also publish the publican
+      documentation to wayland.freedesktop.org:
+
+      $ ./publish-doc
+
+  3.  Compose the release announcements.  The script will generate
+      *.x.y.z.announce files with a list of changes and tags.  Prepend
+      it with a human-readable listing of the most notable changes.
+      For x.y.0 releases, indicate the schedule for the x.y+1.0
+      release.
+
+  4.  PGP sign the release announcements and send them to
+      wayland-devel@lists.freedesktop.org
+
+  5.  Update releases.html in wayland-web with links to tarballs and
+      the release email URL.
+
+      The wl_register_release script in wayland-web will generate an HTML
+      snippet that can be pasted into releases.html (or e.g. in emacs
+      insert it via "C-u M-! scripts/wl_register_release x.y.z") and
+      customized.
+
+      Once satisfied:
+
+      $ git commit ./releases.html -m "releases: Add ${RELEASE_NUMBER} release"
+      $ git push
+      $ ./deploy
+
+For x.y.0 releases, also create the release series x.y branch.  The x.y
+branch is for bug fixes and conservative changes to the x.y.0 release,
+and is where we create x.y.z releases from.  Creating the x.y branch
+opens up master for new development and lets new development move on.
+We've done this both after the x.y.0 release (to focus development on
+bug fixing for the x.y.1 release for a little longer) or before the
+x.y.0 release (like we did with the 1.5.0 release, to unblock master
+development early).
+
+    $ git branch x.y sha
+    $ git push origin x.y
+
+The master branch's meson.build version should always be (at least)
+x.y.90, with x.y being the most recent stable branch.  The stable
+branch's meson.build version is just whatever was most recently
+released from that branch.
+
+For stable branches, we commit fixes to master first, then cherry-pick
+them back to the stable branch.

_service:tar_scm:wayland-1.21.0.tar.gz/src Added

_service:tar_scm:wayland-1.21.0.tar.gz/src/.gitignore Added

_service:tar_scm:wayland-1.21.0.tar.gz/src/connection.c Added

@@ -0,0 +1,1389 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ * Copyright © 2013 Jason Ekstrand
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/uio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <time.h>
+#include <ffi.h>
+
+#include "wayland-util.h"
+#include "wayland-private.h"
+#include "wayland-os.h"
+
+static inline uint32_t
+div_roundup(uint32_t n, size_t a)
+{
+	/* The cast to uint64_t is necessary to prevent overflow when rounding
+	 * values close to UINT32_MAX. After the division it is again safe to
+	 * cast back to uint32_t.
+	 */
+	return (uint32_t) (((uint64_t) n + (a - 1)) / a);
+}
+
+struct wl_ring_buffer {
+	char data4096;
+	uint32_t head, tail;
+};
+
+#define MASK(i) ((i) & 4095)
+
+#define MAX_FDS_OUT	28
+#define CLEN		(CMSG_LEN(MAX_FDS_OUT * sizeof(int32_t)))
+
+struct wl_connection {
+	struct wl_ring_buffer in, out;
+	struct wl_ring_buffer fds_in, fds_out;
+	int fd;
+	int want_flush;
+};
+
+static int
+ring_buffer_put(struct wl_ring_buffer *b, const void *data, size_t count)
+{
+	uint32_t head, size;
+
+	if (count > sizeof(b->data)) {
+		wl_log("Data too big for buffer (%d > %d).\n",
+		       count, sizeof(b->data));
+		errno = E2BIG;
+		return -1;
+	}
+
+	head = MASK(b->head);
+	if (head + count <= sizeof b->data) {
+		memcpy(b->data + head, data, count);
+	} else {
+		size = sizeof b->data - head;
+		memcpy(b->data + head, data, size);
+		memcpy(b->data, (const char *) data + size, count - size);
+	}
+
+	b->head += count;
+
+	return 0;
+}
+
+static void
+ring_buffer_put_iov(struct wl_ring_buffer *b, struct iovec *iov, int *count)
+{
+	uint32_t head, tail;
+
+	head = MASK(b->head);
+	tail = MASK(b->tail);
+	if (head < tail) {
+		iov0.iov_base = b->data + head;
+		iov0.iov_len = tail - head;
+		*count = 1;
+	} else if (tail == 0) {
+		iov0.iov_base = b->data + head;
+		iov0.iov_len = sizeof b->data - head;
+		*count = 1;
+	} else {
+		iov0.iov_base = b->data + head;
+		iov0.iov_len = sizeof b->data - head;
+		iov1.iov_base = b->data;
+		iov1.iov_len = tail;
+		*count = 2;
+	}
+}
+
+static void
+ring_buffer_get_iov(struct wl_ring_buffer *b, struct iovec *iov, int *count)
+{
+	uint32_t head, tail;
+
+	head = MASK(b->head);
+	tail = MASK(b->tail);
+	if (tail < head) {
+		iov0.iov_base = b->data + tail;
+		iov0.iov_len = head - tail;
+		*count = 1;
+	} else if (head == 0) {
+		iov0.iov_base = b->data + tail;
+		iov0.iov_len = sizeof b->data - tail;
+		*count = 1;
+	} else {
+		iov0.iov_base = b->data + tail;
+		iov0.iov_len = sizeof b->data - tail;
+		iov1.iov_base = b->data;
+		iov1.iov_len = head;
+		*count = 2;
+	}
+}
+
+static void
+ring_buffer_copy(struct wl_ring_buffer *b, void *data, size_t count)
+{
+	uint32_t tail, size;
+
+	tail = MASK(b->tail);
+	if (tail + count <= sizeof b->data) {
+		memcpy(data, b->data + tail, count);
+	} else {
+		size = sizeof b->data - tail;
+		memcpy(data, b->data + tail, size);
+		memcpy((char *) data + size, b->data, count - size);
+	}
+}
+
+static uint32_t
+ring_buffer_size(struct wl_ring_buffer *b)
+{
+	return b->head - b->tail;
+}
+
+struct wl_connection *
+wl_connection_create(int fd)
+{
+	struct wl_connection *connection;
+
+	connection = zalloc(sizeof *connection);
+	if (connection == NULL)
+		return NULL;
+
+	connection->fd = fd;
+
+	return connection;
+}
+
+static void
+close_fds(struct wl_ring_buffer *buffer, int max)
+{
+	int32_t fdssizeof(buffer->data) / sizeof(int32_t), i, count;
+	size_t size;
+
+	size = ring_buffer_size(buffer);
+	if (size == 0)
+		return;
+
+	ring_buffer_copy(buffer, fds, size);
+	count = size / sizeof fds0;
+	if (max > 0 && max < count)
+		count = max;
+	size = count * sizeof fds0;
+	for (i = 0; i < count; i++)
+		close(fdsi);

_service:tar_scm:wayland-1.21.0.tar.gz/src/embed.py Added

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+
+"""
+Simple C data embedder
+
+License: MIT
+
+Copyright (c) 2020 Simon Ser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import sys
+
+if len(sys.argv) != 3:
+    print('usage: ' + sys.argv0 + ' <filename> <ident>', file=sys.stderr)
+    sys.exit(1)
+
+filename = sys.argv1
+ident = sys.argv2
+
+with open(filename, 'rb') as f:
+    buf = f.read()
+
+print('static const char ' + ident + ' = {\n\t', end='')
+for i in range(len(buf)):
+    ch = bufi:i+1
+    print('0x' + ch.hex() + ', ', end='')
+print('\n};')

_service:tar_scm:wayland-1.21.0.tar.gz/src/event-loop.c Added

@@ -0,0 +1,1090 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/epoll.h>
+#include <sys/signalfd.h>
+#include <sys/timerfd.h>
+#include <unistd.h>
+#include "wayland-util.h"
+#include "wayland-private.h"
+#include "wayland-server-core.h"
+#include "wayland-os.h"
+
+/** \cond INTERNAL */
+
+#define TIMER_REMOVED -2
+
+struct wl_event_loop;
+struct wl_event_source_interface;
+struct wl_event_source_timer;
+
+struct wl_event_source {
+	struct wl_event_source_interface *interface;
+	struct wl_event_loop *loop;
+	struct wl_list link;
+	void *data;
+	int fd;
+};
+
+struct wl_timer_heap {
+	struct wl_event_source base;
+	/* pointers to the user-visible event sources */
+	struct wl_event_source_timer **data;
+	int space, active, count;
+};
+
+struct wl_event_loop {
+	int epoll_fd;
+	struct wl_list check_list;
+	struct wl_list idle_list;
+	struct wl_list destroy_list;
+
+	struct wl_signal destroy_signal;
+
+	struct wl_timer_heap timers;
+};
+
+struct wl_event_source_interface {
+	int (*dispatch)(struct wl_event_source *source,
+			struct epoll_event *ep);
+};
+
+
+struct wl_event_source_fd {
+	struct wl_event_source base;
+	wl_event_loop_fd_func_t func;
+	int fd;
+};
+
+/** \endcond */
+
+static int
+wl_event_source_fd_dispatch(struct wl_event_source *source,
+			    struct epoll_event *ep)
+{
+	struct wl_event_source_fd *fd_source = (struct wl_event_source_fd *) source;
+	uint32_t mask;
+
+	mask = 0;
+	if (ep->events & EPOLLIN)
+		mask |= WL_EVENT_READABLE;
+	if (ep->events & EPOLLOUT)
+		mask |= WL_EVENT_WRITABLE;
+	if (ep->events & EPOLLHUP)
+		mask |= WL_EVENT_HANGUP;
+	if (ep->events & EPOLLERR)
+		mask |= WL_EVENT_ERROR;
+
+	return fd_source->func(fd_source->fd, mask, source->data);
+}
+
+struct wl_event_source_interface fd_source_interface = {
+	wl_event_source_fd_dispatch,
+};
+
+static struct wl_event_source *
+add_source(struct wl_event_loop *loop,
+	   struct wl_event_source *source, uint32_t mask, void *data)
+{
+	struct epoll_event ep;
+
+	if (source->fd < 0) {
+		free(source);
+		return NULL;
+	}
+
+	source->loop = loop;
+	source->data = data;
+	wl_list_init(&source->link);
+
+	memset(&ep, 0, sizeof ep);
+	if (mask & WL_EVENT_READABLE)
+		ep.events |= EPOLLIN;
+	if (mask & WL_EVENT_WRITABLE)
+		ep.events |= EPOLLOUT;
+	ep.data.ptr = source;
+
+	if (epoll_ctl(loop->epoll_fd, EPOLL_CTL_ADD, source->fd, &ep) < 0) {
+		close(source->fd);
+		free(source);
+		return NULL;
+	}
+
+	return source;
+}
+
+/** Create a file descriptor event source
+ *
+ * \param loop The event loop that will process the new source.
+ * \param fd The file descriptor to watch.
+ * \param mask A bitwise-or of which events to watch for: \c WL_EVENT_READABLE,
+ * \c WL_EVENT_WRITABLE.
+ * \param func The file descriptor dispatch function.
+ * \param data User data.
+ * \return A new file descriptor event source.
+ *
+ * The given file descriptor is initially watched for the events given in
+ * \c mask. This can be changed as needed with wl_event_source_fd_update().
+ *
+ * If it is possible that program execution causes the file descriptor to be
+ * read while leaving the data in a buffer without actually processing it,
+ * it may be necessary to register the file descriptor source to be re-checked,
+ * see wl_event_source_check(). This will ensure that the dispatch function
+ * gets called even if the file descriptor is not readable or writable
+ * anymore. This is especially useful with IPC libraries that automatically
+ * buffer incoming data, possibly as a side-effect of other operations.
+ *
+ * \sa wl_event_loop_fd_func_t
+ * \memberof wl_event_source
+ */
+WL_EXPORT struct wl_event_source *
+wl_event_loop_add_fd(struct wl_event_loop *loop,
+		     int fd, uint32_t mask,
+		     wl_event_loop_fd_func_t func,
+		     void *data)
+{
+	struct wl_event_source_fd *source;
+
+	source = zalloc(sizeof *source);
+	if (source == NULL)
+		return NULL;
+
+	source->base.interface = &fd_source_interface;
+	source->base.fd = wl_os_dupfd_cloexec(fd, 0);
+	source->func = func;
+	source->fd = fd;
+
+	return add_source(loop, &source->base, mask, data);
+}
+
+/** Update a file descriptor source's event mask
+ *
+ * \param source The file descriptor event source to update.
+ * \param mask The new mask, a bitwise-or of: \c WL_EVENT_READABLE,
+ * \c WL_EVENT_WRITABLE.
+ * \return 0 on success, -1 on failure.

_service:tar_scm:wayland-1.21.0.tar.gz/src/meson.build Added

@@ -0,0 +1,277 @@
+if not (get_option('scanner') or get_option('libraries'))
+	error('Either -Dscanner=true or -Dlibraries=true is required')
+endif
+
+wayland_version_h = configuration_data()
+wayland_version_h.set('WAYLAND_VERSION', meson.project_version())
+wayland_version_h.set('WAYLAND_VERSION_MAJOR', wayland_version0.to_int())
+wayland_version_h.set('WAYLAND_VERSION_MINOR', wayland_version1.to_int())
+wayland_version_h.set('WAYLAND_VERSION_MICRO', wayland_version2.to_int())
+configure_file(
+	input: 'wayland-version.h.in',
+	output: 'wayland-version.h',
+	configuration: wayland_version_h,
+	install: get_option('libraries'),
+	install_dir: join_paths(get_option('prefix'), get_option('includedir'))
+)
+
+
+wayland_util = static_library(
+	'wayland-util',
+	sources: 'wayland-util.c'
+)
+
+wayland_util_dep = declare_dependency(
+	link_with: wayland_util,
+	include_directories: include_directories('.')
+)
+
+if get_option('scanner')
+	# wayland-scanner
+
+	scanner_deps =  dependency('expat') 
+	scanner_args =  '-include', 'config.h' 
+
+	if get_option('dtd_validation')
+		scanner_deps += dependency('libxml-2.0')
+		scanner_args += '-DHAVE_LIBXML=1'
+	endif
+
+	prog_embed = find_program('embed.py', native: true)
+
+	embed_dtd = custom_target(
+		'wayland.dtd.h',
+		input: '../protocol/wayland.dtd',
+		output: 'wayland.dtd.h',
+		command:  prog_embed, '@INPUT@', 'wayland_dtd' ,
+		capture: true
+	)
+
+	wayland_scanner_sources =  'scanner.c', embed_dtd 
+	wayland_scanner_includes =  root_inc, protocol_inc 
+
+	wayland_scanner = executable(
+		'wayland-scanner',
+		wayland_scanner_sources,
+		c_args: scanner_args,
+		include_directories: wayland_scanner_includes,
+		dependencies:  scanner_deps, wayland_util_dep, ,
+		install: true
+	)
+
+	pkgconfig.generate(
+		name: 'Wayland Scanner',
+		description: 'Wayland scanner',
+		version: meson.project_version(),
+		variables: 
+			'datarootdir=' + join_paths('${prefix}', get_option('datadir')),
+			'pkgdatadir=' + join_paths('${datarootdir}', meson.project_name()),
+			'bindir=' + join_paths('${prefix}', get_option('bindir')),
+			'wayland_scanner=${bindir}/wayland-scanner'
+		,
+		filebase: 'wayland-scanner'
+	)
+
+	if meson.can_run_host_binaries()
+		meson.override_find_program('wayland-scanner', wayland_scanner)
+	endif
+endif
+
+if meson.is_cross_build() or not get_option('scanner')
+	scanner_dep = dependency('wayland-scanner', native: true, version: meson.project_version())
+	wayland_scanner_for_build = find_program(scanner_dep.get_variable(pkgconfig: 'wayland_scanner'))
+else
+	wayland_scanner_for_build = wayland_scanner
+endif
+
+if get_option('libraries')
+	# wayland libraries
+
+	mathlib_dep = cc.find_library('m', required: false)
+	threads_dep = dependency('threads', required: false)
+
+	wayland_private = static_library(
+		'wayland-private',
+		sources: 
+			'connection.c',
+			'wayland-os.c'
+		,
+		dependencies:  epoll_dep, ffi_dep, rt_dep 
+	)
+
+	wayland_private_dep = declare_dependency(
+		link_with: wayland_private,
+		include_directories: include_directories('.')
+	)
+
+	generated_headers = 
+		{
+			'scanner_args': 'server-header',
+			'output': 'wayland-server-protocol.h',
+			'install': true,
+		},
+		{
+			'scanner_args': 'server-header', '-c',
+			'output': 'wayland-server-protocol-core.h',
+			'install': false,
+		},
+		{
+			'scanner_args': 'client-header',
+			'output': 'wayland-client-protocol.h',
+			'install': true,
+		},
+		{
+			'scanner_args': 'client-header', '-c',
+			'output': 'wayland-client-protocol-core.h',
+			'install': false,
+		},
+	
+
+	foreach gen: generated_headers
+		scanner_args = gen'scanner_args'
+		output_file = gen'output'
+		install_file = gen'install'
+		install_dir = join_paths(get_option('prefix'), get_option('includedir'))
+		target_name = output_file.underscorify()
+
+		target = custom_target(
+			target_name,
+			command: 
+				wayland_scanner_for_build, '-s', scanner_args,
+				'@INPUT@', '@OUTPUT@'
+			,
+			input: wayland_protocol_xml,
+			output: output_file,
+			install: install_file,
+			install_dir: install_dir
+		)
+
+		set_variable(target_name, target)
+	endforeach
+
+	wayland_protocol_c = custom_target(
+		'protocol source',
+		command: 
+			wayland_scanner_for_build, '-s', 'public-code', '@INPUT@', '@OUTPUT@'
+		,
+		input: wayland_protocol_xml,
+		output: 'wayland-protocol.c'
+	)
+
+	if wayland_version0 != '1'
+		# The versioning used for the shared libraries assumes that the major
+		# version of Wayland as a whole will increase to 2 if and only if there
+		# is an ABI break, at which point we should probably bump the SONAME of
+		# all libraries to .so.2. For more details see
+		# https://gitlab.freedesktop.org/wayland/wayland/-/merge_requests/177
+		error('We probably need to bump the SONAME of libwayland-server and -client')
+	endif
+
+	wayland_server = library(
+		'wayland-server',
+		sources: 
+			wayland_server_protocol_core_h,
+			wayland_server_protocol_h,
+			wayland_protocol_c,
+			'wayland-server.c',
+			'wayland-shm.c',
+			'event-loop.c'
+		,
+		# To avoid an unnecessary SONAME bump, wayland 1.x.y produces
+		# libwayland-server.so.0.x.y.
+		version: '.'.join('0', wayland_version1, wayland_version2),
+		dependencies: 
+			epoll_dep,
+			ffi_dep,
+			wayland_private_dep,
+			wayland_util_dep,
+			mathlib_dep,
+			threads_dep,
+			rt_dep
+		,
+		include_directories: root_inc,
+		install: true
+	)
+
+	wayland_server_dep = declare_dependency(
+		link_with: wayland_server,
+		include_directories:  root_inc, include_directories('.') ,
+		dependencies:  epoll_dep, ffi_dep, mathlib_dep, threads_dep ,

_service:tar_scm:wayland-1.21.0.tar.gz/src/scanner.c Added

@@ -0,0 +1,2085 @@
+/*
+ * Copyright © 2008-2011 Kristian Høgsberg
+ * Copyright © 2011 Intel Corporation
+ * Copyright © 2015 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "wayland-version.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <getopt.h>
+#include <limits.h>
+#include <unistd.h>
+
+#if HAVE_LIBXML
+#include <libxml/parser.h>
+
+/* Embedded wayland.dtd file */
+/* static const char wayland_dtd; wayland.dtd */
+#include "wayland.dtd.h"
+#endif
+
+/* Expat must be included after libxml as both want to declare XMLCALL; see
+ * the Git commit that 'git blame' for this comment points to for more. */
+#include <expat.h>
+
+#include "wayland-util.h"
+
+#define PROGRAM_NAME "wayland-scanner"
+
+enum side {
+	CLIENT,
+	SERVER,
+};
+
+enum visibility {
+	PRIVATE,
+	PUBLIC,
+};
+
+static int
+usage(int ret)
+{
+	fprintf(stderr, "usage: %s OPTION client-header|server-header|private-code|public-code"
+		" input_file output_file\n", PROGRAM_NAME);
+	fprintf(stderr, "\n");
+	fprintf(stderr, "Converts XML protocol descriptions supplied on "
+			"stdin or input file to client\n"
+			"headers, server headers, or protocol marshalling code.\n\n"
+			"Use \"public-code\" only if the marshalling code will be public - "
+			"aka DSO will export it while other components will be using it.\n"
+			"Using \"private-code\" is strongly recommended.\n\n");
+	fprintf(stderr, "options:\n");
+	fprintf(stderr, "    -h,  --help                  display this help and exit.\n"
+			"    -v,  --version               print the wayland library version that\n"
+			"                                 the scanner was built against.\n"
+			"    -c,  --include-core-only     include the core version of the headers,\n"
+			"                                 that is e.g. wayland-client-core.h instead\n"
+			"                                 of wayland-client.h.\n"
+			"    -s,  --strict                exit immediately with an error if DTD\n"
+			"                                 verification fails.\n");
+	exit(ret);
+}
+
+static int
+scanner_version(int ret)
+{
+	fprintf(stderr, "%s %s\n", PROGRAM_NAME, WAYLAND_VERSION);
+	exit(ret);
+}
+
+static bool
+is_dtd_valid(FILE *input, const char *filename)
+{
+	bool rc = true;
+#if HAVE_LIBXML
+	xmlParserCtxtPtr ctx = NULL;
+	xmlDocPtr doc = NULL;
+	xmlDtdPtr dtd = NULL;
+	xmlValidCtxtPtr	dtdctx;
+	xmlParserInputBufferPtr	buffer;
+	int fd = fileno(input);
+
+	dtdctx = xmlNewValidCtxt();
+	ctx = xmlNewParserCtxt();
+	if (!ctx || !dtdctx)
+		abort();
+
+	buffer = xmlParserInputBufferCreateMem(wayland_dtd,
+					       sizeof(wayland_dtd),
+					       XML_CHAR_ENCODING_UTF8);
+	if (!buffer) {
+		fprintf(stderr, "Failed to init buffer for DTD.\n");
+		abort();
+	}
+
+	dtd = xmlIOParseDTD(NULL, buffer, XML_CHAR_ENCODING_UTF8);
+	if (!dtd) {
+		fprintf(stderr, "Failed to parse DTD.\n");
+		abort();
+	}
+
+	doc = xmlCtxtReadFd(ctx, fd, filename, NULL, 0);
+	if (!doc) {
+		fprintf(stderr, "Failed to read XML\n");
+		abort();
+	}
+
+	rc = xmlValidateDtd(dtdctx, doc, dtd);
+	xmlFreeDoc(doc);
+	xmlFreeParserCtxt(ctx);
+	xmlFreeDtd(dtd);
+	xmlFreeValidCtxt(dtdctx);
+	/* xmlIOParseDTD consumes buffer */
+
+	if (lseek(fd, 0, SEEK_SET) != 0) {
+		fprintf(stderr, "Failed to reset fd, output would be garbage.\n");
+		abort();
+	}
+#endif
+	return rc;
+}
+
+#define XML_BUFFER_SIZE 4096
+
+struct location {
+	const char *filename;
+	int line_number;
+};
+
+struct description {
+	char *summary;
+	char *text;
+};
+
+struct protocol {
+	char *name;
+	char *uppercase_name;
+	struct wl_list interface_list;
+	int type_index;
+	int null_run_length;
+	char *copyright;
+	struct description *description;
+	bool core_headers;
+};
+
+struct interface {
+	struct location loc;
+	char *name;
+	char *uppercase_name;
+	int version;
+	int since;
+	struct wl_list request_list;
+	struct wl_list event_list;
+	struct wl_list enumeration_list;
+	struct wl_list link;
+	struct description *description;
+};
+
+struct message {
+	struct location loc;
+	char *name;
+	char *uppercase_name;
+	struct wl_list arg_list;
+	struct wl_list link;
+	int arg_count;
+	int new_id_count;
+	int type_index;
+	int all_null;
+	int destructor;
+	int since;
+	struct description *description;
+};

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-client-core.h Added

@@ -0,0 +1,292 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_CLIENT_CORE_H
+#define WAYLAND_CLIENT_CORE_H
+
+#include <stdint.h>
+#include "wayland-util.h"
+#include "wayland-version.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/** \class wl_proxy
+ *
+ * \brief Represents a protocol object on the client side.
+ *
+ * A wl_proxy acts as a client side proxy to an object existing in the
+ * compositor. The proxy is responsible for converting requests made by the
+ * clients with \ref wl_proxy_marshal() into Wayland's wire format. Events
+ * coming from the compositor are also handled by the proxy, which will in
+ * turn call the handler set with \ref wl_proxy_add_listener().
+ *
+ * \note With the exception of function \ref wl_proxy_set_queue(), functions
+ * accessing a wl_proxy are not normally used by client code. Clients
+ * should normally use the higher level interface generated by the scanner to
+ * interact with compositor objects.
+ *
+ */
+struct wl_proxy;
+
+/** \class wl_display
+ *
+ * \brief Represents a connection to the compositor and acts as a proxy to
+ * the wl_display singleton object.
+ *
+ * A wl_display object represents a client connection to a Wayland
+ * compositor. It is created with either \ref wl_display_connect() or
+ * \ref wl_display_connect_to_fd(). A connection is terminated using
+ * \ref wl_display_disconnect().
+ *
+ * A wl_display is also used as the \ref wl_proxy for the wl_display
+ * singleton object on the compositor side.
+ *
+ * A wl_display object handles all the data sent from and to the
+ * compositor. When a \ref wl_proxy marshals a request, it will write its wire
+ * representation to the display's write buffer. The data is sent to the
+ * compositor when the client calls \ref wl_display_flush().
+ *
+ * Incoming data is handled in two steps: queueing and dispatching. In the
+ * queue step, the data coming from the display fd is interpreted and
+ * added to a queue. On the dispatch step, the handler for the incoming
+ * event set by the client on the corresponding \ref wl_proxy is called.
+ *
+ * A wl_display has at least one event queue, called the <em>default
+ * queue</em>. Clients can create additional event queues with \ref
+ * wl_display_create_queue() and assign \ref wl_proxy's to it. Events
+ * occurring in a particular proxy are always queued in its assigned queue.
+ * A client can ensure that a certain assumption, such as holding a lock
+ * or running from a given thread, is true when a proxy event handler is
+ * called by assigning that proxy to an event queue and making sure that
+ * this queue is only dispatched when the assumption holds.
+ *
+ * The default queue is dispatched by calling \ref wl_display_dispatch().
+ * This will dispatch any events queued on the default queue and attempt
+ * to read from the display fd if it's empty. Events read are then queued
+ * on the appropriate queues according to the proxy assignment.
+ *
+ * A user created queue is dispatched with \ref wl_display_dispatch_queue().
+ * This function behaves exactly the same as wl_display_dispatch()
+ * but it dispatches given queue instead of the default queue.
+ *
+ * A real world example of event queue usage is Mesa's implementation of
+ * eglSwapBuffers() for the Wayland platform. This function might need
+ * to block until a frame callback is received, but dispatching the default
+ * queue could cause an event handler on the client to start drawing
+ * again. This problem is solved using another event queue, so that only
+ * the events handled by the EGL code are dispatched during the block.
+ *
+ * This creates a problem where a thread dispatches a non-default
+ * queue, reading all the data from the display fd. If the application
+ * would call \em poll(2) after that it would block, even though there
+ * might be events queued on the default queue. Those events should be
+ * dispatched with \ref wl_display_dispatch_pending() or \ref
+ * wl_display_dispatch_queue_pending() before flushing and blocking.
+ */
+struct wl_display;
+
+/** \class wl_event_queue
+ *
+ * \brief A queue for \ref wl_proxy object events.
+ *
+ * Event queues allows the events on a display to be handled in a thread-safe
+ * manner. See \ref wl_display for details.
+ *
+ */
+struct wl_event_queue;
+
+/** Destroy proxy after marshalling
+ * @ingroup wl_proxy
+ */
+#define WL_MARSHAL_FLAG_DESTROY (1 << 0)
+
+void
+wl_event_queue_destroy(struct wl_event_queue *queue);
+
+struct wl_proxy *
+wl_proxy_marshal_flags(struct wl_proxy *proxy, uint32_t opcode,
+		       const struct wl_interface *interface,
+		       uint32_t version,
+		       uint32_t flags, ...);
+
+struct wl_proxy *
+wl_proxy_marshal_array_flags(struct wl_proxy *proxy, uint32_t opcode,
+			     const struct wl_interface *interface,
+			     uint32_t version,
+			     uint32_t flags,
+			     union wl_argument *args);
+
+void
+wl_proxy_marshal(struct wl_proxy *p, uint32_t opcode, ...);
+
+void
+wl_proxy_marshal_array(struct wl_proxy *p, uint32_t opcode,
+		       union wl_argument *args);
+
+struct wl_proxy *
+wl_proxy_create(struct wl_proxy *factory,
+		const struct wl_interface *interface);
+
+void *
+wl_proxy_create_wrapper(void *proxy);
+
+void
+wl_proxy_wrapper_destroy(void *proxy_wrapper);
+
+struct wl_proxy *
+wl_proxy_marshal_constructor(struct wl_proxy *proxy,
+			     uint32_t opcode,
+			     const struct wl_interface *interface,
+			     ...);
+
+struct wl_proxy *
+wl_proxy_marshal_constructor_versioned(struct wl_proxy *proxy,
+				       uint32_t opcode,
+				       const struct wl_interface *interface,
+				       uint32_t version,
+				       ...);
+
+struct wl_proxy *
+wl_proxy_marshal_array_constructor(struct wl_proxy *proxy,
+				   uint32_t opcode, union wl_argument *args,
+				   const struct wl_interface *interface);
+
+struct wl_proxy *
+wl_proxy_marshal_array_constructor_versioned(struct wl_proxy *proxy,
+					     uint32_t opcode,
+					     union wl_argument *args,
+					     const struct wl_interface *interface,
+					     uint32_t version);
+
+void
+wl_proxy_destroy(struct wl_proxy *proxy);
+
+int
+wl_proxy_add_listener(struct wl_proxy *proxy,
+		      void (**implementation)(void), void *data);
+
+const void *
+wl_proxy_get_listener(struct wl_proxy *proxy);
+
+int
+wl_proxy_add_dispatcher(struct wl_proxy *proxy,
+			wl_dispatcher_func_t dispatcher_func,
+			const void * dispatcher_data, void *data);
+

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-client.c Added

@@ -0,0 +1,2444 @@
+/*
+ * Copyright © 2008-2012 Kristian Høgsberg
+ * Copyright © 2010-2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <ctype.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <pthread.h>
+
+#include "wayland-util.h"
+#include "wayland-os.h"
+#include "wayland-client.h"
+#include "wayland-private.h"
+
+/** \cond */
+
+enum wl_proxy_flag {
+	WL_PROXY_FLAG_ID_DELETED = (1 << 0),
+	WL_PROXY_FLAG_DESTROYED = (1 << 1),
+	WL_PROXY_FLAG_WRAPPER = (1 << 2),
+};
+
+struct wl_zombie {
+	int event_count;
+	int *fd_count;
+};
+
+struct wl_proxy {
+	struct wl_object object;
+	struct wl_display *display;
+	struct wl_event_queue *queue;
+	uint32_t flags;
+	int refcount;
+	void *user_data;
+	wl_dispatcher_func_t dispatcher;
+	uint32_t version;
+	const char * const *tag;
+};
+
+struct wl_event_queue {
+	struct wl_list event_list;
+	struct wl_display *display;
+};
+
+struct wl_display {
+	struct wl_proxy proxy;
+	struct wl_connection *connection;
+
+	/* errno of the last wl_display error */
+	int last_error;
+
+	/* When display gets an error event from some object, it stores
+	 * information about it here, so that client can get this
+	 * information afterwards */
+	struct {
+		/* Code of the error. It can be compared to
+		 * the interface's errors enumeration. */
+		uint32_t code;
+		/* interface (protocol) in which the error occurred */
+		const struct wl_interface *interface;
+		/* id of the proxy that caused the error. There's no warranty
+		 * that the proxy is still valid. It's up to client how it will
+		 * use it */
+		uint32_t id;
+	} protocol_error;
+	int fd;
+	struct wl_map objects;
+	struct wl_event_queue display_queue;
+	struct wl_event_queue default_queue;
+	pthread_mutex_t mutex;
+
+	int reader_count;
+	uint32_t read_serial;
+	pthread_cond_t reader_cond;
+};
+
+/** \endcond */
+
+static int debug_client = 0;
+
+/**
+ * This helper function wakes up all threads that are
+ * waiting for display->reader_cond (i. e. when reading is done,
+ * canceled, or an error occurred)
+ *
+ * NOTE: must be called with display->mutex locked
+ */
+static void
+display_wakeup_threads(struct wl_display *display)
+{
+	/* Thread can get sleeping only in read_events(). If we're
+	 * waking it up, it means that the read completed or was
+	 * canceled, so we must increase the read_serial.
+	 * This prevents from indefinite sleeping in read_events().
+	 */
+	++display->read_serial;
+
+	pthread_cond_broadcast(&display->reader_cond);
+}
+
+/**
+ * This function is called for local errors (no memory, server hung up)
+ *
+ * \param display
+ * \param error    error value (EINVAL, EFAULT, ...)
+ *
+ * \note this function is called with display mutex locked
+ */
+static void
+display_fatal_error(struct wl_display *display, int error)
+{
+	if (display->last_error)
+		return;
+
+	if (!error)
+		error = EFAULT;
+
+	display->last_error = error;
+
+	display_wakeup_threads(display);
+}
+
+/**
+ * This function is called for error events
+ * and indicates that in some object an error occurred.
+ * The difference between this function and display_fatal_error()
+ * is that this one handles errors that will come by wire,
+ * whereas display_fatal_error() is called for local errors.
+ *
+ * \param display
+ * \param code    error code
+ * \param id      id of the object that generated the error
+ * \param intf    protocol interface
+ */
+static void
+display_protocol_error(struct wl_display *display, uint32_t code,
+		       uint32_t id, const struct wl_interface *intf)
+{
+	int err;
+
+	if (display->last_error)
+		return;
+
+	/* set correct errno */
+	if (intf && wl_interface_equal(intf, &wl_display_interface)) {
+		switch (code) {
+		case WL_DISPLAY_ERROR_INVALID_OBJECT:
+		case WL_DISPLAY_ERROR_INVALID_METHOD:
+			err = EINVAL;
+			break;
+		case WL_DISPLAY_ERROR_NO_MEMORY:
+			err = ENOMEM;
+			break;
+		case WL_DISPLAY_ERROR_IMPLEMENTATION:
+			err = EPROTO;
+			break;
+		default:
+			err = EFAULT;
+		}
+	} else {
+		err = EPROTO;
+	}
+
+	pthread_mutex_lock(&display->mutex);

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-client.h Added

@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/** \file
+ *
+ *  \brief Include the client API and protocol C API.
+ *
+ *  \warning Use of this header file is discouraged. Prefer including
+ *  wayland-client-core.h instead, which does not include the
+ *  client protocol header and as such only defines the library
+ *  API.
+ */
+
+#ifndef WAYLAND_CLIENT_H
+#define WAYLAND_CLIENT_H
+
+#include "wayland-client-core.h"
+#include "wayland-client-protocol.h"
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-os.c Added

@@ -0,0 +1,252 @@
+/*
+ * Copyright © 2012 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+
+#include "../config.h"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/epoll.h>
+#include <sys/mman.h>
+#include <sys/un.h>
+#ifdef HAVE_SYS_UCRED_H
+#include <sys/ucred.h>
+#endif
+
+#include "wayland-os.h"
+
+static int
+set_cloexec_or_close(int fd)
+{
+	long flags;
+
+	if (fd == -1)
+		return -1;
+
+	flags = fcntl(fd, F_GETFD);
+	if (flags == -1)
+		goto err;
+
+	if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1)
+		goto err;
+
+	return fd;
+
+err:
+	close(fd);
+	return -1;
+}
+
+int
+wl_os_socket_cloexec(int domain, int type, int protocol)
+{
+	int fd;
+
+	fd = socket(domain, type | SOCK_CLOEXEC, protocol);
+	if (fd >= 0)
+		return fd;
+	if (errno != EINVAL)
+		return -1;
+
+	fd = socket(domain, type, protocol);
+	return set_cloexec_or_close(fd);
+}
+
+#if defined(__FreeBSD__)
+int
+wl_os_socket_peercred(int sockfd, uid_t *uid, gid_t *gid, pid_t *pid)
+{
+	socklen_t len;
+	struct xucred ucred;
+
+	len = sizeof(ucred);
+	if (getsockopt(sockfd, SOL_LOCAL, LOCAL_PEERCRED, &ucred, &len) < 0 ||
+	    ucred.cr_version != XUCRED_VERSION)
+		return -1;
+	*uid = ucred.cr_uid;
+	*gid = ucred.cr_gid;
+#if HAVE_XUCRED_CR_PID
+	/* Since https://cgit.freebsd.org/src/commit/?id=c5afec6e895a */
+	*pid = ucred.cr_pid;
+#else
+	*pid = 0;
+#endif
+	return 0;
+}
+#elif defined(SO_PEERCRED)
+int
+wl_os_socket_peercred(int sockfd, uid_t *uid, gid_t *gid, pid_t *pid)
+{
+	socklen_t len;
+	struct ucred ucred;
+
+	len = sizeof(ucred);
+	if (getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) < 0)
+		return -1;
+	*uid = ucred.uid;
+	*gid = ucred.gid;
+	*pid = ucred.pid;
+	return 0;
+}
+#else
+#error "Don't know how to read ucred on this platform"
+#endif
+
+int
+wl_os_dupfd_cloexec(int fd, int minfd)
+{
+	int newfd;
+
+	newfd = fcntl(fd, F_DUPFD_CLOEXEC, minfd);
+	if (newfd >= 0)
+		return newfd;
+	if (errno != EINVAL)
+		return -1;
+
+	newfd = fcntl(fd, F_DUPFD, minfd);
+	return set_cloexec_or_close(newfd);
+}
+
+static ssize_t
+recvmsg_cloexec_fallback(int sockfd, struct msghdr *msg, int flags)
+{
+	ssize_t len;
+	struct cmsghdr *cmsg;
+	unsigned char *data;
+	int *fd;
+	int *end;
+
+	len = recvmsg(sockfd, msg, flags);
+	if (len == -1)
+		return -1;
+
+	if (!msg->msg_control || msg->msg_controllen == 0)
+		return len;
+
+	cmsg = CMSG_FIRSTHDR(msg);
+	for (; cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) {
+		if (cmsg->cmsg_level != SOL_SOCKET ||
+		    cmsg->cmsg_type != SCM_RIGHTS)
+			continue;
+
+		data = CMSG_DATA(cmsg);
+		end = (int *)(data + cmsg->cmsg_len - CMSG_LEN(0));
+		for (fd = (int *)data; fd < end; ++fd)
+			*fd = set_cloexec_or_close(*fd);
+	}
+
+	return len;
+}
+
+ssize_t
+wl_os_recvmsg_cloexec(int sockfd, struct msghdr *msg, int flags)
+{
+#if HAVE_BROKEN_MSG_CMSG_CLOEXEC
+	/*
+	 * FreeBSD had a broken implementation of MSG_CMSG_CLOEXEC between 2015
+	 * and 2021, so we have to use the non-MSG_CMSG_CLOEXEC fallback
+	 * directly when compiling against a version that does not include the
+	 * fix (https://cgit.freebsd.org/src/commit/?id=6ceacebdf52211).
+	 */
+#pragma message("Using fallback directly since MSG_CMSG_CLOEXEC is broken.")
+#else
+	ssize_t len;
+
+	len = recvmsg(sockfd, msg, flags | MSG_CMSG_CLOEXEC);
+	if (len >= 0)
+		return len;
+	if (errno != EINVAL)
+		return -1;
+#endif
+	return recvmsg_cloexec_fallback(sockfd, msg, flags);
+}
+
+int
+wl_os_epoll_create_cloexec(void)
+{
+	int fd;
+
+#ifdef EPOLL_CLOEXEC
+	fd = epoll_create1(EPOLL_CLOEXEC);
+	if (fd >= 0)
+		return fd;

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-os.h Added

@@ -0,0 +1,76 @@
+/*
+ * Copyright © 2012 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_OS_H
+#define WAYLAND_OS_H
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+int
+wl_os_socket_cloexec(int domain, int type, int protocol);
+
+int
+wl_os_socket_peercred(int sockfd, uid_t *uid, gid_t *gid, pid_t *pid);
+
+int
+wl_os_dupfd_cloexec(int fd, int minfd);
+
+ssize_t
+wl_os_recvmsg_cloexec(int sockfd, struct msghdr *msg, int flags);
+
+int
+wl_os_epoll_create_cloexec(void);
+
+int
+wl_os_accept_cloexec(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
+
+void *
+wl_os_mremap_maymove(int fd, void *old_data, ssize_t *old_size,
+		     ssize_t new_size, int prot, int flags);
+
+
+/*
+ * The following are for wayland-os.c and the unit tests.
+ * Do not use them elsewhere.
+ */
+
+#ifdef __linux__
+
+#ifndef SOCK_CLOEXEC
+#define SOCK_CLOEXEC 02000000
+#endif
+
+#ifndef F_DUPFD_CLOEXEC
+#define F_DUPFD_CLOEXEC 1030
+#endif
+
+#ifndef MSG_CMSG_CLOEXEC
+#define MSG_CMSG_CLOEXEC 0x40000000
+#endif
+
+#endif /* __linux__ */
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-private.h Added

@@ -0,0 +1,240 @@
+/*
+ * Copyright © 2008-2011 Kristian Høgsberg
+ * Copyright © 2011 Intel Corporation
+ * Copyright © 2013 Jason Ekstrand
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_PRIVATE_H
+#define WAYLAND_PRIVATE_H
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#define WL_HIDE_DEPRECATED 1
+
+#include "wayland-util.h"
+
+/* Invalid memory address */
+#define WL_ARRAY_POISON_PTR (void *) 4
+
+#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)0)
+
+#define WL_MAP_SERVER_SIDE 0
+#define WL_MAP_CLIENT_SIDE 1
+#define WL_SERVER_ID_START 0xff000000
+#define WL_MAP_MAX_OBJECTS 0x00f00000
+#define WL_CLOSURE_MAX_ARGS 20
+
+struct wl_object {
+	const struct wl_interface *interface;
+	const void *implementation;
+	uint32_t id;
+};
+
+int
+wl_interface_equal(const struct wl_interface *iface1,
+		   const struct wl_interface *iface2);
+
+/* Flags for wl_map_insert_new and wl_map_insert_at.  Flags can be queried with
+ * wl_map_lookup_flags.  The current implementation has room for 1 bit worth of
+ * flags.  If more flags are ever added, the implementation of wl_map will have
+ * to change to allow for new flags */
+enum wl_map_entry_flags {
+	WL_MAP_ENTRY_LEGACY = (1 << 0), /* Server side only */
+	WL_MAP_ENTRY_ZOMBIE = (1 << 0) /* Client side only */
+};
+
+struct wl_map {
+	struct wl_array client_entries;
+	struct wl_array server_entries;
+	uint32_t side;
+	uint32_t free_list;
+};
+
+typedef enum wl_iterator_result (*wl_iterator_func_t)(void *element,
+						      void *data,
+						      uint32_t flags);
+
+void
+wl_map_init(struct wl_map *map, uint32_t side);
+
+void
+wl_map_release(struct wl_map *map);
+
+uint32_t
+wl_map_insert_new(struct wl_map *map, uint32_t flags, void *data);
+
+int
+wl_map_insert_at(struct wl_map *map, uint32_t flags, uint32_t i, void *data);
+
+int
+wl_map_reserve_new(struct wl_map *map, uint32_t i);
+
+void
+wl_map_remove(struct wl_map *map, uint32_t i);
+
+void *
+wl_map_lookup(struct wl_map *map, uint32_t i);
+
+uint32_t
+wl_map_lookup_flags(struct wl_map *map, uint32_t i);
+
+void
+wl_map_for_each(struct wl_map *map, wl_iterator_func_t func, void *data);
+
+struct wl_connection *
+wl_connection_create(int fd);
+
+int
+wl_connection_destroy(struct wl_connection *connection);
+
+void
+wl_connection_copy(struct wl_connection *connection, void *data, size_t size);
+
+void
+wl_connection_consume(struct wl_connection *connection, size_t size);
+
+int
+wl_connection_flush(struct wl_connection *connection);
+
+uint32_t
+wl_connection_pending_input(struct wl_connection *connection);
+
+int
+wl_connection_read(struct wl_connection *connection);
+
+int
+wl_connection_write(struct wl_connection *connection,
+		    const void *data, size_t count);
+
+int
+wl_connection_queue(struct wl_connection *connection,
+		    const void *data, size_t count);
+
+int
+wl_connection_get_fd(struct wl_connection *connection);
+
+struct wl_closure {
+	int count;
+	const struct wl_message *message;
+	uint32_t opcode;
+	uint32_t sender_id;
+	union wl_argument argsWL_CLOSURE_MAX_ARGS;
+	struct wl_list link;
+	struct wl_proxy *proxy;
+	struct wl_array extra0;
+};
+
+struct argument_details {
+	char type;
+	int nullable;
+};
+
+const char *
+get_next_argument(const char *signature, struct argument_details *details);
+
+int
+arg_count_for_signature(const char *signature);
+
+int
+wl_message_count_arrays(const struct wl_message *message);
+
+int
+wl_message_get_since(const struct wl_message *message);
+
+void
+wl_argument_from_va_list(const char *signature, union wl_argument *args,
+			 int count, va_list ap);
+
+struct wl_closure *
+wl_closure_marshal(struct wl_object *sender,
+		    uint32_t opcode, union wl_argument *args,
+		    const struct wl_message *message);
+
+struct wl_closure *
+wl_closure_vmarshal(struct wl_object *sender,
+		    uint32_t opcode, va_list ap,
+		    const struct wl_message *message);
+
+struct wl_closure *
+wl_connection_demarshal(struct wl_connection *connection,
+			uint32_t size,
+			struct wl_map *objects,
+			const struct wl_message *message);
+
+bool
+wl_object_is_zombie(struct wl_map *map, uint32_t id);
+
+int
+wl_closure_lookup_objects(struct wl_closure *closure, struct wl_map *objects);
+
+enum wl_closure_invoke_flag {
+	WL_CLOSURE_INVOKE_CLIENT = (1 << 0),
+	WL_CLOSURE_INVOKE_SERVER = (1 << 1)
+};
+
+void

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-server-core.h Added

@@ -0,0 +1,684 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_SERVER_CORE_H
+#define WAYLAND_SERVER_CORE_H
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include "wayland-util.h"
+#include "wayland-version.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+enum {
+	WL_EVENT_READABLE = 0x01,
+	WL_EVENT_WRITABLE = 0x02,
+	WL_EVENT_HANGUP   = 0x04,
+	WL_EVENT_ERROR    = 0x08
+};
+
+/** File descriptor dispatch function type
+ *
+ * Functions of this type are used as callbacks for file descriptor events.
+ *
+ * \param fd The file descriptor delivering the event.
+ * \param mask Describes the kind of the event as a bitwise-or of:
+ * \c WL_EVENT_READABLE, \c WL_EVENT_WRITABLE, \c WL_EVENT_HANGUP,
+ * \c WL_EVENT_ERROR.
+ * \param data The user data argument of the related wl_event_loop_add_fd()
+ * call.
+ * \return If the event source is registered for re-check with
+ * wl_event_source_check(): 0 for all done, 1 for needing a re-check.
+ * If not registered, the return value is ignored and should be zero.
+ *
+ * \sa wl_event_loop_add_fd()
+ * \memberof wl_event_source
+ */
+typedef int (*wl_event_loop_fd_func_t)(int fd, uint32_t mask, void *data);
+
+/** Timer dispatch function type
+ *
+ * Functions of this type are used as callbacks for timer expiry.
+ *
+ * \param data The user data argument of the related wl_event_loop_add_timer()
+ * call.
+ * \return If the event source is registered for re-check with
+ * wl_event_source_check(): 0 for all done, 1 for needing a re-check.
+ * If not registered, the return value is ignored and should be zero.
+ *
+ * \sa wl_event_loop_add_timer()
+ * \memberof wl_event_source
+ */
+typedef int (*wl_event_loop_timer_func_t)(void *data);
+
+/** Signal dispatch function type
+ *
+ * Functions of this type are used as callbacks for (POSIX) signals.
+ *
+ * \param signal_number
+ * \param data The user data argument of the related wl_event_loop_add_signal()
+ * call.
+ * \return If the event source is registered for re-check with
+ * wl_event_source_check(): 0 for all done, 1 for needing a re-check.
+ * If not registered, the return value is ignored and should be zero.
+ *
+ * \sa wl_event_loop_add_signal()
+ * \memberof wl_event_source
+ */
+typedef int (*wl_event_loop_signal_func_t)(int signal_number, void *data);
+
+/** Idle task function type
+ *
+ * Functions of this type are used as callbacks before blocking in
+ * wl_event_loop_dispatch().
+ *
+ * \param data The user data argument of the related wl_event_loop_add_idle()
+ * call.
+ *
+ * \sa wl_event_loop_add_idle() wl_event_loop_dispatch()
+ * \memberof wl_event_source
+ */
+typedef void (*wl_event_loop_idle_func_t)(void *data);
+
+/** \struct wl_event_loop
+ *
+ * \brief An event loop context
+ *
+ * Usually you create an event loop context, add sources to it, and call
+ * wl_event_loop_dispatch() in a loop to process events.
+ *
+ * \sa wl_event_source
+ */
+
+/** \struct wl_event_source
+ *
+ * \brief An abstract event source
+ *
+ * This is the generic type for fd, timer, signal, and idle sources.
+ * Functions that operate on specific source types must not be used with
+ * a different type, even if the function signature allows it.
+ */
+
+struct wl_event_loop *
+wl_event_loop_create(void);
+
+void
+wl_event_loop_destroy(struct wl_event_loop *loop);
+
+struct wl_event_source *
+wl_event_loop_add_fd(struct wl_event_loop *loop,
+		     int fd, uint32_t mask,
+		     wl_event_loop_fd_func_t func,
+		     void *data);
+
+int
+wl_event_source_fd_update(struct wl_event_source *source, uint32_t mask);
+
+struct wl_event_source *
+wl_event_loop_add_timer(struct wl_event_loop *loop,
+			wl_event_loop_timer_func_t func,
+			void *data);
+
+struct wl_event_source *
+wl_event_loop_add_signal(struct wl_event_loop *loop,
+			 int signal_number,
+			 wl_event_loop_signal_func_t func,
+			 void *data);
+
+int
+wl_event_source_timer_update(struct wl_event_source *source,
+			     int ms_delay);
+
+int
+wl_event_source_remove(struct wl_event_source *source);
+
+void
+wl_event_source_check(struct wl_event_source *source);
+
+int
+wl_event_loop_dispatch(struct wl_event_loop *loop, int timeout);
+
+void
+wl_event_loop_dispatch_idle(struct wl_event_loop *loop);
+
+struct wl_event_source *
+wl_event_loop_add_idle(struct wl_event_loop *loop,
+		       wl_event_loop_idle_func_t func,
+		       void *data);
+
+int
+wl_event_loop_get_fd(struct wl_event_loop *loop);
+
+struct wl_listener;
+
+typedef void (*wl_notify_func_t)(struct wl_listener *listener, void *data);
+
+void
+wl_event_loop_add_destroy_listener(struct wl_event_loop *loop,
+				   struct wl_listener *listener);
+
+struct wl_listener *
+wl_event_loop_get_destroy_listener(struct wl_event_loop *loop,
+				   wl_notify_func_t notify);
+
+struct wl_display *
+wl_display_create(void);
+
+void
+wl_display_destroy(struct wl_display *display);
+
+struct wl_event_loop *
+wl_display_get_event_loop(struct wl_display *display);
+
+int

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-server-private.h Added

@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2008-2011 Kristian Høgsberg
+ * Copyright © 2011 Intel Corporation
+ * Copyright © 2013 Jason Ekstrand
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_SERVER_PRIVATE_H
+#define WAYLAND_SERVER_PRIVATE_H
+
+#include "wayland-server-core.h"
+
+struct wl_priv_signal {
+	struct wl_list listener_list;
+	struct wl_list emit_list;
+};
+
+void
+wl_priv_signal_init(struct wl_priv_signal *signal);
+
+void
+wl_priv_signal_add(struct wl_priv_signal *signal, struct wl_listener *listener);
+
+struct wl_listener *
+wl_priv_signal_get(struct wl_priv_signal *signal, wl_notify_func_t notify);
+
+void
+wl_priv_signal_emit(struct wl_priv_signal *signal, void *data);
+
+void
+wl_priv_signal_final_emit(struct wl_priv_signal *signal, void *data);
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-server.c Added

@@ -0,0 +1,2427 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <dlfcn.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <sys/eventfd.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+
+#include "wayland-util.h"
+#include "wayland-private.h"
+#include "wayland-server-private.h"
+#include "wayland-server.h"
+#include "wayland-os.h"
+
+/* This is the size of the char array in struct sock_addr_un.
+ * No Wayland socket can be created with a path longer than this,
+ * including the null terminator.
+ */
+#ifndef UNIX_PATH_MAX
+#define UNIX_PATH_MAX	108
+#endif
+
+#define LOCK_SUFFIX	".lock"
+#define LOCK_SUFFIXLEN	5
+
+struct wl_socket {
+	int fd;
+	int fd_lock;
+	struct sockaddr_un addr;
+	char lock_addrUNIX_PATH_MAX + LOCK_SUFFIXLEN;
+	struct wl_list link;
+	struct wl_event_source *source;
+	char *display_name;
+};
+
+struct wl_client {
+	struct wl_connection *connection;
+	struct wl_event_source *source;
+	struct wl_display *display;
+	struct wl_resource *display_resource;
+	struct wl_list link;
+	struct wl_map objects;
+	struct wl_priv_signal destroy_signal;
+	pid_t pid;
+	uid_t uid;
+	gid_t gid;
+	int error;
+	struct wl_priv_signal resource_created_signal;
+};
+
+struct wl_display {
+	struct wl_event_loop *loop;
+	int run;
+
+	uint32_t id;
+	uint32_t serial;
+
+	struct wl_list registry_resource_list;
+	struct wl_list global_list;
+	struct wl_list socket_list;
+	struct wl_list client_list;
+	struct wl_list protocol_loggers;
+
+	struct wl_priv_signal destroy_signal;
+	struct wl_priv_signal create_client_signal;
+
+	struct wl_array additional_shm_formats;
+
+	wl_display_global_filter_func_t global_filter;
+	void *global_filter_data;
+
+	int terminate_efd;
+	struct wl_event_source *term_source;
+};
+
+struct wl_global {
+	struct wl_display *display;
+	const struct wl_interface *interface;
+	uint32_t name;
+	uint32_t version;
+	void *data;
+	wl_global_bind_func_t bind;
+	struct wl_list link;
+	bool removed;
+};
+
+struct wl_resource {
+	struct wl_object object;
+	wl_resource_destroy_func_t destroy;
+	struct wl_list link;
+	/* Unfortunately some users of libwayland (e.g. mesa) still use the
+	 * deprecated wl_resource struct, even if creating it with the new
+	 * wl_resource_create(). So we cannot change the layout of the struct
+	 * unless after the data field. */
+	struct wl_signal deprecated_destroy_signal;
+	struct wl_client *client;
+	void *data;
+	int version;
+	wl_dispatcher_func_t dispatcher;
+	struct wl_priv_signal destroy_signal;
+};
+
+struct wl_protocol_logger {
+	struct wl_list link;
+	wl_protocol_logger_func_t func;
+	void *user_data;
+};
+
+static int debug_server = 0;
+
+static void
+log_closure(struct wl_resource *resource,
+	    struct wl_closure *closure, int send)
+{
+	struct wl_object *object = &resource->object;
+	struct wl_display *display = resource->client->display;
+	struct wl_protocol_logger *protocol_logger;
+	struct wl_protocol_logger_message message;
+
+	if (debug_server)
+		wl_closure_print(closure, object, send, false, NULL);
+
+	if (!wl_list_empty(&display->protocol_loggers)) {
+		message.resource = resource;
+		message.message_opcode = closure->opcode;
+		message.message = closure->message;
+		message.arguments_count = closure->count;
+		message.arguments = closure->args;
+		wl_list_for_each(protocol_logger,
+				 &display->protocol_loggers, link) {
+			protocol_logger->func(protocol_logger->user_data,
+					      send ? WL_PROTOCOL_LOGGER_EVENT :
+						     WL_PROTOCOL_LOGGER_REQUEST,
+					      &message);
+		}
+	}
+}
+
+static bool
+verify_objects(struct wl_resource *resource, uint32_t opcode,
+	       union wl_argument *args)
+{
+	struct wl_object *object = &resource->object;
+	const char *signature = object->interface->eventsopcode.signature;
+	struct argument_details arg;
+	struct wl_resource *res;
+	int count, i;
+
+	count = arg_count_for_signature(signature);
+	for (i = 0; i < count; i++) {
+		signature = get_next_argument(signature, &arg);
+		switch (arg.type) {
+		case 'n':
+		case 'o':
+			res = (struct wl_resource *) (argsi.o);
+			if (res && res->client != resource->client) {
+				wl_log("compositor bug: The compositor "
+				       "tried to use an object from one "
+				       "client in a '%s.%s' for a different "
+				       "client.\n", object->interface->name,
+				       object->interface->eventsopcode.name);

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-server.h Added

@@ -0,0 +1,106 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/** \file
+ *
+ *  \brief Include the server API, deprecations and protocol C API.
+ *
+ *  \warning Use of this header file is discouraged. Prefer including
+ *  wayland-server-core.h instead, which does not include the
+ *  server protocol header and as such only defines the library
+ *  API, excluding the deprecated API below.
+ */
+
+#ifndef WAYLAND_SERVER_H
+#define WAYLAND_SERVER_H
+
+#include <stdint.h>
+#include "wayland-server-core.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The user can set this macro to hide the wl_object, wl_resource and wl_buffer
+ * objects alongside the associated API.
+ *
+ * The structs were meant to be opaque, although we missed that in the early days.
+ *
+ * NOTE: the list of structs, functions, etc in this section MUST NEVER GROW.
+ * Otherwise we will break forward compatibility and applications that used to
+ * build fine will no longer be able to do so.
+ */
+#ifndef WL_HIDE_DEPRECATED
+
+struct wl_object {
+	const struct wl_interface *interface;
+	const void *implementation;
+	uint32_t id;
+};
+
+struct wl_resource {
+	struct wl_object object;
+	wl_resource_destroy_func_t destroy;
+	struct wl_list link;
+	struct wl_signal destroy_signal;
+	struct wl_client *client;
+	void *data;
+};
+
+uint32_t
+wl_client_add_resource(struct wl_client *client,
+		       struct wl_resource *resource) WL_DEPRECATED;
+
+struct wl_resource *
+wl_client_add_object(struct wl_client *client,
+		     const struct wl_interface *interface,
+		     const void *implementation,
+		     uint32_t id, void *data) WL_DEPRECATED;
+
+struct wl_resource *
+wl_client_new_object(struct wl_client *client,
+		     const struct wl_interface *interface,
+		     const void *implementation, void *data) WL_DEPRECATED;
+
+struct wl_global *
+wl_display_add_global(struct wl_display *display,
+		      const struct wl_interface *interface,
+		      void *data,
+		      wl_global_bind_func_t bind) WL_DEPRECATED;
+
+void
+wl_display_remove_global(struct wl_display *display,
+			 struct wl_global *global) WL_DEPRECATED;
+
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#include "wayland-server-protocol.h"
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-shm.c Added

@@ -0,0 +1,706 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Authors:
+ *    Kristian Høgsberg <krh@bitplanet.net>
+ *    Benjamin Franzke <benjaminfranzke@googlemail.com>
+ *
+ */
+
+#define _GNU_SOURCE
+
+#include "config.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <assert.h>
+#include <signal.h>
+#include <pthread.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include "wayland-os.h"
+#include "wayland-util.h"
+#include "wayland-private.h"
+#include "wayland-server.h"
+
+/* This once_t is used to synchronize installing the SIGBUS handler
+ * and creating the TLS key. This will be done in the first call
+ * wl_shm_buffer_begin_access which can happen from any thread */
+static pthread_once_t wl_shm_sigbus_once = PTHREAD_ONCE_INIT;
+static pthread_key_t wl_shm_sigbus_data_key;
+static struct sigaction wl_shm_old_sigbus_action;
+
+struct wl_shm_pool {
+	struct wl_resource *resource;
+	int internal_refcount;
+	int external_refcount;
+	char *data;
+	ssize_t size;
+	ssize_t new_size;
+#ifndef MREMAP_MAYMOVE
+	/* The following three fields are needed for mremap() emulation. */
+	int mmap_fd;
+	int mmap_flags;
+	int mmap_prot;
+#endif
+	bool sigbus_is_impossible;
+};
+
+/** \class wl_shm_buffer
+ *
+ * \brief A SHM buffer
+ *
+ * wl_shm_buffer provides a helper for accessing the contents of a wl_buffer
+ * resource created via the wl_shm interface.
+ *
+ * A wl_shm_buffer becomes invalid as soon as its #wl_resource is destroyed.
+ */
+struct wl_shm_buffer {
+	struct wl_resource *resource;
+	int32_t width, height;
+	int32_t stride;
+	uint32_t format;
+	int offset;
+	struct wl_shm_pool *pool;
+};
+
+struct wl_shm_sigbus_data {
+	struct wl_shm_pool *current_pool;
+	int access_count;
+	int fallback_mapping_used;
+};
+
+static void *
+shm_pool_grow_mapping(struct wl_shm_pool *pool)
+{
+	void *data;
+
+#ifdef MREMAP_MAYMOVE
+	data = mremap(pool->data, pool->size, pool->new_size, MREMAP_MAYMOVE);
+#else
+	data = wl_os_mremap_maymove(pool->mmap_fd, pool->data, &pool->size,
+				    pool->new_size, pool->mmap_prot,
+				    pool->mmap_flags);
+	if (pool->size != 0) {
+		wl_resource_post_error(pool->resource,
+				       WL_SHM_ERROR_INVALID_FD,
+				       "leaked old mapping");
+	}
+#endif
+	return data;
+}
+
+static void
+shm_pool_finish_resize(struct wl_shm_pool *pool)
+{
+	void *data;
+
+	if (pool->size == pool->new_size)
+		return;
+
+	data = shm_pool_grow_mapping(pool);
+	if (data == MAP_FAILED) {
+		wl_resource_post_error(pool->resource,
+				       WL_SHM_ERROR_INVALID_FD,
+				       "failed mremap");
+		return;
+	}
+
+	pool->data = data;
+	pool->size = pool->new_size;
+}
+
+static void
+shm_pool_unref(struct wl_shm_pool *pool, bool external)
+{
+	if (external) {
+		pool->external_refcount--;
+		assert(pool->external_refcount >= 0);
+		if (pool->external_refcount == 0)
+			shm_pool_finish_resize(pool);
+	} else {
+		pool->internal_refcount--;
+		assert(pool->internal_refcount >= 0);
+	}
+
+	if (pool->internal_refcount + pool->external_refcount > 0)
+		return;
+
+	munmap(pool->data, pool->size);
+#ifndef MREMAP_MAYMOVE
+	close(pool->mmap_fd);
+#endif
+	free(pool);
+}
+
+static void
+destroy_buffer(struct wl_resource *resource)
+{
+	struct wl_shm_buffer *buffer = wl_resource_get_user_data(resource);
+
+	shm_pool_unref(buffer->pool, false);
+	free(buffer);
+}
+
+static void
+shm_buffer_destroy(struct wl_client *client, struct wl_resource *resource)
+{
+	wl_resource_destroy(resource);
+}
+
+static const struct wl_buffer_interface shm_buffer_interface = {
+	shm_buffer_destroy
+};
+
+static bool
+format_is_supported(struct wl_client *client, uint32_t format)
+{
+	struct wl_display *display = wl_client_get_display(client);
+	struct wl_array *formats;
+	uint32_t *p;
+
+	switch (format) {
+	case WL_SHM_FORMAT_ARGB8888:
+	case WL_SHM_FORMAT_XRGB8888:
+		return true;
+	default:
+		formats = wl_display_get_additional_shm_formats(display);
+		wl_array_for_each(p, formats)
+			if (*p == format)
+				return true;
+	}

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-util.c Added

@@ -0,0 +1,465 @@
+/*
+ * Copyright © 2008-2011 Kristian Høgsberg
+ * Copyright © 2011 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "wayland-util.h"
+#include "wayland-private.h"
+
+WL_EXPORT void
+wl_list_init(struct wl_list *list)
+{
+	list->prev = list;
+	list->next = list;
+}
+
+WL_EXPORT void
+wl_list_insert(struct wl_list *list, struct wl_list *elm)
+{
+	elm->prev = list;
+	elm->next = list->next;
+	list->next = elm;
+	elm->next->prev = elm;
+}
+
+WL_EXPORT void
+wl_list_remove(struct wl_list *elm)
+{
+	elm->prev->next = elm->next;
+	elm->next->prev = elm->prev;
+	elm->next = NULL;
+	elm->prev = NULL;
+}
+
+WL_EXPORT int
+wl_list_length(const struct wl_list *list)
+{
+	struct wl_list *e;
+	int count;
+
+	count = 0;
+	e = list->next;
+	while (e != list) {
+		e = e->next;
+		count++;
+	}
+
+	return count;
+}
+
+WL_EXPORT int
+wl_list_empty(const struct wl_list *list)
+{
+	return list->next == list;
+}
+
+WL_EXPORT void
+wl_list_insert_list(struct wl_list *list, struct wl_list *other)
+{
+	if (wl_list_empty(other))
+		return;
+
+	other->next->prev = list;
+	other->prev->next = list->next;
+	list->next->prev = other->prev;
+	list->next = other->next;
+}
+
+WL_EXPORT void
+wl_array_init(struct wl_array *array)
+{
+	memset(array, 0, sizeof *array);
+}
+
+WL_EXPORT void
+wl_array_release(struct wl_array *array)
+{
+	free(array->data);
+	array->data = WL_ARRAY_POISON_PTR;
+}
+
+WL_EXPORT void *
+wl_array_add(struct wl_array *array, size_t size)
+{
+	size_t alloc;
+	void *data, *p;
+
+	if (array->alloc > 0)
+		alloc = array->alloc;
+	else
+		alloc = 16;
+
+	while (alloc < array->size + size)
+		alloc *= 2;
+
+	if (array->alloc < alloc) {
+		if (array->alloc > 0)
+			data = realloc(array->data, alloc);
+		else
+			data = malloc(alloc);
+
+		if (data == NULL)
+			return NULL;
+		array->data = data;
+		array->alloc = alloc;
+	}
+
+	p = (char *)array->data + array->size;
+	array->size += size;
+
+	return p;
+}
+
+WL_EXPORT int
+wl_array_copy(struct wl_array *array, struct wl_array *source)
+{
+	if (array->size < source->size) {
+		if (!wl_array_add(array, source->size - array->size))
+			return -1;
+	} else {
+		array->size = source->size;
+	}
+
+	if (source->size > 0)
+		memcpy(array->data, source->data, source->size);
+
+	return 0;
+}
+
+/** \cond */
+
+int
+wl_interface_equal(const struct wl_interface *a, const struct wl_interface *b)
+{
+	/* 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.
+	 */
+	return a == b || strcmp(a->name, b->name) == 0;
+}
+
+union map_entry {
+	uintptr_t next;
+	void *data;
+};
+
+#define map_entry_is_free(entry) ((entry).next & 0x1)
+#define map_entry_get_data(entry) ((void *)((entry).next & ~(uintptr_t)0x3))
+#define map_entry_get_flags(entry) (((entry).next >> 1) & 0x1)
+
+void
+wl_map_init(struct wl_map *map, uint32_t side)
+{
+	memset(map, 0, sizeof *map);
+	map->side = side;
+}
+
+void
+wl_map_release(struct wl_map *map)
+{
+	wl_array_release(&map->client_entries);
+	wl_array_release(&map->server_entries);
+}
+
+uint32_t
+wl_map_insert_new(struct wl_map *map, uint32_t flags, void *data)
+{
+	union map_entry *start, *entry;
+	struct wl_array *entries;

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-util.h Added

@@ -0,0 +1,765 @@
+/*
+ * Copyright © 2008 Kristian Høgsberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/** \file wayland-util.h
+ *
+ * \brief Utility classes, functions, and macros.
+ */
+
+#ifndef WAYLAND_UTIL_H
+#define WAYLAND_UTIL_H
+
+#include <math.h>
+#include <stddef.h>
+#include <inttypes.h>
+#include <stdarg.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/** Visibility attribute */
+#if defined(__GNUC__) && __GNUC__ >= 4
+#define WL_EXPORT __attribute__ ((visibility("default")))
+#else
+#define WL_EXPORT
+#endif
+
+/** Deprecated attribute */
+#if defined(__GNUC__) && __GNUC__ >= 4
+#define WL_DEPRECATED __attribute__ ((deprecated))
+#else
+#define WL_DEPRECATED
+#endif
+
+/**
+ * Printf-style argument attribute
+ *
+ * \param x Ordinality of the format string argument
+ * \param y Ordinality of the argument to check against the format string
+ *
+ * \sa https://gcc.gnu.org/onlinedocs/gcc-3.2.1/gcc/Function-Attributes.html
+ */
+#if defined(__GNUC__) && __GNUC__ >= 4
+#define WL_PRINTF(x, y) __attribute__((__format__(__printf__, x, y)))
+#else
+#define WL_PRINTF(x, y)
+#endif
+
+/** \class wl_object
+ *
+ * \brief A protocol object.
+ *
+ * A `wl_object` is an opaque struct identifying the protocol object
+ * underlying a `wl_proxy` or `wl_resource`.
+ *
+ * \note Functions accessing a `wl_object` are not normally used by client code.
+ * Clients should normally use the higher level interface generated by the
+ * scanner to interact with compositor objects.
+ *
+ */
+struct wl_object;
+
+/**
+ * Protocol message signature
+ *
+ * A wl_message describes the signature of an actual protocol message, such as a
+ * request or event, that adheres to the Wayland protocol wire format. The
+ * protocol implementation uses a wl_message within its demarshal machinery for
+ * decoding messages between a compositor and its clients. In a sense, a
+ * wl_message is to a protocol message like a class is to an object.
+ *
+ * The `name` of a wl_message is the name of the corresponding protocol message.
+ *
+ * The `signature` is an ordered list of symbols representing the data types
+ * of message arguments and, optionally, a protocol version and indicators for
+ * nullability. A leading integer in the `signature` indicates the _since_
+ * version of the protocol message. A `?` preceding a data type symbol indicates
+ * that the following argument type is nullable. While it is a protocol violation
+ * to send messages with non-nullable arguments set to `NULL`, event handlers in
+ * clients might still get called with non-nullable object arguments set to
+ * `NULL`. This can happen when the client destroyed the object being used as
+ * argument on its side and an event referencing that object was sent before the
+ * server knew about its destruction. As this race cannot be prevented, clients
+ * should - as a general rule - program their event handlers such that they can
+ * handle object arguments declared non-nullable being `NULL` gracefully.
+ *
+ * When no arguments accompany a message, `signature` is an empty string.
+ *
+ * Symbols:
+ *
+ * * `i`: int
+ * * `u`: uint
+ * * `f`: fixed
+ * * `s`: string
+ * * `o`: object
+ * * `n`: new_id
+ * * `a`: array
+ * * `h`: fd
+ * * `?`: following argument is nullable
+ *
+ * While demarshaling primitive arguments is straightforward, when demarshaling
+ * messages containing `object` or `new_id` arguments, the protocol
+ * implementation often must determine the type of the object. The `types` of a
+ * wl_message is an array of wl_interface references that correspond to `o` and
+ * `n` arguments in `signature`, with `NULL` placeholders for arguments with
+ * non-object types.
+ *
+ * Consider the protocol event wl_display `delete_id` that has a single `uint`
+ * argument. The wl_message is:
+ *
+ * \code
+ * { "delete_id", "u", NULL }
+ * \endcode
+ *
+ * Here, the message `name` is `"delete_id"`, the `signature` is `"u"`, and the
+ * argument `types` is `NULL`, indicating that the `uint` argument has no
+ * corresponding wl_interface since it is a primitive argument.
+ *
+ * In contrast, consider a `wl_foo` interface supporting protocol request `bar`
+ * that has existed since version 2, and has two arguments: a `uint` and an
+ * object of type `wl_baz_interface` that may be `NULL`. Such a `wl_message`
+ * might be:
+ *
+ * \code
+ * { "bar", "2u?o", NULL, &wl_baz_interface }
+ * \endcode
+ *
+ * Here, the message `name` is `"bar"`, and the `signature` is `"2u?o"`. Notice
+ * how the `2` indicates the protocol version, the `u` indicates the first
+ * argument type is `uint`, and the `?o` indicates that the second argument
+ * is an object that may be `NULL`. Lastly, the argument `types` array indicates
+ * that no wl_interface corresponds to the first argument, while the type
+ * `wl_baz_interface` corresponds to the second argument.
+ *
+ * \sa wl_argument
+ * \sa wl_interface
+ * \sa <a href="https://wayland.freedesktop.org/docs/html/ch04.html#sect-Protocol-Wire-Format">Wire Format</a>
+ */
+struct wl_message {
+	/** Message name */
+	const char *name;
+	/** Message signature */
+	const char *signature;
+	/** Object argument interfaces */
+	const struct wl_interface **types;
+};
+
+/**
+ * Protocol object interface
+ *
+ * A wl_interface describes the API of a protocol object defined in the Wayland
+ * protocol specification. The protocol implementation uses a wl_interface
+ * within its marshalling machinery for encoding client requests.
+ *
+ * The `name` of a wl_interface is the name of the corresponding protocol
+ * interface, and `version` represents the version of the interface. The members
+ * `method_count` and `event_count` represent the number of `methods` (requests)
+ * and `events` in the respective wl_message members.
+ *
+ * For example, consider a protocol interface `foo`, marked as version `1`, with
+ * two requests and one event.
+ *
+ * \code{.xml}
+ * <interface name="foo" version="1">
+ *   <request name="a"></request>
+ *   <request name="b"></request>
+ *   <event name="c"></event>
+ * </interface>
+ * \endcode
+ *
+ * Given two wl_message arrays `foo_requests` and `foo_events`, a wl_interface
+ * for `foo` might be:
+ *
+ * \code
+ * struct wl_interface foo_interface = {
+ *         "foo", 1,
+ *         2, foo_requests,

_service:tar_scm:wayland-1.21.0.tar.gz/src/wayland-version.h.in Added

@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WAYLAND_VERSION_H
+#define WAYLAND_VERSION_H
+
+#define WAYLAND_VERSION_MAJOR @WAYLAND_VERSION_MAJOR@
+#define WAYLAND_VERSION_MINOR @WAYLAND_VERSION_MINOR@
+#define WAYLAND_VERSION_MICRO @WAYLAND_VERSION_MICRO@
+#define WAYLAND_VERSION "@WAYLAND_VERSION@"
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/tests Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/array-test.c Added

@@ -0,0 +1,157 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "wayland-util.h"
+#include "wayland-private.h"
+#include "test-runner.h"
+
+TEST(array_init)
+{
+	struct wl_array array;
+
+	/* fill with garbage to emulate uninitialized memory */
+	memset(&array, 0x57, sizeof array);
+
+	wl_array_init(&array);
+	assert(array.size == 0);
+	assert(array.alloc == 0);
+	assert(array.data == 0);
+}
+
+TEST(array_release)
+{
+	struct wl_array array;
+	void *ptr;
+
+	wl_array_init(&array);
+	ptr = wl_array_add(&array, 1);
+	assert(ptr != NULL);
+	assert(array.data != NULL);
+
+	wl_array_release(&array);
+	assert(array.data == WL_ARRAY_POISON_PTR);
+}
+
+TEST(array_add)
+{
+	struct mydata {
+		unsigned int a;
+		unsigned int b;
+		double c;
+		double d;
+	};
+
+	const unsigned int iterations = 1321; /* this is arbitrary */
+	const int datasize = sizeof(struct mydata);
+	struct wl_array array;
+	size_t i;
+
+	wl_array_init(&array);
+
+	/* add some data */
+	for (i = 0; i < iterations; i++) {
+		struct mydata* ptr = wl_array_add(&array, datasize);
+		assert(ptr);
+		assert((i + 1) * datasize == array.size);
+
+		ptr->a = i * 3;
+		ptr->b = 20000 - i;
+		ptr->c = (double)(i);
+		ptr->d = (double)(i / 2.);
+	}
+
+	/* verify the data */
+	for (i = 0; i < iterations; ++i) {
+		struct mydata* check = (struct mydata*)array.data + i;
+
+		assert(check->a == i * 3);
+		assert(check->b == 20000 - i);
+		assert(check->c == (double)(i));
+		assert(check->d == (double)(i/2.));
+	}
+
+	wl_array_release(&array);
+}
+
+TEST(array_copy)
+{
+	const int iterations = 1529; /* this is arbitrary */
+	struct wl_array source;
+	struct wl_array copy;
+	int i;
+
+	wl_array_init(&source);
+
+	/* add some data */
+	for (i = 0; i < iterations; i++) {
+		int *p = wl_array_add(&source, sizeof(int));
+		assert(p);
+		*p = i * 2 + i;
+	}
+
+	/* copy the array */
+	wl_array_init(&copy);
+	wl_array_copy(&copy, &source);
+
+	/* check the copy */
+	for (i = 0; i < iterations; i++) {
+		int *s = (int *)source.data + i;
+		int *c = (int *)copy.data + i;
+
+		assert(*s == *c); /* verify the values are the same */
+		assert(s != c); /* ensure the addresses aren't the same */
+		assert(*s == i * 2 + i); /* sanity check */
+	}
+
+	wl_array_release(&source);
+	wl_array_release(&copy);
+}
+
+TEST(array_for_each)
+{
+	static const int elements = { 77, 12, 45192, 53280, 334455 };
+	struct wl_array array;
+	int *p;
+	int i;
+
+	wl_array_init(&array);
+	for (i = 0; i < 5; i++) {
+		p = wl_array_add(&array, sizeof *p);
+		assert(p);
+		*p = elementsi;
+	}
+
+	i = 0;
+	wl_array_for_each(p, &array) {
+		assert(*p == elementsi);
+		i++;
+	}
+	assert(i == 5);
+
+	wl_array_release(&array);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/client-test.c Added

@@ -0,0 +1,91 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "wayland-private.h"
+#include "wayland-server.h"
+#include "test-runner.h"
+
+struct client_destroy_listener {
+	struct wl_listener listener;
+	int done;
+};
+
+static void
+client_destroy_notify(struct wl_listener *l, void *data)
+{
+	struct client_destroy_listener *listener =
+		wl_container_of(l, listener, listener);
+
+	listener->done = 1;
+}
+
+TEST(client_destroy_listener)
+{
+	struct wl_display *display;
+	struct wl_client *client;
+	struct client_destroy_listener a, b;
+	int s2;
+
+	assert(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, s) == 0);
+	display = wl_display_create();
+	assert(display);
+	client = wl_client_create(display, s0);
+	assert(client);
+
+	a.listener.notify = client_destroy_notify;
+	a.done = 0;
+	wl_client_add_destroy_listener(client, &a.listener);
+
+	assert(wl_client_get_destroy_listener(client, client_destroy_notify) ==
+	       &a.listener);
+
+	b.listener.notify = client_destroy_notify;
+	b.done = 0;
+	wl_client_add_destroy_listener(client, &b.listener);
+
+	wl_list_remove(&a.listener.link);
+
+	wl_client_destroy(client);
+
+	assert(!a.done);
+	assert(b.done);
+
+	close(s0);
+	close(s1);
+
+	wl_display_destroy(display);
+}
+

_service:tar_scm:wayland-1.21.0.tar.gz/tests/compositor-introspection-test.c Added

@@ -0,0 +1,172 @@
+/*
+ * Copyright © 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "wayland-client.h"
+#include "wayland-server.h"
+#include "test-runner.h"
+
+/* Ensure the connection doesn't fail due to lack of XDG_RUNTIME_DIR. */
+static const char *
+require_xdg_runtime_dir(void)
+{
+	char *val = getenv("XDG_RUNTIME_DIR");
+	assert(val && val0 == '/' && "set $XDG_RUNTIME_DIR to run this test");
+
+	return val;
+}
+
+struct compositor {
+	struct wl_display *display;
+	struct wl_listener listener;
+	struct wl_client *client;
+};
+
+static void
+client_created(struct wl_listener *listener, void *data)
+{
+	struct compositor *c = wl_container_of(listener, c, listener);
+	c->client = data;
+}
+
+static void
+check_client_list(struct compositor *compositor)
+{
+	struct wl_list *client_list;
+	struct wl_client *client, *client_it;
+	int num_clients = 0;
+
+	client_list = wl_display_get_client_list(compositor->display);
+	wl_client_for_each(client_it, client_list) {
+		num_clients++;
+		client = client_it;
+	}
+	assert(num_clients == 1);
+	/* 'client_it' is not valid here, so we took a copy of the client in the loop.
+	 * We could also do this assert in the loop directly, but in case it fails it is
+	 * easier to understand the problem when we know that the previous assert passed,
+	 * so that there is only one client but the wrong one. */
+	assert(compositor->client == client);
+}
+
+static const char *
+setup_compositor(struct compositor *compositor)
+{
+	const char *socket;
+
+	require_xdg_runtime_dir();
+
+	compositor->display = wl_display_create();
+	socket = wl_display_add_socket_auto(compositor->display);
+
+	compositor->listener.notify = client_created;
+	wl_display_add_client_created_listener(compositor->display, &compositor->listener);
+
+	return socket;
+}
+
+static void
+cleanup_compositor(struct compositor *compositor)
+{
+	wl_client_destroy(compositor->client);
+	wl_display_destroy(compositor->display);
+}
+
+TEST(new_client_connect)
+{
+	const char *socket;
+	struct compositor compositor = { 0 };
+	struct {
+		struct wl_display *display;
+	} client;
+
+	socket = setup_compositor(&compositor);
+
+	client.display = wl_display_connect(socket);
+
+	wl_event_loop_dispatch(wl_display_get_event_loop(compositor.display), 100);
+
+	assert(compositor.client != NULL);
+
+	check_client_list(&compositor);
+
+
+
+	wl_display_disconnect(client.display);
+	cleanup_compositor(&compositor);
+}
+
+struct resource_listener {
+	struct wl_listener listener;
+	int count;
+};
+
+static void
+resource_created(struct wl_listener *listener, void *data)
+{
+	struct resource_listener *l;
+	l = wl_container_of(listener, l, listener);
+	l->count++;
+}
+
+TEST(new_resource)
+{
+	const char *socket;
+	struct compositor compositor = { 0 };
+	struct {
+		struct wl_display *display;
+		struct wl_callback *cb;
+	} client;
+	struct resource_listener resource_listener;
+
+	socket = setup_compositor(&compositor);
+	client.display = wl_display_connect(socket);
+	wl_event_loop_dispatch(wl_display_get_event_loop(compositor.display), 100);
+
+	resource_listener.count = 0;
+	resource_listener.listener.notify = resource_created;
+	wl_client_add_resource_created_listener(compositor.client,
+						&resource_listener.listener);
+
+	client.cb = wl_display_sync(client.display);
+	wl_display_flush(client.display);
+	wl_event_loop_dispatch(wl_display_get_event_loop(compositor.display), 100);
+
+	assert(resource_listener.count == 1);
+
+	wl_callback_destroy(client.cb);
+	wl_display_disconnect(client.display);
+	cleanup_compositor(&compositor);
+
+	/* This is defined to be safe also after client destruction */
+	wl_list_remove(&resource_listener.listener.link);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/connection-test.c Added

@@ -0,0 +1,861 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <poll.h>
+
+#include "wayland-private.h"
+#include "test-runner.h"
+#include "test-compositor.h"
+
+static const char message = "Hello, world";
+
+static struct wl_connection *
+setup(int *s)
+{
+	struct wl_connection *connection;
+
+	assert(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, s) == 0);
+
+	connection = wl_connection_create(s0);
+	assert(connection);
+
+	return connection;
+}
+
+TEST(connection_create)
+{
+	struct wl_connection *connection;
+	int s2;
+
+	connection = setup(s);
+	wl_connection_destroy(connection);
+	close(s0);
+	close(s1);
+}
+
+TEST(connection_write)
+{
+	struct wl_connection *connection;
+	int s2;
+	char buffer64;
+
+	connection = setup(s);
+
+	assert(wl_connection_write(connection, message, sizeof message) == 0);
+	assert(wl_connection_flush(connection) == sizeof message);
+	assert(read(s1, buffer, sizeof buffer) == sizeof message);
+	assert(memcmp(message, buffer, sizeof message) == 0);
+
+	wl_connection_destroy(connection);
+	close(s0);
+	close(s1);
+}
+
+TEST(connection_data)
+{
+	struct wl_connection *connection;
+	int s2;
+	char buffer64;
+
+	connection = setup(s);
+
+	assert(write(s1, message, sizeof message) == sizeof message);
+	assert(wl_connection_read(connection) == sizeof message);
+	wl_connection_copy(connection, buffer, sizeof message);
+	assert(memcmp(message, buffer, sizeof message) == 0);
+	wl_connection_consume(connection, sizeof message);
+
+	wl_connection_destroy(connection);
+	close(s0);
+	close(s1);
+}
+
+TEST(connection_queue)
+{
+	struct wl_connection *connection;
+	int s2;
+	char buffer64;
+
+	connection = setup(s);
+
+	/* Test that wl_connection_queue() puts data in the output
+	 * buffer without flush it.  Verify that the data did get in
+	 * the buffer by writing another message and making sure that
+	 * we receive the two messages on the other fd. */
+
+	assert(wl_connection_queue(connection, message, sizeof message) == 0);
+	assert(wl_connection_flush(connection) == 0);
+	assert(wl_connection_write(connection, message, sizeof message) == 0);
+	assert(wl_connection_flush(connection) == 2 * sizeof message);
+	assert(read(s1, buffer, sizeof buffer) == 2 * sizeof message);
+	assert(memcmp(message, buffer, sizeof message) == 0);
+	assert(memcmp(message, buffer + sizeof message, sizeof message) == 0);
+
+	wl_connection_destroy(connection);
+	close(s0);
+	close(s1);
+}
+
+static void
+va_list_wrapper(const char *signature, union wl_argument *args, int count, ...)
+{
+	va_list ap;
+	va_start(ap, count);
+	wl_argument_from_va_list(signature, args, count, ap);
+	va_end(ap);
+}
+
+TEST(argument_from_va_list)
+{
+	union wl_argument argsWL_CLOSURE_MAX_ARGS;
+	struct wl_object fake_object, fake_new_object;
+	struct wl_array fake_array;
+
+	va_list_wrapper("i", args, 1, 100);
+	assert(args0.i == 100);
+
+	va_list_wrapper("is", args, 2, 101, "value");
+	assert(args0.i == 101);
+	assert(strcmp(args1.s, "value") == 0);
+
+	va_list_wrapper("?iuf?sonah", args, 8,
+			102, 103, wl_fixed_from_int(104), "value",
+			&fake_object, &fake_new_object, &fake_array, 106);
+	assert(args0.i == 102);
+	assert(args1.u == 103);
+	assert(args2.f == wl_fixed_from_int(104));
+	assert(strcmp(args3.s, "value") == 0);
+	assert(args4.o == &fake_object);
+	assert(args5.o == &fake_new_object);
+	assert(args6.a == &fake_array);
+	assert(args7.h == 106);
+}
+
+struct marshal_data {
+	struct wl_connection *read_connection;
+	struct wl_connection *write_connection;
+	int s2;
+	uint32_t buffer10;
+	union {
+		uint32_t u;
+		int32_t i;
+		const char *s;
+		int h;
+	} value;
+};
+
+static void
+setup_marshal_data(struct marshal_data *data)
+{
+	assert(socketpair(AF_UNIX,
+			  SOCK_STREAM | SOCK_CLOEXEC, 0, data->s) == 0);
+	data->read_connection = wl_connection_create(data->s0);
+	assert(data->read_connection);
+	data->write_connection = wl_connection_create(data->s1);
+	assert(data->write_connection);
+}
+
+static void
+release_marshal_data(struct marshal_data *data)
+{
+	close(wl_connection_destroy(data->read_connection));
+	close(wl_connection_destroy(data->write_connection));
+}
+
+static void

_service:tar_scm:wayland-1.21.0.tar.gz/tests/cpp-compile-test.cpp Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/bad-identifier-arg.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/bad-identifier-entry.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/bad-identifier-enum.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/bad-identifier-event.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/bad-identifier-interface.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/bad-identifier-protocol.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/bad-identifier-request.xml Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/example-client.h Added

@@ -0,0 +1,5625 @@
+/* SCANNER TEST */
+
+#ifndef WAYLAND_CLIENT_PROTOCOL_H
+#define WAYLAND_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_wayland The wayland protocol
+ * @section page_ifaces_wayland Interfaces
+ * - @subpage page_iface_wl_display - core global object
+ * - @subpage page_iface_wl_registry - global registry object
+ * - @subpage page_iface_wl_callback - callback object
+ * - @subpage page_iface_wl_compositor - the compositor singleton
+ * - @subpage page_iface_wl_shm_pool - a shared memory pool
+ * - @subpage page_iface_wl_shm - shared memory support
+ * - @subpage page_iface_wl_buffer - content for a wl_surface
+ * - @subpage page_iface_wl_data_offer - offer to transfer data
+ * - @subpage page_iface_wl_data_source - offer to transfer data
+ * - @subpage page_iface_wl_data_device - data transfer device
+ * - @subpage page_iface_wl_data_device_manager - data transfer interface
+ * - @subpage page_iface_wl_shell - create desktop-style surfaces
+ * - @subpage page_iface_wl_shell_surface - desktop-style metadata interface
+ * - @subpage page_iface_wl_surface - an onscreen surface
+ * - @subpage page_iface_wl_seat - group of input devices
+ * - @subpage page_iface_wl_pointer - pointer input device
+ * - @subpage page_iface_wl_keyboard - keyboard input device
+ * - @subpage page_iface_wl_touch - touchscreen input device
+ * - @subpage page_iface_wl_output - compositor output region
+ * - @subpage page_iface_wl_region - region interface
+ * - @subpage page_iface_wl_subcompositor - sub-surface compositing
+ * - @subpage page_iface_wl_subsurface - sub-surface interface to a wl_surface
+ * @section page_copyright_wayland Copyright
+ * <pre>
+ *
+ * Copyright © 2008-2011 Kristian Høgsberg
+ * Copyright © 2010-2011 Intel Corporation
+ * Copyright © 2012-2013 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * </pre>
+ */
+struct wl_buffer;
+struct wl_callback;
+struct wl_compositor;
+struct wl_data_device;
+struct wl_data_device_manager;
+struct wl_data_offer;
+struct wl_data_source;
+struct wl_display;
+struct wl_keyboard;
+struct wl_output;
+struct wl_pointer;
+struct wl_region;
+struct wl_registry;
+struct wl_seat;
+struct wl_shell;
+struct wl_shell_surface;
+struct wl_shm;
+struct wl_shm_pool;
+struct wl_subcompositor;
+struct wl_subsurface;
+struct wl_surface;
+struct wl_touch;
+
+#ifndef WL_DISPLAY_INTERFACE
+#define WL_DISPLAY_INTERFACE
+/**
+ * @page page_iface_wl_display wl_display
+ * @section page_iface_wl_display_desc Description
+ *
+ * The core global object.  This is a special singleton object.  It
+ * is used for internal Wayland protocol features.
+ * @section page_iface_wl_display_api API
+ * See @ref iface_wl_display.
+ */
+/**
+ * @defgroup iface_wl_display The wl_display interface
+ *
+ * The core global object.  This is a special singleton object.  It
+ * is used for internal Wayland protocol features.
+ */
+extern const struct wl_interface wl_display_interface;
+#endif
+#ifndef WL_REGISTRY_INTERFACE
+#define WL_REGISTRY_INTERFACE
+/**
+ * @page page_iface_wl_registry wl_registry
+ * @section page_iface_wl_registry_desc Description
+ *
+ * The singleton global registry object.  The server has a number of
+ * global objects that are available to all clients.  These objects
+ * typically represent an actual object in the server (for example,
+ * an input device) or they are singleton objects that provide
+ * extension functionality.
+ *
+ * When a client creates a registry object, the registry object
+ * will emit a global event for each global currently in the
+ * registry.  Globals come and go as a result of device or
+ * monitor hotplugs, reconfiguration or other events, and the
+ * registry will send out global and global_remove events to
+ * keep the client up to date with the changes.  To mark the end
+ * of the initial burst of events, the client can use the
+ * wl_display.sync request immediately after calling
+ * wl_display.get_registry.
+ *
+ * A client can bind to a global object by using the bind
+ * request.  This creates a client-side handle that lets the object
+ * emit events to the client and lets the client invoke requests on
+ * the object.
+ * @section page_iface_wl_registry_api API
+ * See @ref iface_wl_registry.
+ */
+/**
+ * @defgroup iface_wl_registry The wl_registry interface
+ *
+ * The singleton global registry object.  The server has a number of
+ * global objects that are available to all clients.  These objects
+ * typically represent an actual object in the server (for example,
+ * an input device) or they are singleton objects that provide
+ * extension functionality.
+ *
+ * When a client creates a registry object, the registry object
+ * will emit a global event for each global currently in the
+ * registry.  Globals come and go as a result of device or
+ * monitor hotplugs, reconfiguration or other events, and the
+ * registry will send out global and global_remove events to
+ * keep the client up to date with the changes.  To mark the end
+ * of the initial burst of events, the client can use the
+ * wl_display.sync request immediately after calling
+ * wl_display.get_registry.
+ *
+ * A client can bind to a global object by using the bind
+ * request.  This creates a client-side handle that lets the object
+ * emit events to the client and lets the client invoke requests on
+ * the object.
+ */
+extern const struct wl_interface wl_registry_interface;
+#endif
+#ifndef WL_CALLBACK_INTERFACE
+#define WL_CALLBACK_INTERFACE
+/**
+ * @page page_iface_wl_callback wl_callback
+ * @section page_iface_wl_callback_desc Description
+ *
+ * Clients can handle the 'done' event to get notified when
+ * the related request is done.
+ * @section page_iface_wl_callback_api API
+ * See @ref iface_wl_callback.
+ */
+/**
+ * @defgroup iface_wl_callback The wl_callback interface
+ *
+ * Clients can handle the 'done' event to get notified when
+ * the related request is done.
+ */
+extern const struct wl_interface wl_callback_interface;
+#endif
+#ifndef WL_COMPOSITOR_INTERFACE
+#define WL_COMPOSITOR_INTERFACE
+/**
+ * @page page_iface_wl_compositor wl_compositor
+ * @section page_iface_wl_compositor_desc Description
+ *
+ * A compositor.  This object is a singleton global.  The
+ * compositor is in charge of combining the contents of multiple
+ * surfaces into one displayable output.
+ * @section page_iface_wl_compositor_api API
+ * See @ref iface_wl_compositor.
+ */
+/**
+ * @defgroup iface_wl_compositor The wl_compositor interface
+ *
+ * A compositor.  This object is a singleton global.  The

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/example-code.c Added

@@ -0,0 +1,507 @@
+/* SCANNER TEST */
+
+/*
+ * Copyright © 2008-2011 Kristian Høgsberg
+ * Copyright © 2010-2011 Intel Corporation
+ * Copyright © 2012-2013 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+extern const struct wl_interface wl_buffer_interface;
+extern const struct wl_interface wl_callback_interface;
+extern const struct wl_interface wl_data_device_interface;
+extern const struct wl_interface wl_data_offer_interface;
+extern const struct wl_interface wl_data_source_interface;
+extern const struct wl_interface wl_keyboard_interface;
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface wl_pointer_interface;
+extern const struct wl_interface wl_region_interface;
+extern const struct wl_interface wl_registry_interface;
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_shell_surface_interface;
+extern const struct wl_interface wl_shm_pool_interface;
+extern const struct wl_interface wl_subsurface_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface wl_touch_interface;
+
+static const struct wl_interface *wayland_types = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&wl_callback_interface,
+	&wl_registry_interface,
+	&wl_surface_interface,
+	&wl_region_interface,
+	&wl_buffer_interface,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&wl_shm_pool_interface,
+	NULL,
+	NULL,
+	&wl_data_source_interface,
+	&wl_surface_interface,
+	&wl_surface_interface,
+	NULL,
+	&wl_data_source_interface,
+	NULL,
+	&wl_data_offer_interface,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	NULL,
+	&wl_data_offer_interface,
+	&wl_data_offer_interface,
+	&wl_data_source_interface,
+	&wl_data_device_interface,
+	&wl_seat_interface,
+	&wl_shell_surface_interface,
+	&wl_surface_interface,
+	&wl_seat_interface,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&wl_output_interface,
+	&wl_seat_interface,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_output_interface,
+	&wl_buffer_interface,
+	NULL,
+	NULL,
+	&wl_callback_interface,
+	&wl_region_interface,
+	&wl_region_interface,
+	&wl_output_interface,
+	&wl_output_interface,
+	&wl_pointer_interface,
+	&wl_keyboard_interface,
+	&wl_touch_interface,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	NULL,
+	&wl_surface_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_subsurface_interface,
+	&wl_surface_interface,
+	&wl_surface_interface,
+	&wl_surface_interface,
+	&wl_surface_interface,
+};
+
+static const struct wl_message wl_display_requests = {
+	{ "sync", "n", wayland_types + 8 },
+	{ "get_registry", "n", wayland_types + 9 },
+};
+
+static const struct wl_message wl_display_events = {
+	{ "error", "ous", wayland_types + 0 },
+	{ "delete_id", "u", wayland_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface wl_display_interface = {
+	"wl_display", 1,
+	2, wl_display_requests,
+	2, wl_display_events,
+};
+
+static const struct wl_message wl_registry_requests = {
+	{ "bind", "usun", wayland_types + 0 },
+};
+
+static const struct wl_message wl_registry_events = {
+	{ "global", "usu", wayland_types + 0 },
+	{ "global_remove", "u", wayland_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface wl_registry_interface = {
+	"wl_registry", 1,
+	1, wl_registry_requests,
+	2, wl_registry_events,
+};
+
+static const struct wl_message wl_callback_events = {
+	{ "done", "u", wayland_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface wl_callback_interface = {
+	"wl_callback", 1,
+	0, NULL,
+	1, wl_callback_events,
+};
+
+static const struct wl_message wl_compositor_requests = {
+	{ "create_surface", "n", wayland_types + 10 },
+	{ "create_region", "n", wayland_types + 11 },
+};
+
+WL_EXPORT const struct wl_interface wl_compositor_interface = {
+	"wl_compositor", 4,
+	2, wl_compositor_requests,
+	0, NULL,
+};

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/example-server.h Added

@@ -0,0 +1,4401 @@
+/* SCANNER TEST */
+
+#ifndef WAYLAND_SERVER_PROTOCOL_H
+#define WAYLAND_SERVER_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-server.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct wl_client;
+struct wl_resource;
+
+/**
+ * @page page_wayland The wayland protocol
+ * @section page_ifaces_wayland Interfaces
+ * - @subpage page_iface_wl_display - core global object
+ * - @subpage page_iface_wl_registry - global registry object
+ * - @subpage page_iface_wl_callback - callback object
+ * - @subpage page_iface_wl_compositor - the compositor singleton
+ * - @subpage page_iface_wl_shm_pool - a shared memory pool
+ * - @subpage page_iface_wl_shm - shared memory support
+ * - @subpage page_iface_wl_buffer - content for a wl_surface
+ * - @subpage page_iface_wl_data_offer - offer to transfer data
+ * - @subpage page_iface_wl_data_source - offer to transfer data
+ * - @subpage page_iface_wl_data_device - data transfer device
+ * - @subpage page_iface_wl_data_device_manager - data transfer interface
+ * - @subpage page_iface_wl_shell - create desktop-style surfaces
+ * - @subpage page_iface_wl_shell_surface - desktop-style metadata interface
+ * - @subpage page_iface_wl_surface - an onscreen surface
+ * - @subpage page_iface_wl_seat - group of input devices
+ * - @subpage page_iface_wl_pointer - pointer input device
+ * - @subpage page_iface_wl_keyboard - keyboard input device
+ * - @subpage page_iface_wl_touch - touchscreen input device
+ * - @subpage page_iface_wl_output - compositor output region
+ * - @subpage page_iface_wl_region - region interface
+ * - @subpage page_iface_wl_subcompositor - sub-surface compositing
+ * - @subpage page_iface_wl_subsurface - sub-surface interface to a wl_surface
+ * @section page_copyright_wayland Copyright
+ * <pre>
+ *
+ * Copyright © 2008-2011 Kristian Høgsberg
+ * Copyright © 2010-2011 Intel Corporation
+ * Copyright © 2012-2013 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * </pre>
+ */
+struct wl_buffer;
+struct wl_callback;
+struct wl_compositor;
+struct wl_data_device;
+struct wl_data_device_manager;
+struct wl_data_offer;
+struct wl_data_source;
+struct wl_display;
+struct wl_keyboard;
+struct wl_output;
+struct wl_pointer;
+struct wl_region;
+struct wl_registry;
+struct wl_seat;
+struct wl_shell;
+struct wl_shell_surface;
+struct wl_shm;
+struct wl_shm_pool;
+struct wl_subcompositor;
+struct wl_subsurface;
+struct wl_surface;
+struct wl_touch;
+
+#ifndef WL_DISPLAY_INTERFACE
+#define WL_DISPLAY_INTERFACE
+/**
+ * @page page_iface_wl_display wl_display
+ * @section page_iface_wl_display_desc Description
+ *
+ * The core global object.  This is a special singleton object.  It
+ * is used for internal Wayland protocol features.
+ * @section page_iface_wl_display_api API
+ * See @ref iface_wl_display.
+ */
+/**
+ * @defgroup iface_wl_display The wl_display interface
+ *
+ * The core global object.  This is a special singleton object.  It
+ * is used for internal Wayland protocol features.
+ */
+extern const struct wl_interface wl_display_interface;
+#endif
+#ifndef WL_REGISTRY_INTERFACE
+#define WL_REGISTRY_INTERFACE
+/**
+ * @page page_iface_wl_registry wl_registry
+ * @section page_iface_wl_registry_desc Description
+ *
+ * The singleton global registry object.  The server has a number of
+ * global objects that are available to all clients.  These objects
+ * typically represent an actual object in the server (for example,
+ * an input device) or they are singleton objects that provide
+ * extension functionality.
+ *
+ * When a client creates a registry object, the registry object
+ * will emit a global event for each global currently in the
+ * registry.  Globals come and go as a result of device or
+ * monitor hotplugs, reconfiguration or other events, and the
+ * registry will send out global and global_remove events to
+ * keep the client up to date with the changes.  To mark the end
+ * of the initial burst of events, the client can use the
+ * wl_display.sync request immediately after calling
+ * wl_display.get_registry.
+ *
+ * A client can bind to a global object by using the bind
+ * request.  This creates a client-side handle that lets the object
+ * emit events to the client and lets the client invoke requests on
+ * the object.
+ * @section page_iface_wl_registry_api API
+ * See @ref iface_wl_registry.
+ */
+/**
+ * @defgroup iface_wl_registry The wl_registry interface
+ *
+ * The singleton global registry object.  The server has a number of
+ * global objects that are available to all clients.  These objects
+ * typically represent an actual object in the server (for example,
+ * an input device) or they are singleton objects that provide
+ * extension functionality.
+ *
+ * When a client creates a registry object, the registry object
+ * will emit a global event for each global currently in the
+ * registry.  Globals come and go as a result of device or
+ * monitor hotplugs, reconfiguration or other events, and the
+ * registry will send out global and global_remove events to
+ * keep the client up to date with the changes.  To mark the end
+ * of the initial burst of events, the client can use the
+ * wl_display.sync request immediately after calling
+ * wl_display.get_registry.
+ *
+ * A client can bind to a global object by using the bind
+ * request.  This creates a client-side handle that lets the object
+ * emit events to the client and lets the client invoke requests on
+ * the object.
+ */
+extern const struct wl_interface wl_registry_interface;
+#endif
+#ifndef WL_CALLBACK_INTERFACE
+#define WL_CALLBACK_INTERFACE
+/**
+ * @page page_iface_wl_callback wl_callback
+ * @section page_iface_wl_callback_desc Description
+ *
+ * Clients can handle the 'done' event to get notified when
+ * the related request is done.
+ * @section page_iface_wl_callback_api API
+ * See @ref iface_wl_callback.
+ */
+/**
+ * @defgroup iface_wl_callback The wl_callback interface
+ *
+ * Clients can handle the 'done' event to get notified when
+ * the related request is done.
+ */
+extern const struct wl_interface wl_callback_interface;
+#endif
+#ifndef WL_COMPOSITOR_INTERFACE
+#define WL_COMPOSITOR_INTERFACE
+/**
+ * @page page_iface_wl_compositor wl_compositor
+ * @section page_iface_wl_compositor_desc Description
+ *
+ * A compositor.  This object is a singleton global.  The
+ * compositor is in charge of combining the contents of multiple
+ * surfaces into one displayable output.
+ * @section page_iface_wl_compositor_api API
+ * See @ref iface_wl_compositor.
+ */
+/**

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/example.xml Added

@@ -0,0 +1,2748 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wayland">
+
+  <copyright>
+    Copyright © 2008-2011 Kristian Høgsberg
+    Copyright © 2010-2011 Intel Corporation
+    Copyright © 2012-2013 Collabora, Ltd.
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation files
+    (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the
+    next paragraph) shall be included in all copies or substantial
+    portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  </copyright>
+
+  <interface name="wl_display" version="1">
+    <description summary="core global object">
+      The core global object.  This is a special singleton object.  It
+      is used for internal Wayland protocol features.
+    </description>
+
+    <request name="sync">
+      <description summary="asynchronous roundtrip">
+	The sync request asks the server to emit the 'done' event
+	on the returned wl_callback object.  Since requests are
+	handled in-order and events are delivered in-order, this can
+	be used as a barrier to ensure all previous requests and the
+	resulting events have been handled.
+
+	The object returned by this request will be destroyed by the
+	compositor after the callback is fired and as such the client must not
+	attempt to use it after that point.
+
+	The callback_data passed in the callback is the event serial.
+      </description>
+      <arg name="callback" type="new_id" interface="wl_callback"
+	   summary="callback object for the sync request"/>
+    </request>
+
+    <request name="get_registry">
+      <description summary="get global registry object">
+	This request creates a registry object that allows the client
+	to list and bind the global objects available from the
+	compositor.
+      </description>
+      <arg name="registry" type="new_id" interface="wl_registry"
+	   summary="global registry object"/>
+    </request>
+
+    <event name="error">
+      <description summary="fatal error event">
+	The error event is sent out when a fatal (non-recoverable)
+	error has occurred.  The object_id argument is the object
+	where the error occurred, most often in response to a request
+	to that object.  The code identifies the error and is defined
+	by the object interface.  As such, each interface defines its
+	own set of error codes.  The message is a brief description
+	of the error, for (debugging) convenience.
+      </description>
+      <arg name="object_id" type="object" summary="object where the error occurred"/>
+      <arg name="code" type="uint" summary="error code"/>
+      <arg name="message" type="string" summary="error description"/>
+    </event>
+
+    <enum name="error">
+      <description summary="global error values">
+	These errors are global and can be emitted in response to any
+	server request.
+      </description>
+      <entry name="invalid_object" value="0"
+	     summary="server couldn't find object"/>
+      <entry name="invalid_method" value="1"
+	     summary="method doesn't exist on the specified interface"/>
+      <entry name="no_memory" value="2"
+	     summary="server is out of memory"/>
+    </enum>
+
+    <event name="delete_id">
+      <description summary="acknowledge object ID deletion">
+	This event is used internally by the object ID management
+	logic.  When a client deletes an object, the server will send
+	this event to acknowledge that it has seen the delete request.
+	When the client receives this event, it will know that it can
+	safely reuse the object ID.
+      </description>
+      <arg name="id" type="uint" summary="deleted object ID"/>
+    </event>
+  </interface>
+
+  <interface name="wl_registry" version="1">
+    <description summary="global registry object">
+      The singleton global registry object.  The server has a number of
+      global objects that are available to all clients.  These objects
+      typically represent an actual object in the server (for example,
+      an input device) or they are singleton objects that provide
+      extension functionality.
+
+      When a client creates a registry object, the registry object
+      will emit a global event for each global currently in the
+      registry.  Globals come and go as a result of device or
+      monitor hotplugs, reconfiguration or other events, and the
+      registry will send out global and global_remove events to
+      keep the client up to date with the changes.  To mark the end
+      of the initial burst of events, the client can use the
+      wl_display.sync request immediately after calling
+      wl_display.get_registry.
+
+      A client can bind to a global object by using the bind
+      request.  This creates a client-side handle that lets the object
+      emit events to the client and lets the client invoke requests on
+      the object.
+    </description>
+
+    <request name="bind">
+      <description summary="bind an object to the display">
+	Binds a new, client-created object to the server using the
+	specified name as the identifier.
+      </description>
+      <arg name="name" type="uint" summary="unique numeric name of the object"/>
+      <arg name="id" type="new_id" summary="bounded object"/>
+    </request>
+
+    <event name="global">
+      <description summary="announce global object">
+	Notify the client of global objects.
+
+	The event notifies the client that a global object with
+	the given name is now available, and it implements the
+	given version of the given interface.
+      </description>
+      <arg name="name" type="uint" summary="numeric name of the global object"/>
+      <arg name="interface" type="string" summary="interface implemented by the object"/>
+      <arg name="version" type="uint" summary="interface version"/>
+    </event>
+
+    <event name="global_remove">
+      <description summary="announce removal of global object">
+	Notify the client of removed global objects.
+
+	This event notifies the client that the global identified
+	by name is no longer available.  If the client bound to
+	the global using the bind request, the client should now
+	destroy that object.
+
+	The object remains valid and requests to the object will be
+	ignored until the client destroys it, to avoid races between
+	the global going away and a client sending a request to it.
+      </description>
+      <arg name="name" type="uint" summary="numeric name of the global object"/>
+    </event>
+  </interface>
+
+  <interface name="wl_callback" version="1">
+    <description summary="callback object">
+      Clients can handle the 'done' event to get notified when
+      the related request is done.
+    </description>
+
+    <event name="done">
+      <description summary="done event">
+	Notify the client when the related request is done.
+      </description>
+      <arg name="callback_data" type="uint" summary="request-specific data for the callback"/>
+    </event>
+  </interface>
+
+  <interface name="wl_compositor" version="4">
+    <description summary="the compositor singleton">
+      A compositor.  This object is a singleton global.  The
+      compositor is in charge of combining the contents of multiple
+      surfaces into one displayable output.
+    </description>
+
+    <request name="create_surface">
+      <description summary="create new surface">
+	Ask the compositor to create a new surface.
+      </description>
+      <arg name="id" type="new_id" interface="wl_surface" summary="the new surface"/>
+    </request>
+
+    <request name="create_region">
+      <description summary="create new region">
+	Ask the compositor to create a new region.
+      </description>

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/small-client-core.h Added

@@ -0,0 +1,196 @@
+/* SCANNER TEST */
+
+#ifndef SMALL_TEST_CLIENT_PROTOCOL_H
+#define SMALL_TEST_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client-core.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_small_test The small_test protocol
+ * @section page_ifaces_small_test Interfaces
+ * - @subpage page_iface_intf_A - the thing A
+ * @section page_copyright_small_test Copyright
+ * <pre>
+ *
+ * Copyright © 2016 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * </pre>
+ */
+struct another_intf;
+struct intf_A;
+struct intf_not_here;
+
+#ifndef INTF_A_INTERFACE
+#define INTF_A_INTERFACE
+/**
+ * @page page_iface_intf_A intf_A
+ * @section page_iface_intf_A_desc Description
+ *
+ * A useless example trying to tickle the scanner.
+ * @section page_iface_intf_A_api API
+ * See @ref iface_intf_A.
+ */
+/**
+ * @defgroup iface_intf_A The intf_A interface
+ *
+ * A useless example trying to tickle the scanner.
+ */
+extern const struct wl_interface intf_A_interface;
+#endif
+
+#ifndef INTF_A_FOO_ENUM
+#define INTF_A_FOO_ENUM
+enum intf_A_foo {
+	/**
+	 * this is the first
+	 */
+	INTF_A_FOO_FIRST = 0,
+	/**
+	 * this is the second
+	 */
+	INTF_A_FOO_SECOND = 1,
+	/**
+	 * this is the third
+	 * @since 2
+	 */
+	INTF_A_FOO_THIRD = 2,
+};
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_FOO_THIRD_SINCE_VERSION 2
+#endif /* INTF_A_FOO_ENUM */
+
+/**
+ * @ingroup iface_intf_A
+ * @struct intf_A_listener
+ */
+struct intf_A_listener {
+	/**
+	 */
+	void (*hey)(void *data,
+		    struct intf_A *intf_A);
+};
+
+/**
+ * @ingroup iface_intf_A
+ */
+static inline int
+intf_A_add_listener(struct intf_A *intf_A,
+		    const struct intf_A_listener *listener, void *data)
+{
+	return wl_proxy_add_listener((struct wl_proxy *) intf_A,
+				     (void (**)(void)) listener, data);
+}
+
+#define INTF_A_RQ1 0
+#define INTF_A_RQ2 1
+#define INTF_A_DESTROY 2
+
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_HEY_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_RQ1_SINCE_VERSION 1
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_RQ2_SINCE_VERSION 1
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_DESTROY_SINCE_VERSION 1
+
+/** @ingroup iface_intf_A */
+static inline void
+intf_A_set_user_data(struct intf_A *intf_A, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) intf_A, user_data);
+}
+
+/** @ingroup iface_intf_A */
+static inline void *
+intf_A_get_user_data(struct intf_A *intf_A)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) intf_A);
+}
+
+static inline uint32_t
+intf_A_get_version(struct intf_A *intf_A)
+{
+	return wl_proxy_get_version((struct wl_proxy *) intf_A);
+}
+
+/**
+ * @ingroup iface_intf_A
+ */
+static inline void *
+intf_A_rq1(struct intf_A *intf_A, const struct wl_interface *interface, uint32_t version)
+{
+	struct wl_proxy *untyped_new;
+
+	untyped_new = wl_proxy_marshal_flags((struct wl_proxy *) intf_A,
+			 INTF_A_RQ1, interface, version, 0, interface->name, version, NULL);
+
+	return (void *) untyped_new;
+}
+
+/**
+ * @ingroup iface_intf_A
+ */
+static inline struct intf_not_here *
+intf_A_rq2(struct intf_A *intf_A, const char *str, int32_t i, uint32_t u, wl_fixed_t f, int32_t fd, struct another_intf *obj)
+{
+	struct wl_proxy *typed_new;
+
+	typed_new = wl_proxy_marshal_flags((struct wl_proxy *) intf_A,
+			 INTF_A_RQ2, &intf_not_here_interface, wl_proxy_get_version((struct wl_proxy *) intf_A), 0, NULL, str, i, u, f, fd, obj);
+
+	return (struct intf_not_here *) typed_new;
+}
+
+/**
+ * @ingroup iface_intf_A
+ */
+static inline void
+intf_A_destroy(struct intf_A *intf_A)
+{
+	wl_proxy_marshal_flags((struct wl_proxy *) intf_A,
+			 INTF_A_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) intf_A), WL_MARSHAL_FLAG_DESTROY);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/small-client.h Added

@@ -0,0 +1,196 @@
+/* SCANNER TEST */
+
+#ifndef SMALL_TEST_CLIENT_PROTOCOL_H
+#define SMALL_TEST_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_small_test The small_test protocol
+ * @section page_ifaces_small_test Interfaces
+ * - @subpage page_iface_intf_A - the thing A
+ * @section page_copyright_small_test Copyright
+ * <pre>
+ *
+ * Copyright © 2016 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * </pre>
+ */
+struct another_intf;
+struct intf_A;
+struct intf_not_here;
+
+#ifndef INTF_A_INTERFACE
+#define INTF_A_INTERFACE
+/**
+ * @page page_iface_intf_A intf_A
+ * @section page_iface_intf_A_desc Description
+ *
+ * A useless example trying to tickle the scanner.
+ * @section page_iface_intf_A_api API
+ * See @ref iface_intf_A.
+ */
+/**
+ * @defgroup iface_intf_A The intf_A interface
+ *
+ * A useless example trying to tickle the scanner.
+ */
+extern const struct wl_interface intf_A_interface;
+#endif
+
+#ifndef INTF_A_FOO_ENUM
+#define INTF_A_FOO_ENUM
+enum intf_A_foo {
+	/**
+	 * this is the first
+	 */
+	INTF_A_FOO_FIRST = 0,
+	/**
+	 * this is the second
+	 */
+	INTF_A_FOO_SECOND = 1,
+	/**
+	 * this is the third
+	 * @since 2
+	 */
+	INTF_A_FOO_THIRD = 2,
+};
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_FOO_THIRD_SINCE_VERSION 2
+#endif /* INTF_A_FOO_ENUM */
+
+/**
+ * @ingroup iface_intf_A
+ * @struct intf_A_listener
+ */
+struct intf_A_listener {
+	/**
+	 */
+	void (*hey)(void *data,
+		    struct intf_A *intf_A);
+};
+
+/**
+ * @ingroup iface_intf_A
+ */
+static inline int
+intf_A_add_listener(struct intf_A *intf_A,
+		    const struct intf_A_listener *listener, void *data)
+{
+	return wl_proxy_add_listener((struct wl_proxy *) intf_A,
+				     (void (**)(void)) listener, data);
+}
+
+#define INTF_A_RQ1 0
+#define INTF_A_RQ2 1
+#define INTF_A_DESTROY 2
+
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_HEY_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_RQ1_SINCE_VERSION 1
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_RQ2_SINCE_VERSION 1
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_DESTROY_SINCE_VERSION 1
+
+/** @ingroup iface_intf_A */
+static inline void
+intf_A_set_user_data(struct intf_A *intf_A, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) intf_A, user_data);
+}
+
+/** @ingroup iface_intf_A */
+static inline void *
+intf_A_get_user_data(struct intf_A *intf_A)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) intf_A);
+}
+
+static inline uint32_t
+intf_A_get_version(struct intf_A *intf_A)
+{
+	return wl_proxy_get_version((struct wl_proxy *) intf_A);
+}
+
+/**
+ * @ingroup iface_intf_A
+ */
+static inline void *
+intf_A_rq1(struct intf_A *intf_A, const struct wl_interface *interface, uint32_t version)
+{
+	struct wl_proxy *untyped_new;
+
+	untyped_new = wl_proxy_marshal_flags((struct wl_proxy *) intf_A,
+			 INTF_A_RQ1, interface, version, 0, interface->name, version, NULL);
+
+	return (void *) untyped_new;
+}
+
+/**
+ * @ingroup iface_intf_A
+ */
+static inline struct intf_not_here *
+intf_A_rq2(struct intf_A *intf_A, const char *str, int32_t i, uint32_t u, wl_fixed_t f, int32_t fd, struct another_intf *obj)
+{
+	struct wl_proxy *typed_new;
+
+	typed_new = wl_proxy_marshal_flags((struct wl_proxy *) intf_A,
+			 INTF_A_RQ2, &intf_not_here_interface, wl_proxy_get_version((struct wl_proxy *) intf_A), 0, NULL, str, i, u, f, fd, obj);
+
+	return (struct intf_not_here *) typed_new;
+}
+
+/**
+ * @ingroup iface_intf_A
+ */
+static inline void
+intf_A_destroy(struct intf_A *intf_A)
+{
+	wl_proxy_marshal_flags((struct wl_proxy *) intf_A,
+			 INTF_A_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) intf_A), WL_MARSHAL_FLAG_DESTROY);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/small-code-core.c Added

@@ -0,0 +1,61 @@
+/* SCANNER TEST */
+
+/*
+ * Copyright © 2016 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+extern const struct wl_interface another_intf_interface;
+extern const struct wl_interface intf_not_here_interface;
+
+static const struct wl_interface *small_test_types = {
+	NULL,
+	&intf_not_here_interface,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&another_intf_interface,
+};
+
+static const struct wl_message intf_A_requests = {
+	{ "rq1", "sun", small_test_types + 0 },
+	{ "rq2", "nsiufho", small_test_types + 1 },
+	{ "destroy", "", small_test_types + 0 },
+};
+
+static const struct wl_message intf_A_events = {
+	{ "hey", "", small_test_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface intf_A_interface = {
+	"intf_A", 3,
+	3, intf_A_requests,
+	1, intf_A_events,
+};
+

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/small-code.c Added

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/small-private-code.c Added

@@ -0,0 +1,71 @@
+/* SCANNER TEST */
+
+/*
+ * Copyright © 2016 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface another_intf_interface;
+extern const struct wl_interface intf_not_here_interface;
+
+static const struct wl_interface *small_test_types = {
+	NULL,
+	&intf_not_here_interface,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&another_intf_interface,
+};
+
+static const struct wl_message intf_A_requests = {
+	{ "rq1", "sun", small_test_types + 0 },
+	{ "rq2", "nsiufho", small_test_types + 1 },
+	{ "destroy", "", small_test_types + 0 },
+};
+
+static const struct wl_message intf_A_events = {
+	{ "hey", "", small_test_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface intf_A_interface = {
+	"intf_A", 3,
+	3, intf_A_requests,
+	1, intf_A_events,
+};
+

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/small-server-core.h Added

@@ -0,0 +1,157 @@
+/* SCANNER TEST */
+
+#ifndef SMALL_TEST_SERVER_PROTOCOL_H
+#define SMALL_TEST_SERVER_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-server-core.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct wl_client;
+struct wl_resource;
+
+/**
+ * @page page_small_test The small_test protocol
+ * @section page_ifaces_small_test Interfaces
+ * - @subpage page_iface_intf_A - the thing A
+ * @section page_copyright_small_test Copyright
+ * <pre>
+ *
+ * Copyright © 2016 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * </pre>
+ */
+struct another_intf;
+struct intf_A;
+struct intf_not_here;
+
+#ifndef INTF_A_INTERFACE
+#define INTF_A_INTERFACE
+/**
+ * @page page_iface_intf_A intf_A
+ * @section page_iface_intf_A_desc Description
+ *
+ * A useless example trying to tickle the scanner.
+ * @section page_iface_intf_A_api API
+ * See @ref iface_intf_A.
+ */
+/**
+ * @defgroup iface_intf_A The intf_A interface
+ *
+ * A useless example trying to tickle the scanner.
+ */
+extern const struct wl_interface intf_A_interface;
+#endif
+
+#ifndef INTF_A_FOO_ENUM
+#define INTF_A_FOO_ENUM
+enum intf_A_foo {
+	/**
+	 * this is the first
+	 */
+	INTF_A_FOO_FIRST = 0,
+	/**
+	 * this is the second
+	 */
+	INTF_A_FOO_SECOND = 1,
+	/**
+	 * this is the third
+	 * @since 2
+	 */
+	INTF_A_FOO_THIRD = 2,
+};
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_FOO_THIRD_SINCE_VERSION 2
+#endif /* INTF_A_FOO_ENUM */
+
+/**
+ * @ingroup iface_intf_A
+ * @struct intf_A_interface
+ */
+struct intf_A_interface {
+	/**
+	 * @param interface name of the objects interface
+	 * @param version version of the objects interface
+	 */
+	void (*rq1)(struct wl_client *client,
+		    struct wl_resource *resource,
+		    const char *interface, uint32_t version, uint32_t untyped_new);
+	/**
+	 */
+	void (*rq2)(struct wl_client *client,
+		    struct wl_resource *resource,
+		    uint32_t typed_new,
+		    const char *str,
+		    int32_t i,
+		    uint32_t u,
+		    wl_fixed_t f,
+		    int32_t fd,
+		    struct wl_resource *obj);
+	/**
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+};
+
+#define INTF_A_HEY 0
+
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_HEY_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_RQ1_SINCE_VERSION 1
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_RQ2_SINCE_VERSION 1
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_DESTROY_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_intf_A
+ * Sends an hey event to the client owning the resource.
+ * @param resource_ The client's resource
+ */
+static inline void
+intf_A_send_hey(struct wl_resource *resource_)
+{
+	wl_resource_post_event(resource_, INTF_A_HEY);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/small-server.h Added

@@ -0,0 +1,157 @@
+/* SCANNER TEST */
+
+#ifndef SMALL_TEST_SERVER_PROTOCOL_H
+#define SMALL_TEST_SERVER_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-server.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct wl_client;
+struct wl_resource;
+
+/**
+ * @page page_small_test The small_test protocol
+ * @section page_ifaces_small_test Interfaces
+ * - @subpage page_iface_intf_A - the thing A
+ * @section page_copyright_small_test Copyright
+ * <pre>
+ *
+ * Copyright © 2016 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * </pre>
+ */
+struct another_intf;
+struct intf_A;
+struct intf_not_here;
+
+#ifndef INTF_A_INTERFACE
+#define INTF_A_INTERFACE
+/**
+ * @page page_iface_intf_A intf_A
+ * @section page_iface_intf_A_desc Description
+ *
+ * A useless example trying to tickle the scanner.
+ * @section page_iface_intf_A_api API
+ * See @ref iface_intf_A.
+ */
+/**
+ * @defgroup iface_intf_A The intf_A interface
+ *
+ * A useless example trying to tickle the scanner.
+ */
+extern const struct wl_interface intf_A_interface;
+#endif
+
+#ifndef INTF_A_FOO_ENUM
+#define INTF_A_FOO_ENUM
+enum intf_A_foo {
+	/**
+	 * this is the first
+	 */
+	INTF_A_FOO_FIRST = 0,
+	/**
+	 * this is the second
+	 */
+	INTF_A_FOO_SECOND = 1,
+	/**
+	 * this is the third
+	 * @since 2
+	 */
+	INTF_A_FOO_THIRD = 2,
+};
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_FOO_THIRD_SINCE_VERSION 2
+#endif /* INTF_A_FOO_ENUM */
+
+/**
+ * @ingroup iface_intf_A
+ * @struct intf_A_interface
+ */
+struct intf_A_interface {
+	/**
+	 * @param interface name of the objects interface
+	 * @param version version of the objects interface
+	 */
+	void (*rq1)(struct wl_client *client,
+		    struct wl_resource *resource,
+		    const char *interface, uint32_t version, uint32_t untyped_new);
+	/**
+	 */
+	void (*rq2)(struct wl_client *client,
+		    struct wl_resource *resource,
+		    uint32_t typed_new,
+		    const char *str,
+		    int32_t i,
+		    uint32_t u,
+		    wl_fixed_t f,
+		    int32_t fd,
+		    struct wl_resource *obj);
+	/**
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+};
+
+#define INTF_A_HEY 0
+
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_HEY_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_RQ1_SINCE_VERSION 1
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_RQ2_SINCE_VERSION 1
+/**
+ * @ingroup iface_intf_A
+ */
+#define INTF_A_DESTROY_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_intf_A
+ * Sends an hey event to the client owning the resource.
+ * @param resource_ The client's resource
+ */
+static inline void
+intf_A_send_hey(struct wl_resource *resource_)
+{
+	wl_resource_post_event(resource_, INTF_A_HEY);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/tests/data/small.xml Added

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="small_test">
+
+  <copyright>
+    Copyright © 2016 Collabora, Ltd.
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation files
+    (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the
+    next paragraph) shall be included in all copies or substantial
+    portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+    BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  </copyright>
+
+  <interface name="intf_A" version="3">
+    <description summary="the thing A">
+      A useless example trying to tickle the scanner.
+    </description>
+
+    <request name="rq1">
+      <arg name="untyped_new" type="new_id"/>
+    </request>
+
+    <request name="rq2">
+      <arg name="typed_new" type="new_id" interface="intf_not_here"/>
+      <arg name="str" type="string"/>
+      <arg name="i" type="int"/>
+      <arg name="u" type="uint"/>
+      <arg name="f" type="fixed"/>
+      <arg name="fd" type="fd"/>
+      <arg name="obj" type="object" interface="another_intf"/>
+    </request>
+
+    <request name="destroy" type="destructor"/>
+
+    <event name="hey"/>
+
+    <enum name="foo">
+	<entry name="first" value="0" summary="this is the first"/>
+	<entry name="second" value="1" summary="this is the second"/>
+	<entry name="third" value="2" since="2" summary="this is the third"/>
+    </enum>
+  </interface>
+</protocol>

_service:tar_scm:wayland-1.21.0.tar.gz/tests/display-test.c Added

@@ -0,0 +1,1712 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ * Copyright © 2013 Jason Ekstrand
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#include <pthread.h>
+#include <poll.h>
+
+#include "wayland-private.h"
+#include "wayland-server.h"
+#include "wayland-client.h"
+#include "test-runner.h"
+#include "test-compositor.h"
+
+#include "tests-server-protocol.h"
+#include "tests-client-protocol.h"
+
+struct display_destroy_listener {
+	struct wl_listener listener;
+	int done;
+};
+
+static void
+display_destroy_notify(struct wl_listener *l, void *data)
+{
+	struct display_destroy_listener *listener;
+
+	listener = wl_container_of(l, listener, listener);
+	listener->done = 1;
+}
+
+TEST(display_destroy_listener)
+{
+	struct wl_display *display;
+	struct display_destroy_listener a, b;
+
+	display = wl_display_create();
+	assert(display);
+
+	a.listener.notify = &display_destroy_notify;
+	a.done = 0;
+	wl_display_add_destroy_listener(display, &a.listener);
+
+	assert(wl_display_get_destroy_listener(display, display_destroy_notify) ==
+	       &a.listener);
+
+	b.listener.notify = display_destroy_notify;
+	b.done = 0;
+	wl_display_add_destroy_listener(display, &b.listener);
+
+	wl_list_remove(&a.listener.link);
+
+	wl_display_destroy(display);
+
+	assert(!a.done);
+	assert(b.done);
+}
+
+/* Fake 'client' which does not use wl_display_connect, and thus leaves the
+ * file descriptor passed through WAYLAND_SOCKET intact. This should not
+ * trigger an assertion in the leak check. */
+static void
+empty_client(void)
+{
+	return;
+}
+
+TEST(tc_leaks_tests)
+{
+	struct display *d = display_create();
+	client_create_noarg(d, empty_client);
+	display_run(d);
+	display_destroy(d);
+}
+
+/* This is how pre proxy-version registry binds worked,
+ * this should create a proxy that shares the display's
+ * version number: 0 */
+static void *
+old_registry_bind(struct wl_registry *wl_registry,
+		  uint32_t name,
+		  const struct wl_interface *interface,
+		  uint32_t version)
+{
+	struct wl_proxy *id;
+
+	id = wl_proxy_marshal_constructor(
+		(struct wl_proxy *) wl_registry, WL_REGISTRY_BIND,
+		interface, name, interface->name, version, NULL);
+
+	return (void *) id;
+}
+
+struct handler_info {
+	struct wl_seat *seat;
+	uint32_t bind_version;
+	bool use_unversioned;
+};
+
+static void
+registry_handle_globals(void *data, struct wl_registry *registry,
+			uint32_t id, const char *intf, uint32_t ver)
+{
+	struct handler_info *hi = data;
+
+	/* This is only for the proxy version test */
+	if (hi->bind_version)
+		ver = hi->bind_version;
+
+	if (strcmp(intf, "wl_seat") == 0) {
+		if (hi->use_unversioned)
+			hi->seat = old_registry_bind(registry, id,
+						     &wl_seat_interface, ver);
+		else
+			hi->seat = wl_registry_bind(registry, id,
+						    &wl_seat_interface, ver);
+		assert(hi->seat);
+	}
+}
+
+static const struct wl_registry_listener registry_listener = {
+	registry_handle_globals,
+	NULL
+};
+
+static struct wl_seat *
+client_get_seat_with_info(struct client *c, struct handler_info *hi)
+{
+	struct wl_registry *reg = wl_display_get_registry(c->wl_display);
+	assert(reg);
+
+	assert(hi);
+	hi->seat = NULL;
+	wl_registry_add_listener(reg, &registry_listener, hi);
+	wl_display_roundtrip(c->wl_display);
+	assert(hi->seat);
+
+	wl_registry_destroy(reg);
+
+	return hi->seat;
+}
+
+static struct wl_seat *
+client_get_seat(struct client *c)
+{
+	struct handler_info hi;
+
+	hi.use_unversioned = false;
+	hi.bind_version = 0;
+
+	return client_get_seat_with_info(c, &hi);
+}
+
+static void
+check_pending_error(struct client *c, struct wl_proxy *proxy)
+{
+	uint32_t ec, id;
+	int err;
+	const struct wl_interface *intf;
+
+	err = wl_display_get_error(c->wl_display);
+	assert(err == EPROTO);
+

_service:tar_scm:wayland-1.21.0.tar.gz/tests/event-loop-test.c Added

@@ -0,0 +1,555 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ * Copyright © 2012 Jason Ekstrand
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <stdint.h>
+#include <assert.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/time.h>
+
+#include "wayland-private.h"
+#include "wayland-server.h"
+#include "test-runner.h"
+
+static int
+fd_dispatch(int fd, uint32_t mask, void *data)
+{
+	int *p = data;
+
+	assert(mask == 0);
+	++(*p);
+
+	return 0;
+}
+
+TEST(event_loop_post_dispatch_check)
+{
+	struct wl_event_loop *loop = wl_event_loop_create();
+	struct wl_event_source *source;
+	int dispatch_ran = 0;
+	int p2;
+
+	assert(loop);
+	assert(pipe(p) == 0);
+
+	source = wl_event_loop_add_fd(loop, p0, WL_EVENT_READABLE,
+				      fd_dispatch, &dispatch_ran);
+	assert(source);
+	wl_event_source_check(source);
+
+	wl_event_loop_dispatch(loop, 0);
+	assert(dispatch_ran == 1);
+
+	assert(close(p0) == 0);
+	assert(close(p1) == 0);
+	wl_event_source_remove(source);
+	wl_event_loop_destroy(loop);
+}
+
+struct free_source_context {
+	struct wl_event_source *source1, *source2;
+	int p12, p22;
+	int count;
+};
+
+static int
+free_source_callback(int fd, uint32_t mask, void *data)
+{
+	struct free_source_context *context = data;
+
+	context->count++;
+
+	/* Remove other source */
+	if (fd == context->p10) {
+		wl_event_source_remove(context->source2);
+		context->source2 = NULL;
+	} else if (fd == context->p20) {
+		wl_event_source_remove(context->source1);
+		context->source1 = NULL;
+	} else {
+		assert(0);
+	}
+
+	return 1;
+}
+
+TEST(event_loop_free_source_with_data)
+{
+	struct wl_event_loop *loop = wl_event_loop_create();
+	struct free_source_context context;
+	int data;
+
+	/* This test is a little tricky to get right, since we don't
+	 * have any guarantee from the event loop (ie epoll) on the
+	 * order of which it reports events.  We want to have one
+	 * source free the other, but we don't know which one is going
+	 * to run first.  So we add two fd sources with a callback
+	 * that frees the other source and check that only one of them
+	 * run (and that we don't crash, of course).
+	 */
+
+	assert(loop);
+
+	context.count = 0;
+	assert(pipe(context.p1) == 0);
+	assert(pipe(context.p2) == 0);
+	context.source1 =
+		wl_event_loop_add_fd(loop, context.p10, WL_EVENT_READABLE,
+				     free_source_callback, &context);
+	assert(context.source1);
+	context.source2 =
+		wl_event_loop_add_fd(loop, context.p20, WL_EVENT_READABLE,
+				     free_source_callback, &context);
+	assert(context.source2);
+
+	data = 5;
+	assert(write(context.p11, &data, sizeof data) == sizeof data);
+	assert(write(context.p21, &data, sizeof data) == sizeof data);
+
+	wl_event_loop_dispatch(loop, 0);
+
+	assert(context.count == 1);
+
+	if (context.source1)
+		wl_event_source_remove(context.source1);
+	if (context.source2)
+		wl_event_source_remove(context.source2);
+	wl_event_loop_destroy(loop);
+
+	assert(close(context.p10) == 0);
+	assert(close(context.p11) == 0);
+	assert(close(context.p20) == 0);
+	assert(close(context.p21) == 0);
+}
+
+static int
+signal_callback(int signal_number, void *data)
+{
+	int *got_it = data;
+
+	assert(signal_number == SIGUSR1);
+	++(*got_it);
+
+	return 1;
+}
+
+TEST(event_loop_signal)
+{
+	struct wl_event_loop *loop = wl_event_loop_create();
+	struct wl_event_source *source;
+	int got_it = 0;
+
+	source = wl_event_loop_add_signal(loop, SIGUSR1,
+					  signal_callback, &got_it);
+	assert(source);
+
+	assert(wl_event_loop_dispatch(loop, 0) == 0);
+	assert(!got_it);
+	assert(kill(getpid(), SIGUSR1) == 0);
+	/*
+	 * On Linux the signal will be immediately visible in the epoll_wait()
+	 * call. However, on FreeBSD we may need a small delay between kill()
+	 * call and the signal being visible to the kevent() call. This
+	 * sometimes happens when the signal processing and kevent processing
+	 * runs on different CPUs, so becomes more likely when the system is
+	 * under load (e.g. running all tests in parallel).
+	 * See https://github.com/jiixyj/epoll-shim/pull/32
+	 * Passing 1ms as the timeout appears to avoid this race condition in
+	 * all cases tested so far, but to be safe we use 1000ms which should
+	 * be enough time even on a really slow (or emulated) system.
+	 */
+	assert(wl_event_loop_dispatch(loop, 1000) == 0);
+	assert(got_it == 1);
+
+	wl_event_source_remove(source);
+	wl_event_loop_destroy(loop);
+}
+
+TEST(event_loop_multiple_same_signals)
+{
+	struct wl_event_loop *loop = wl_event_loop_create();
+	struct wl_event_source *s1, *s2;
+	int calls_no = 0;
+	int i;

_service:tar_scm:wayland-1.21.0.tar.gz/tests/exec-fd-leak-checker.c Added

@@ -0,0 +1,78 @@
+/*
+ * Copyright © 2012 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <limits.h>
+
+#include "test-runner.h"
+
+static int
+parse_count(const char *str, int *value)
+{
+	char *end;
+	long v;
+
+	errno = 0;
+	v = strtol(str, &end, 10);
+	if ((errno == ERANGE && (v == LONG_MAX || v == LONG_MIN)) ||
+	    (errno != 0 && v == 0) ||
+	    (end == str) ||
+	    (*end != '\0')) {
+		return -1;
+	}
+
+	if (v < 0 || v > INT_MAX) {
+		return -1;
+	}
+
+	*value = v;
+	return 0;
+}
+
+int main(int argc, char *argv)
+{
+	int expected;
+
+	if (argc != 2)
+		goto help_out;
+
+	if (parse_count(argv1, &expected) < 0)
+		goto help_out;
+
+	if (count_open_fds() == expected)
+		return EXIT_SUCCESS;
+	else
+		return EXIT_FAILURE;
+
+help_out:
+	fprintf(stderr, "Usage: %s N\n"
+		"where N is the expected number of open file descriptors.\n"
+		"This program exits with a failure if the number "
+		"does not match exactly.\n", argv0);
+
+	return EXIT_FAILURE;
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/fixed-benchmark.c Added

@@ -0,0 +1,107 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+#include "wayland-private.h"
+
+volatile double global_d;
+
+static void
+noop_conversion(void)
+{
+	wl_fixed_t f;
+	union {
+		int64_t i;
+		double d;
+	} u;
+
+	for (f = 0; f < INT32_MAX; f++) {
+		u.i = f;
+		global_d = u.d;
+	}
+}
+
+static void
+magic_conversion(void)
+{
+	wl_fixed_t f;
+
+	for (f = 0; f < INT32_MAX; f++)
+		global_d = wl_fixed_to_double(f);
+}
+
+static void
+mul_conversion(void)
+{
+	wl_fixed_t f;
+
+	/* This will get optimized into multiplication by 1/256 */
+	for (f = 0; f < INT32_MAX; f++)
+		global_d = f / 256.0;
+}
+
+double factor = 256.0;
+
+static void
+div_conversion(void)
+{
+	wl_fixed_t f;
+
+	for (f = 0; f < INT32_MAX; f++)
+		global_d = f / factor;
+}
+
+static void
+benchmark(const char *s, void (*f)(void))
+{
+	struct timespec start, stop, elapsed;
+
+	clock_gettime(CLOCK_MONOTONIC, &start);
+	f();
+	clock_gettime(CLOCK_MONOTONIC, &stop);
+
+	elapsed.tv_sec = stop.tv_sec - start.tv_sec;
+	elapsed.tv_nsec = stop.tv_nsec - start.tv_nsec;
+	if (elapsed.tv_nsec < 0) {
+		elapsed.tv_nsec += 1000000000;
+		elapsed.tv_sec--;
+	}
+	printf("benchmarked %s:\t%ld.%09lds\n",
+	       s, elapsed.tv_sec, elapsed.tv_nsec);
+}
+
+int main(void)
+{
+	benchmark("noop", noop_conversion);
+	benchmark("magic", magic_conversion);
+	benchmark("div", div_conversion);
+	benchmark("mul", mul_conversion);
+
+	return 0;
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/fixed-test.c Added

@@ -0,0 +1,94 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include "wayland-private.h"
+#include "test-runner.h"
+
+TEST(fixed_double_conversions)
+{
+	wl_fixed_t f;
+	double d;
+
+	d = 62.125;
+	f = wl_fixed_from_double(d);
+	fprintf(stderr, "double %lf to fixed %x\n", d, f);
+	assert(f == 0x3e20);
+
+	d = -1200.625;
+	f = wl_fixed_from_double(d);
+	fprintf(stderr, "double %lf to fixed %x\n", d, f);
+	assert(f == -0x4b0a0);
+
+	f = random();
+	d = wl_fixed_to_double(f);
+	fprintf(stderr, "fixed %x to double %lf\n", f, d);
+	assert(d == f / 256.0);
+
+	f = 0x012030;
+	d = wl_fixed_to_double(f);
+	fprintf(stderr, "fixed %x to double %lf\n", f, d);
+	assert(d == 288.1875);
+
+	f = 0x70000000;
+	d = wl_fixed_to_double(f);
+	fprintf(stderr, "fixed %x to double %lf\n", f, d);
+	assert(d == f / 256);
+
+	f = -0x012030;
+	d = wl_fixed_to_double(f);
+	fprintf(stderr, "fixed %x to double %lf\n", f, d);
+	assert(d == -288.1875);
+
+	f = 0x80000000;
+	d = wl_fixed_to_double(f);
+	fprintf(stderr, "fixed %x to double %lf\n", f, d);
+	assert(d == f / 256);
+}
+
+TEST(fixed_int_conversions)
+{
+	wl_fixed_t f;
+	int i;
+
+	i = 62;
+	f = wl_fixed_from_int(i);
+	assert(f == 62 * 256);
+
+	i = -2080;
+	f = wl_fixed_from_int(i);
+	assert(f == -2080 * 256);
+
+	f = 0x277013;
+	i = wl_fixed_to_int(f);
+	assert(i == 0x2770);
+
+	f = -0x5044;
+	i = wl_fixed_to_int(f);
+	assert(i == -0x50);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/headers-protocol-core-test.c Added

@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2015 Giulio Camuffo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "wayland-client-protocol-core.h"
+#include "wayland-server-protocol-core.h"
+
+#ifndef WAYLAND_CLIENT_CORE_H
+#error including wayland-client-protocol-core.h did not include wayland-client-core.h!
+#endif
+#ifndef WAYLAND_SERVER_CORE_H
+#error including wayland-server-protocol-core.h did not include wayland-server-core.h!
+#endif
+
+#ifdef WAYLAND_CLIENT_H
+#error including wayland-client-protocol-core.h included wayland-client.h!
+#endif
+#ifdef WAYLAND_SERVER_H
+#error including wayland-server-protocol-core.h included wayland-server.h!
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/tests/headers-protocol-test.c Added

@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2015 Giulio Camuffo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "wayland-client-protocol.h"
+#include "wayland-server-protocol.h"
+
+#ifndef WAYLAND_CLIENT_H
+#error including wayland-client-protocol.h did not include wayland-client.h!
+#endif
+#ifndef WAYLAND_SERVER_H
+#error including wayland-server-protocol.h did not include wayland-server.h!
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/tests/headers-test.c Added

@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2015 Giulio Camuffo
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "wayland-client-core.h"
+#include "wayland-server-core.h"
+
+#ifdef WL_DISPLAY_SYNC
+#error including wayland-client-core.h imported protocol symbols!
+#endif
+#ifdef WL_DISPLAY_ERROR
+#error including wayland-server-core.h imported protocol symbols!
+#endif
+
+#ifdef WAYLAND_CLIENT_H
+#error including wayland-client-core.h included the non-core header!
+#endif
+#ifdef WAYLAND_SERVER_H
+#error including wayland-server-core.h included the non-core header!
+#endif
+
+#include "wayland-client.h"
+#include "wayland-server.h"
+
+#ifndef WL_DISPLAY_SYNC
+#error including wayland-client.h did not import protocol symbols!
+#endif
+#ifndef WL_DISPLAY_ERROR
+#error including wayland-server.h did not import protocol symbols!
+#endif
+
+int main(int argc, char **argv) { return 0; }

_service:tar_scm:wayland-1.21.0.tar.gz/tests/interface-test.c Added

@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2016 Yong Bakos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include "wayland-client.h"
+#include "wayland-private.h"
+#include "test-runner.h"
+
+TEST(interface_equal)
+{
+	const struct wl_interface fake = {
+		"fake", 1, 0, NULL, 0, NULL
+	};
+	const struct wl_interface fake_registry = {
+		"wl_registry", 1, 0, NULL, 0, NULL
+	};
+	const struct wl_interface copy = wl_registry_interface;
+
+	assert(&wl_registry_interface != &copy);
+
+	assert(wl_interface_equal(&wl_registry_interface,
+				  &wl_registry_interface));
+	assert(wl_interface_equal(&wl_registry_interface, &copy));
+	assert(wl_interface_equal(&wl_registry_interface,
+				  &fake_registry));
+	assert(!wl_interface_equal(&wl_registry_interface, &fake));
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/list-test.c Added

@@ -0,0 +1,179 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "wayland-private.h"
+#include "test-runner.h"
+
+TEST(list_init)
+{
+	struct wl_list list;
+
+	wl_list_init(&list);
+	assert(list.next == &list);
+	assert(list.prev == &list);
+	assert(wl_list_empty(&list));
+}
+
+struct element {
+	int i;
+	struct wl_list link;
+};
+
+TEST(list_insert)
+{
+	struct wl_list list;
+	struct element e;
+
+	wl_list_init(&list);
+	wl_list_insert(&list, &e.link);
+	assert(list.next == &e.link);
+	assert(list.prev == &e.link);
+	assert(e.link.next == &list);
+	assert(e.link.prev == &list);
+}
+
+TEST(list_length)
+{
+	struct wl_list list;
+	struct element e;
+
+	wl_list_init(&list);
+	assert(wl_list_length(&list) == 0);
+	wl_list_insert(&list, &e.link);
+	assert(wl_list_length(&list) == 1);
+	wl_list_remove(&e.link);
+	assert(wl_list_length(&list) == 0);
+}
+
+TEST(list_iterator)
+{
+	struct wl_list list;
+	struct element e1, e2, e3, e4, *e;
+	int reference = { 708090, 102030, 5588, 12 };
+	unsigned int i;
+
+	e1.i = 708090;
+	e2.i = 102030;
+	e3.i = 5588;
+	e4.i = 12;
+
+	wl_list_init(&list);
+	wl_list_insert(list.prev, &e1.link);
+	wl_list_insert(list.prev, &e2.link);
+	wl_list_insert(list.prev, &e3.link);
+	wl_list_insert(list.prev, &e4.link);
+
+	i = 0;
+	wl_list_for_each(e, &list, link) {
+		assert(i < ARRAY_LENGTH(reference));
+		assert(e->i == referencei);
+		i++;
+	}
+	assert(i == ARRAY_LENGTH(reference));
+
+	i = 0;
+	wl_list_for_each_reverse(e, &list, link) {
+		assert(i < ARRAY_LENGTH(reference));
+		assert(e->i == referenceARRAY_LENGTH(reference) - i - 1);
+		i++;
+	}
+	assert(i == ARRAY_LENGTH(reference));
+}
+
+static int
+validate_list(struct wl_list *list, int *reference, int length)
+{
+	struct element *e;
+	int i;
+
+	i = 0;
+	wl_list_for_each(e, list, link) {
+		if (i >= length)
+			return 0;
+		if (e->i != referencei)
+			return 0;
+		i++;
+	}
+
+	if (i != length)
+		return 0;
+
+	return 1;
+}
+
+TEST(list_remove)
+{
+	struct wl_list list;
+	struct element e1, e2, e3;
+	int reference1 = { 17, 8888, 1000 }, reference2 = { 17, 1000 };
+
+	e1.i = 17;
+	e2.i = 8888;
+	e3.i = 1000;
+
+	wl_list_init(&list);
+	wl_list_insert(&list, &e1.link);
+	wl_list_insert(list.prev, &e2.link);
+	wl_list_insert(list.prev, &e3.link);
+	assert(validate_list(&list, reference1, ARRAY_LENGTH(reference1)));
+
+	wl_list_remove(&e2.link);
+	assert(validate_list(&list, reference2, ARRAY_LENGTH(reference2)));
+}
+
+TEST(list_insert_list)
+{
+	struct wl_list list, other;
+	struct element e1, e2, e3, e4, e5, e6;
+	int reference1 = { 17, 8888, 1000 };
+	int reference2 = { 76543, 1, -500 };
+	int reference3 = { 17, 76543, 1, -500, 8888, 1000 };
+
+	e1.i = 17;
+	e2.i = 8888;
+	e3.i = 1000;
+
+	wl_list_init(&list);
+	wl_list_insert(&list, &e1.link);
+	wl_list_insert(list.prev, &e2.link);
+	wl_list_insert(list.prev, &e3.link);
+	assert(validate_list(&list, reference1, ARRAY_LENGTH(reference1)));
+
+	e4.i = 76543;
+	e5.i = 1;
+	e6.i = -500;
+
+	wl_list_init(&other);
+	wl_list_insert(&other, &e4.link);
+	wl_list_insert(other.prev, &e5.link);
+	wl_list_insert(other.prev, &e6.link);
+	assert(validate_list(&other, reference2, ARRAY_LENGTH(reference2)));
+
+	wl_list_insert_list(list.next, &other);
+	assert(validate_list(&list, reference3, ARRAY_LENGTH(reference3)));
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/map-test.c Added

@@ -0,0 +1,137 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <assert.h>
+#include "wayland-private.h"
+#include "test-runner.h"
+
+TEST(map_insert_new)
+{
+	struct wl_map map;
+	uint32_t i, j, k, a, b, c;
+
+	wl_map_init(&map, WL_MAP_SERVER_SIDE);
+	i = wl_map_insert_new(&map, 0, &a);
+	j = wl_map_insert_new(&map, 0, &b);
+	k = wl_map_insert_new(&map, 0, &c);
+	assert(i == WL_SERVER_ID_START);
+	assert(j == WL_SERVER_ID_START + 1);
+	assert(k == WL_SERVER_ID_START + 2);
+
+	assert(wl_map_lookup(&map, i) == &a);
+	assert(wl_map_lookup(&map, j) == &b);
+	assert(wl_map_lookup(&map, k) == &c);
+    wl_map_release(&map);
+
+	wl_map_init(&map, WL_MAP_CLIENT_SIDE);
+	i = wl_map_insert_new(&map, 0, &a);
+	assert(i == 0);
+	assert(wl_map_lookup(&map, i) == &a);
+
+	wl_map_release(&map);
+}
+
+TEST(map_insert_at)
+{
+	struct wl_map map;
+	uint32_t a, b, c;
+
+	wl_map_init(&map, WL_MAP_CLIENT_SIDE);
+	assert(wl_map_insert_at(&map, 0, WL_SERVER_ID_START, &a) == 0);
+	assert(wl_map_insert_at(&map, 0, WL_SERVER_ID_START + 3, &b) == -1);
+	assert(wl_map_insert_at(&map, 0, WL_SERVER_ID_START + 1, &c) == 0);
+
+	assert(wl_map_lookup(&map, WL_SERVER_ID_START) == &a);
+	assert(wl_map_lookup(&map, WL_SERVER_ID_START + 1) == &c);
+
+	wl_map_release(&map);
+}
+
+TEST(map_remove)
+{
+	struct wl_map map;
+	uint32_t i, j, k, l, a, b, c, d;
+
+	wl_map_init(&map, WL_MAP_SERVER_SIDE);
+	i = wl_map_insert_new(&map, 0, &a);
+	j = wl_map_insert_new(&map, 0, &b);
+	k = wl_map_insert_new(&map, 0, &c);
+	assert(i == WL_SERVER_ID_START);
+	assert(j == WL_SERVER_ID_START + 1);
+	assert(k == WL_SERVER_ID_START + 2);
+
+	assert(wl_map_lookup(&map, i) == &a);
+	assert(wl_map_lookup(&map, j) == &b);
+	assert(wl_map_lookup(&map, k) == &c);
+
+	wl_map_remove(&map, j);
+	assert(wl_map_lookup(&map, j) == NULL);
+
+	/* Verify that we insert d at the hole left by removing b */
+	l = wl_map_insert_new(&map, 0, &d);
+	assert(l == WL_SERVER_ID_START + 1);
+	assert(wl_map_lookup(&map, l) == &d);
+
+	wl_map_release(&map);
+}
+
+TEST(map_flags)
+{
+	struct wl_map map;
+	uint32_t i, j, a, b;
+
+	wl_map_init(&map, WL_MAP_SERVER_SIDE);
+	i = wl_map_insert_new(&map, 0, &a);
+	j = wl_map_insert_new(&map, 1, &b);
+	assert(i == WL_SERVER_ID_START);
+	assert(j == WL_SERVER_ID_START + 1);
+
+	assert(wl_map_lookup(&map, i) == &a);
+	assert(wl_map_lookup(&map, j) == &b);
+
+    assert(wl_map_lookup_flags(&map, i) == 0);
+    assert(wl_map_lookup_flags(&map, j) == 1);
+
+	wl_map_release(&map);
+}
+
+static enum wl_iterator_result never_run(void *element, void *data, uint32_t flags)
+{
+	assert(0);
+}
+
+TEST(map_iter_empty)
+{
+	struct wl_map map;
+
+	wl_map_init(&map, WL_MAP_SERVER_SIDE);
+
+	wl_map_for_each(&map, never_run, NULL);
+
+	wl_map_release(&map);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/meson.build Added

@@ -0,0 +1,172 @@
+if not get_option('libraries')
+	error('-Dtests=true requires -Dlibraries=true')
+endif
+
+test_runner = static_library(
+	'test-runner',
+	sources: 
+		'test-runner.c',
+		'test-helpers.c',
+		'test-compositor.c'
+	,
+	include_directories:  root_inc, src_inc ,
+	dependencies: 
+		cc.find_library('dl', required: false),
+		dependency('threads'),
+		epoll_dep,
+		ffi_dep,
+		wayland_util_dep,
+		wayland_private_dep,
+		wayland_client_dep,
+		wayland_server_dep
+	
+)
+
+test_runner_dep = declare_dependency(
+	link_with: test_runner,
+	include_directories:  src_inc ,
+	dependencies: 
+		dependency('threads'),
+		cc.find_library('dl', required: false)
+	
+)
+
+tests_protocol_xml = files('../protocol/tests.xml')
+
+tests_server_protocol_h = custom_target(
+	'test server protocol header',
+	command:  wayland_scanner_for_build, '-s', 'server-header', '@INPUT@', '@OUTPUT@' ,
+	input: tests_protocol_xml,
+	output: 'tests-server-protocol.h'
+)
+
+tests_client_protocol_c = custom_target(
+	'test client protocol header',
+	command:  wayland_scanner_for_build, '-s', 'client-header', '@INPUT@', '@OUTPUT@' ,
+	input: tests_protocol_xml,
+	output: 'tests-client-protocol.h'
+)
+
+tests_protocol_c = custom_target(
+	'test protocol source',
+	command:  wayland_scanner_for_build, '-s', 'public-code', '@INPUT@', '@OUTPUT@' ,
+	input: tests_protocol_xml,
+	output: 'tests-protocol.c'
+)
+
+benchmark(
+	'fixed-benchmark',
+	executable(
+		'fixed-benchmark',
+		'fixed-benchmark.c',
+		dependencies:  test_runner_dep, rt_dep 
+	)
+)
+
+executable(
+	'exec-fd-leak-checker',
+	'exec-fd-leak-checker.c',
+	dependencies: test_runner_dep
+)
+
+if add_languages('cpp', native: false)
+	test(
+		'cpp-compile-test',
+		executable(
+			'cpp-compile-test',
+			'cpp-compile-test.cpp',
+			wayland_server_protocol_h,
+			include_directories: src_inc
+		)
+	)
+endif
+
+sed_path = find_program('sed').full_path()
+
+if get_option('scanner')
+	test(
+		'scanner-test',
+		find_program('scanner-test.sh'),
+		env: 
+			'TEST_DATA_DIR=@0@/data'.format(meson.current_source_dir()),
+			'TEST_OUTPUT_DIR=@0@/output'.format(meson.current_build_dir()),
+			'SED=@0@'.format(sed_path),
+			'WAYLAND_SCANNER=@0@'.format(wayland_scanner.full_path()),
+		,
+	)
+endif
+
+tests = {
+	'array-test': ,
+	'client-test':  wayland_server_protocol_h ,
+	'display-test': 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+		tests_server_protocol_h,
+		tests_client_protocol_c,
+		tests_protocol_c,
+	,
+	'connection-test': 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+	,
+	'event-loop-test':  wayland_server_protocol_h ,
+	'fixed-test': ,
+	'interface-test':  wayland_client_protocol_h ,
+	'list-test': ,
+	'map-test': ,
+	'sanity-test' : 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+	,
+	'socket-test': 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+	,
+	'queue-test': 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+	,
+	'signal-test':  wayland_server_protocol_h ,
+	'newsignal-test': 
+		# wayland-server.c is needed here to access wl_priv_* functions
+		files('../src/wayland-server.c'),
+		wayland_server_protocol_h,
+	,
+	'resources-test':  wayland_server_protocol_h ,
+	'message-test': 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+	,
+	'compositor-introspection-test': 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+	,
+	'protocol-logger-test': 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+	,
+	'headers-test': 
+		wayland_client_protocol_h,
+		wayland_server_protocol_h,
+		'headers-protocol-test.c',
+		wayland_client_protocol_core_h,
+		wayland_server_protocol_core_h,
+		'headers-protocol-core-test.c',
+	,
+	'os-wrappers-test': ,
+}
+
+foreach test_name, test_extra_sources: tests
+	test_sources =  test_name + '.c'  + test_extra_sources
+	test_deps = test_runner_dep, epoll_dep
+	bin = executable(test_name, test_sources, dependencies: test_deps)
+	test(
+		test_name,
+		bin,
+		env: 
+			'TEST_SRC_DIR=@0@'.format(meson.current_source_dir()),
+			'TEST_BUILD_DIR=@0@'.format(meson.current_build_dir()),
+		,
+	)
+endforeach

_service:tar_scm:wayland-1.21.0.tar.gz/tests/message-test.c Added

@@ -0,0 +1,92 @@
+/*
+ * Copyright © 2014 Jonas Ådahl
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include "wayland-client.h"
+#include "wayland-private.h"
+#include "wayland-server.h"
+#include "test-runner.h"
+
+TEST(message_version)
+{
+	unsigned int i;
+	const struct {
+		const struct wl_message *message;
+		int expected_version;
+	} messages = {
+		{ &wl_pointer_interface.eventsWL_POINTER_ENTER, 1 },
+		{ &wl_surface_interface.eventsWL_SURFACE_ENTER, 1 },
+		{ &wl_pointer_interface.methodsWL_POINTER_SET_CURSOR, 1 },
+		{ &wl_pointer_interface.methodsWL_POINTER_RELEASE, 3 },
+		{ &wl_surface_interface.methodsWL_SURFACE_DESTROY, 1 },
+		{ &wl_surface_interface.methodsWL_SURFACE_SET_BUFFER_TRANSFORM, 2 },
+		{ &wl_surface_interface.methodsWL_SURFACE_SET_BUFFER_SCALE, 3 },
+	};
+
+	for (i = 0; i < ARRAY_LENGTH(messages); ++i) {
+		assert(wl_message_get_since(messagesi.message) ==
+		       messagesi.expected_version);
+	}
+}
+
+TEST(message_count_arrays)
+{
+	unsigned int i;
+	struct wl_message fake_messages = {
+		{ "empty", "", NULL },
+		{ "non_present", "iufsonh", NULL },
+		{ "leading", "aiufsonh", NULL},
+		{ "trailing", "iufsonha", NULL },
+		{ "middle", "iufasonh", NULL },
+		{ "multiple", "aaiufaasonhaa", NULL },
+		{ "leading_version", "2aaiufaasonhaa", NULL },
+		{ "among_nullables", "iufsa?oa?nah", NULL },
+		{ "nullable", "?aiufs?a?onh?a", NULL },
+		{ "all_mixed", "2?aiufas?oa?na", NULL },
+	};
+	const struct {
+		const struct wl_message *message;
+		int expected_array_count;
+	} messages = {
+		{ &wl_pointer_interface.eventsWL_POINTER_ENTER, 0 },
+		{ &wl_keyboard_interface.eventsWL_KEYBOARD_ENTER, 1 },
+		{ &fake_messages0, 0 },
+		{ &fake_messages1, 0 },
+		{ &fake_messages2, 1 },
+		{ &fake_messages3, 1 },
+		{ &fake_messages4, 1 },
+		{ &fake_messages5, 6 },
+		{ &fake_messages6, 6 },
+		{ &fake_messages7, 3 },
+		{ &fake_messages8, 3 },
+		{ &fake_messages9, 4 },
+	};
+
+	for (i = 0; i < ARRAY_LENGTH(messages); ++i) {
+		assert(wl_message_count_arrays(messagesi.message) ==
+		       messagesi.expected_array_count);
+	}
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/newsignal-test.c Added

@@ -0,0 +1,337 @@
+/*
+ * Copyright © 2013 Marek Chalupa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include "test-runner.h"
+#include "wayland-server-private.h"
+
+static void
+signal_notify(struct wl_listener *listener, void *data)
+{
+	/* only increase counter*/
+	++(*((int *) data));
+}
+
+TEST(signal_init)
+{
+	struct wl_priv_signal signal;
+
+	wl_priv_signal_init(&signal);
+
+	/* Test if listeners' list is initialized */
+	assert(&signal.listener_list == signal.listener_list.next
+		&& "Maybe wl_priv_signal implementation changed?");
+	assert(signal.listener_list.next == signal.listener_list.prev
+		&& "Maybe wl_priv_signal implementation changed?");
+}
+
+TEST(signal_add_get)
+{
+	struct wl_priv_signal signal;
+
+	/* we just need different values of notify */
+	struct wl_listener l1 = {.notify = (wl_notify_func_t) 0x1};
+	struct wl_listener l2 = {.notify = (wl_notify_func_t) 0x2};
+	struct wl_listener l3 = {.notify = (wl_notify_func_t) 0x3};
+	/* one real, why not */
+	struct wl_listener l4 = {.notify = signal_notify};
+
+	wl_priv_signal_init(&signal);
+
+	wl_priv_signal_add(&signal, &l1);
+	wl_priv_signal_add(&signal, &l2);
+	wl_priv_signal_add(&signal, &l3);
+	wl_priv_signal_add(&signal, &l4);
+
+	assert(wl_priv_signal_get(&signal, signal_notify) == &l4);
+	assert(wl_priv_signal_get(&signal, (wl_notify_func_t) 0x3) == &l3);
+	assert(wl_priv_signal_get(&signal, (wl_notify_func_t) 0x2) == &l2);
+	assert(wl_priv_signal_get(&signal, (wl_notify_func_t) 0x1) == &l1);
+
+	/* get should not be destructive */
+	assert(wl_priv_signal_get(&signal, signal_notify) == &l4);
+	assert(wl_priv_signal_get(&signal, (wl_notify_func_t) 0x3) == &l3);
+	assert(wl_priv_signal_get(&signal, (wl_notify_func_t) 0x2) == &l2);
+	assert(wl_priv_signal_get(&signal, (wl_notify_func_t) 0x1) == &l1);
+}
+
+TEST(signal_emit_to_one_listener)
+{
+	int count = 0;
+	int counter;
+
+	struct wl_priv_signal signal;
+	struct wl_listener l1 = {.notify = signal_notify};
+
+	wl_priv_signal_init(&signal);
+	wl_priv_signal_add(&signal, &l1);
+
+	for (counter = 0; counter < 100; counter++)
+		wl_priv_signal_emit(&signal, &count);
+
+	assert(counter == count);
+}
+
+TEST(signal_emit_to_more_listeners)
+{
+	int count = 0;
+	int counter;
+
+	struct wl_priv_signal signal;
+	struct wl_listener l1 = {.notify = signal_notify};
+	struct wl_listener l2 = {.notify = signal_notify};
+	struct wl_listener l3 = {.notify = signal_notify};
+
+	wl_priv_signal_init(&signal);
+	wl_priv_signal_add(&signal, &l1);
+	wl_priv_signal_add(&signal, &l2);
+	wl_priv_signal_add(&signal, &l3);
+
+	for (counter = 0; counter < 100; counter++)
+		wl_priv_signal_emit(&signal, &count);
+
+	assert(3 * counter == count);
+}
+
+struct signal
+{
+	struct wl_priv_signal signal;
+	struct wl_listener l1, l2, l3;
+	int count;
+	struct wl_listener *current;
+};
+
+static void notify_remove(struct wl_listener *l, void *data)
+{
+	struct signal *sig = data;
+	wl_list_remove(&sig->current->link);
+	wl_list_init(&sig->current->link);
+	sig->count++;
+}
+
+#define INIT \
+	wl_priv_signal_init(&signal.signal); \
+	wl_list_init(&signal.l1.link); \
+	wl_list_init(&signal.l2.link); \
+	wl_list_init(&signal.l3.link);
+#define CHECK_EMIT(expected) \
+	signal.count = 0; \
+	wl_priv_signal_emit(&signal.signal, &signal); \
+	assert(signal.count == expected);
+
+TEST(signal_remove_listener)
+{
+	test_set_timeout(4);
+
+	struct signal signal;
+
+	signal.l1.notify = notify_remove;
+	signal.l2.notify = notify_remove;
+	signal.l3.notify = notify_remove;
+
+	INIT
+	wl_priv_signal_add(&signal.signal, &signal.l1);
+
+	signal.current = &signal.l1;
+	CHECK_EMIT(1)
+	CHECK_EMIT(0)
+
+	INIT
+	wl_priv_signal_add(&signal.signal, &signal.l1);
+	wl_priv_signal_add(&signal.signal, &signal.l2);
+
+	CHECK_EMIT(2)
+	CHECK_EMIT(1)
+
+	INIT
+	wl_priv_signal_add(&signal.signal, &signal.l1);
+	wl_priv_signal_add(&signal.signal, &signal.l2);
+
+	signal.current = &signal.l2;
+	CHECK_EMIT(1)
+	CHECK_EMIT(1)
+
+	INIT
+	wl_priv_signal_add(&signal.signal, &signal.l1);
+	wl_priv_signal_add(&signal.signal, &signal.l2);
+	wl_priv_signal_add(&signal.signal, &signal.l3);
+
+	signal.current = &signal.l1;
+	CHECK_EMIT(3)
+	CHECK_EMIT(2)
+
+	INIT
+	wl_priv_signal_add(&signal.signal, &signal.l1);
+	wl_priv_signal_add(&signal.signal, &signal.l2);
+	wl_priv_signal_add(&signal.signal, &signal.l3);
+
+	signal.current = &signal.l2;
+	CHECK_EMIT(2)
+	CHECK_EMIT(2)
+
+	INIT
+	wl_priv_signal_add(&signal.signal, &signal.l1);
+	wl_priv_signal_add(&signal.signal, &signal.l2);
+	wl_priv_signal_add(&signal.signal, &signal.l3);
+

_service:tar_scm:wayland-1.21.0.tar.gz/tests/os-wrappers-test.c Added

@@ -0,0 +1,410 @@
+/*
+ * Copyright © 2012 Collabora, Ltd.
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include "../config.h"
+
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/epoll.h>
+
+#include "wayland-private.h"
+#include "test-runner.h"
+#include "wayland-os.h"
+
+static int fall_back;
+
+/* Play nice with sanitizers
+ *
+ * Sanitizers need to intercept syscalls in the compiler run-time library. As
+ * this isn't a separate ELF object, the usual dlsym(RTLD_NEXT) approach won't
+ * work: there can only be one function named "socket" etc. To support this, the
+ * sanitizer library names its interceptors with the prefix __interceptor_ ("__"
+ * being reserved for the implementation) and then weakly aliases it to the real
+ * function. The functions we define below will override the weak alias, and we
+ * can call them by the __interceptor_ name directly. This allows the sanitizer
+ * to do its work before calling the next version of the function via dlsym.
+ *
+ * However! We also don't know which of these functions the sanitizer actually
+ * wants to override, so we have to declare our own weak symbols for
+ * __interceptor_ and check at run time if they linked to anything or not.
+*/
+
+#define DECL(ret_type, func, ...) \
+	ret_type __interceptor_ ## func(__VA_ARGS__) __attribute__((weak)); \
+	static ret_type (*real_ ## func)(__VA_ARGS__);			\
+	static int wrapped_calls_ ## func;
+
+#define REAL(func) (__interceptor_ ## func) ?				\
+	__interceptor_ ## func :					\
+	(__typeof__(&__interceptor_ ## func))dlsym(RTLD_NEXT, #func)
+
+DECL(int, socket, int, int, int);
+DECL(int, fcntl, int, int, ...);
+DECL(ssize_t, recvmsg, int, struct msghdr *, int);
+DECL(int, epoll_create1, int);
+
+static void
+init_fallbacks(int do_fallbacks)
+{
+	fall_back = do_fallbacks;
+	real_socket = REAL(socket);
+	real_fcntl = REAL(fcntl);
+	real_recvmsg = REAL(recvmsg);
+	real_epoll_create1 = REAL(epoll_create1);
+}
+
+__attribute__ ((visibility("default"))) int
+socket(int domain, int type, int protocol)
+{
+	wrapped_calls_socket++;
+
+	if (fall_back && (type & SOCK_CLOEXEC)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	return real_socket(domain, type, protocol);
+}
+
+__attribute__ ((visibility("default"))) int
+(fcntl)(int fd, int cmd, ...)
+{
+	va_list ap;
+	int arg;
+	int has_arg;
+
+	wrapped_calls_fcntl++;
+
+	if (fall_back && (cmd == F_DUPFD_CLOEXEC)) {
+		errno = EINVAL;
+		return -1;
+	}
+	switch (cmd) {
+	case F_DUPFD_CLOEXEC:
+	case F_DUPFD:
+	case F_SETFD:
+		va_start(ap, cmd);
+		arg = va_arg(ap, int);
+		has_arg = 1;
+		va_end(ap);
+		break;
+	case F_GETFD:
+		has_arg = 0;
+		break;
+	default:
+		fprintf(stderr, "Unexpected fctnl cmd %d\n", cmd);
+		abort();
+	}
+
+	if (has_arg) {
+		return real_fcntl(fd, cmd, arg);
+	}
+	return real_fcntl(fd, cmd);
+}
+
+__attribute__ ((visibility("default"))) ssize_t
+recvmsg(int sockfd, struct msghdr *msg, int flags)
+{
+	wrapped_calls_recvmsg++;
+
+	if (fall_back && (flags & MSG_CMSG_CLOEXEC)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	return real_recvmsg(sockfd, msg, flags);
+}
+
+__attribute__ ((visibility("default"))) int
+epoll_create1(int flags)
+{
+	wrapped_calls_epoll_create1++;
+
+	if (fall_back) {
+		wrapped_calls_epoll_create1++; /* epoll_create() not wrapped */
+		errno = EINVAL;
+		return -1;
+	}
+
+	return real_epoll_create1(flags);
+}
+
+static void
+do_os_wrappers_socket_cloexec(int n)
+{
+	int fd;
+	int nr_fds;
+
+	nr_fds = count_open_fds();
+
+	/* simply create a socket that closes on exec */
+	fd = wl_os_socket_cloexec(PF_LOCAL, SOCK_STREAM, 0);
+	assert(fd >= 0);
+
+	/*
+	 * Must have 2 calls if falling back, but must also allow
+	 * falling back without a forced fallback.
+	 */
+	assert(wrapped_calls_socket > n);
+
+	exec_fd_leak_check(nr_fds);
+}
+
+TEST(os_wrappers_socket_cloexec)
+{
+	/* normal case */
+	init_fallbacks(0);
+	do_os_wrappers_socket_cloexec(0);
+}
+
+TEST(os_wrappers_socket_cloexec_fallback)
+{
+	/* forced fallback */
+	init_fallbacks(1);
+	do_os_wrappers_socket_cloexec(1);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/protocol-logger-test.c Added

@@ -0,0 +1,148 @@
+/*
+ * Copyright © 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "wayland-client.h"
+#include "wayland-server.h"
+#include "test-runner.h"
+
+/* Ensure the connection doesn't fail due to lack of XDG_RUNTIME_DIR. */
+static const char *
+require_xdg_runtime_dir(void)
+{
+	char *val = getenv("XDG_RUNTIME_DIR");
+	assert(val && val0 == '/' && "set $XDG_RUNTIME_DIR to run this test");
+
+	return val;
+}
+
+struct compositor {
+	struct wl_display *display;
+	struct wl_event_loop *loop;
+	int message;
+	struct wl_client *client;
+};
+
+struct message {
+	enum wl_protocol_logger_type type;
+	const char *class;
+	int opcode;
+	const char *message_name;
+	int args_count;
+} messages = {
+	{
+		.type = WL_PROTOCOL_LOGGER_REQUEST,
+		.class = "wl_display",
+		.opcode = 0,
+		.message_name = "sync",
+		.args_count = 1,
+	},
+	{
+		.type = WL_PROTOCOL_LOGGER_EVENT,
+		.class = "wl_callback",
+		.opcode = 0,
+		.message_name = "done",
+		.args_count = 1,
+	},
+	{
+		.type = WL_PROTOCOL_LOGGER_EVENT,
+		.class = "wl_display",
+		.opcode = 1,
+		.message_name = "delete_id",
+		.args_count = 1,
+	},
+};
+
+static void
+logger_func(void *user_data, enum wl_protocol_logger_type type,
+	    const struct wl_protocol_logger_message *message)
+{
+	struct compositor *c = user_data;
+	struct message *msg = &messagesc->message++;
+
+	assert(msg->type == type);
+	assert(strcmp(msg->class, wl_resource_get_class(message->resource)) == 0);
+	assert(msg->opcode == message->message_opcode);
+	assert(strcmp(msg->message_name, message->message->name) == 0);
+	assert(msg->args_count == message->arguments_count);
+
+	c->client = wl_resource_get_client(message->resource);
+}
+
+static void
+callback_done(void *data, struct wl_callback *cb, uint32_t time)
+{
+	wl_callback_destroy(cb);
+}
+
+static const struct wl_callback_listener callback_listener = {
+	callback_done,
+};
+
+TEST(logger)
+{
+	test_set_timeout(1);
+
+	const char *socket;
+	struct compositor compositor = { 0 };
+	struct {
+		struct wl_display *display;
+		struct wl_callback *cb;
+	} client;
+	struct wl_protocol_logger *logger;
+
+	require_xdg_runtime_dir();
+
+	compositor.display = wl_display_create();
+	compositor.loop = wl_display_get_event_loop(compositor.display);
+	socket = wl_display_add_socket_auto(compositor.display);
+
+	logger = wl_display_add_protocol_logger(compositor.display,
+						logger_func, &compositor);
+
+	client.display = wl_display_connect(socket);
+	client.cb = wl_display_sync(client.display);
+	wl_callback_add_listener(client.cb, &callback_listener, NULL);
+	wl_display_flush(client.display);
+
+	while (compositor.message < 3) {
+		wl_event_loop_dispatch(compositor.loop, -1);
+		wl_display_flush_clients(compositor.display);
+	}
+
+	wl_display_dispatch(client.display);
+	wl_display_disconnect(client.display);
+
+	wl_client_destroy(compositor.client);
+	wl_protocol_logger_destroy(logger);
+	wl_display_destroy(compositor.display);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/proxy-test.c Added

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2019 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <assert.h>
+#include <string.h>
+
+#include "wayland-server.h"
+#include "wayland-client.h"
+#include "test-runner.h"
+
+static struct {
+	struct wl_display *display;
+	struct wl_event_loop *loop;
+	int sync_count;
+} server;
+
+static struct {
+	struct wl_display *display;
+	struct wl_callback *callback_a;
+	struct wl_callback *callback_b;
+	int callback_count;
+} client;
+
+static const char *tag_a = "tag";
+static const char *tag_b = "tag";
+
+static void
+callback_done(void *data, struct wl_callback *cb, uint32_t time)
+{
+	const char * const *expected_tag;
+	const char * const *tag;
+
+	if (cb == client.callback_a)
+		expected_tag = &tag_a;
+	else if (cb == client.callback_b)
+		expected_tag = &tag_b;
+	else
+		assert(!"unexpected callback");
+
+	tag = wl_proxy_get_tag((struct wl_proxy *) cb);
+
+	assert(tag == expected_tag);
+	assert(strcmp(*tag, "tag") == 0);
+
+	wl_callback_destroy(cb);
+
+	client.callback_count++;
+}
+
+static const struct wl_callback_listener callback_listener = {
+	callback_done,
+};
+
+static void
+logger_func(void *user_data,
+	    enum wl_protocol_logger_type type,
+	    const struct wl_protocol_logger_message *message)
+{
+	if (type != WL_PROTOCOL_LOGGER_REQUEST)
+		return;
+
+	assert(strcmp(wl_resource_get_class(message->resource),
+		      "wl_display") == 0);
+	assert(strcmp(message->message->name, "sync") == 0);
+
+	server.sync_count++;
+}
+
+TEST(proxy_tag)
+{
+	const char *socket;
+	struct wl_protocol_logger *logger;
+
+	assert(&tag_a != &tag_b);
+
+	server.display = wl_display_create();
+	assert(server.display);
+	server.loop = wl_display_get_event_loop(server.display);
+	assert(server.loop);
+	socket = wl_display_add_socket_auto(server.display);
+	assert(socket);
+	logger = wl_display_add_protocol_logger(server.display,
+						logger_func, NULL);
+	assert(logger);
+
+	client.display = wl_display_connect(socket);
+	assert(client.display);
+
+	client.callback_a = wl_display_sync(client.display);
+	wl_callback_add_listener(client.callback_a, &callback_listener, NULL);
+	wl_proxy_set_tag((struct wl_proxy *) client.callback_a,
+			 &tag_a);
+
+	client.callback_b = wl_display_sync(client.display);
+	wl_callback_add_listener(client.callback_b, &callback_listener, NULL);
+	wl_proxy_set_tag((struct wl_proxy *) client.callback_b,
+			 &tag_b);
+
+	wl_display_flush(client.display);
+
+	while (server.sync_count < 2) {
+		wl_event_loop_dispatch(server.loop, -1);
+		wl_display_flush_clients(server.display);
+	}
+
+	wl_display_dispatch(client.display);
+
+	assert(client.callback_count == 2);
+
+	wl_protocol_logger_destroy(logger);
+	wl_display_disconnect(client.display);
+	wl_event_loop_dispatch(server.loop, 100);
+
+	wl_display_destroy(server.display);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/queue-test.c Added

@@ -0,0 +1,384 @@
+/*
+ * Copyright © 2012 Jonas Ådahl
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <assert.h>
+
+#include "wayland-client.h"
+#include "wayland-server.h"
+#include "test-runner.h"
+#include "test-compositor.h"
+
+#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)0)
+
+static void
+registry_handle_global(void *data, struct wl_registry *registry,
+		       uint32_t id, const char *interface, uint32_t version)
+{
+	int *pcounter = data;
+	(*pcounter)++;
+	assert(*pcounter == 1);
+	wl_registry_destroy(registry);
+}
+
+static const struct wl_registry_listener registry_listener = {
+	registry_handle_global,
+	NULL
+};
+
+/* Test that destroying a proxy object doesn't result in any more
+ * callback being invoked, even though were many queued. */
+static void
+client_test_proxy_destroy(void)
+{
+	struct wl_display *display;
+	struct wl_registry *registry;
+	int counter = 0;
+
+	display = wl_display_connect(NULL);
+	assert(display);
+
+	registry = wl_display_get_registry(display);
+	assert(registry != NULL);
+	wl_registry_add_listener(registry, &registry_listener,
+				 &counter);
+	assert(wl_display_roundtrip(display) != -1);
+
+	assert(counter == 1);
+
+	/* don't destroy the registry, we have already destroyed them
+	 * in the global handler */
+	wl_display_disconnect(display);
+}
+
+struct multiple_queues_state {
+	struct wl_display *display;
+	struct wl_callback* callback2;
+	bool done;
+};
+
+static void
+sync_callback(void *data, struct wl_callback *callback, uint32_t serial)
+{
+	struct multiple_queues_state *state = data;
+
+	state->done = true;
+	wl_callback_destroy(callback);
+
+	wl_display_dispatch_pending(state->display);
+
+	wl_callback_destroy(state->callback2);
+}
+
+static const struct wl_callback_listener sync_listener = {
+	sync_callback
+};
+
+/* Test that when receiving the first of two synchronization
+ * callback events, destroying the second one doesn't cause any
+ * errors even if the delete_id event is handled out of order. */
+static void
+client_test_multiple_queues(void)
+{
+	struct wl_event_queue *queue;
+	struct wl_callback *callback1;
+	struct multiple_queues_state state;
+	int ret = 0;
+
+	state.display = wl_display_connect(NULL);
+	assert(state.display);
+
+	queue = wl_display_create_queue(state.display);
+	assert(queue);
+
+	state.done = false;
+	callback1 = wl_display_sync(state.display);
+	assert(callback1 != NULL);
+	wl_callback_add_listener(callback1, &sync_listener, &state);
+	wl_proxy_set_queue((struct wl_proxy *) callback1, queue);
+
+	state.callback2 = wl_display_sync(state.display);
+	assert(state.callback2 != NULL);
+	wl_callback_add_listener(state.callback2, &sync_listener, NULL);
+	wl_proxy_set_queue((struct wl_proxy *) state.callback2, queue);
+
+	wl_display_flush(state.display);
+
+	while (!state.done && !ret)
+		ret = wl_display_dispatch_queue(state.display, queue);
+
+	wl_event_queue_destroy(queue);
+	wl_display_disconnect(state.display);
+
+	exit(ret == -1 ? -1 : 0);
+}
+
+static void
+sync_callback_roundtrip(void *data, struct wl_callback *callback, uint32_t serial)
+{
+	bool *done = data;
+	*done = true;
+}
+
+static const struct wl_callback_listener sync_listener_roundtrip = {
+	sync_callback_roundtrip
+};
+
+/* Test that doing a roundtrip on a queue only the events on that
+ * queue get dispatched. */
+static void
+client_test_queue_roundtrip(void)
+{
+	struct wl_event_queue *queue;
+	struct wl_callback *callback1;
+	struct wl_callback *callback2;
+	struct wl_display *display;
+	bool done1 = false;
+	bool done2 = false;
+
+	display = wl_display_connect(NULL);
+	assert(display);
+
+	queue = wl_display_create_queue(display);
+	assert(queue);
+
+	/* arm a callback on the default queue */
+	callback1 = wl_display_sync(display);
+	assert(callback1 != NULL);
+	wl_callback_add_listener(callback1, &sync_listener_roundtrip, &done1);
+
+	/* arm a callback on the other queue */
+	callback2 = wl_display_sync(display);
+	assert(callback2 != NULL);
+	wl_callback_add_listener(callback2, &sync_listener_roundtrip, &done2);
+	wl_proxy_set_queue((struct wl_proxy *) callback2, queue);
+
+	/* roundtrip on default queue must not dispatch the other queue. */
+	wl_display_roundtrip(display);
+	assert(done1 == true);
+	assert(done2 == false);
+
+	/* re-arm the sync callback on the default queue, so we see that
+	 * wl_display_roundtrip_queue() does not dispatch the default queue. */
+	wl_callback_destroy(callback1);
+	done1 = false;
+	callback1 = wl_display_sync(display);
+	assert(callback1 != NULL);
+	wl_callback_add_listener(callback1, &sync_listener_roundtrip, &done1);
+
+	wl_display_roundtrip_queue(display, queue);
+	assert(done1 == false);
+	assert(done2 == true);

_service:tar_scm:wayland-1.21.0.tar.gz/tests/resources-test.c Added

@@ -0,0 +1,208 @@
+/*
+ * Copyright © 2013 Marek Chalupa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <assert.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <stdint.h>
+
+#include "wayland-server.h"
+#include "test-runner.h"
+
+TEST(create_resource_tst)
+{
+	struct wl_display *display;
+	struct wl_client *client;
+	struct wl_resource *res;
+	struct wl_list *link;
+	int s2;
+	uint32_t id;
+
+	assert(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, s) == 0);
+	display = wl_display_create();
+	assert(display);
+	client = wl_client_create(display, s0);
+	assert(client);
+
+	res = wl_resource_create(client, &wl_seat_interface, 4, 0);
+	assert(res);
+
+	/* setters/getters */
+	assert(wl_resource_get_version(res) == 4);
+
+	assert(client == wl_resource_get_client(res));
+	id = wl_resource_get_id(res);
+	assert(wl_client_get_object(client, id) == res);
+
+	link = wl_resource_get_link(res);
+	assert(link);
+	assert(wl_resource_from_link(link) == res);
+
+	wl_resource_set_user_data(res, (void *) 0xbee);
+	assert(wl_resource_get_user_data(res) == (void *) 0xbee);
+
+	wl_resource_destroy(res);
+	wl_client_destroy(client);
+	wl_display_destroy(display);
+	close(s1);
+}
+
+static void
+res_destroy_func(struct wl_resource *res)
+{
+	assert(res);
+
+	_Bool *destr = wl_resource_get_user_data(res);
+	*destr = 1;
+}
+
+static _Bool notify_called = 0;
+static void
+destroy_notify(struct wl_listener *l, void *data)
+{
+	assert(l && data);
+	notify_called = 1;
+
+	/* In real code it's common to free the structure holding the
+	 * listener at this point, but not to remove it from the list.
+	 *
+	 * That's fine since this is a destruction notification and
+	 * it's the last time this signal can fire.  We set these
+	 * to NULL so we can check them later to ensure no write after
+	 * "free" occurred.
+	 */
+	l->link.prev = NULL;
+	l->link.next = NULL;
+}
+
+TEST(destroy_res_tst)
+{
+	struct wl_display *display;
+	struct wl_client *client;
+	struct wl_resource *res;
+	int s2;
+	unsigned id;
+	struct wl_list *link;
+
+	_Bool destroyed = 0;
+	struct wl_listener destroy_listener = {
+		.notify = &destroy_notify
+	};
+
+	assert(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, s) == 0);
+	display = wl_display_create();
+	assert(display);
+	client = wl_client_create(display, s0);
+	assert(client);
+
+	res = wl_resource_create(client, &wl_seat_interface, 4, 0);
+	assert(res);
+	wl_resource_set_implementation(res, NULL, &destroyed, res_destroy_func);
+	wl_resource_add_destroy_listener(res, &destroy_listener);
+
+	id = wl_resource_get_id(res);
+	link = wl_resource_get_link(res);
+	assert(link);
+
+	wl_resource_destroy(res);
+	assert(destroyed);
+	assert(notify_called); /* check if signal was emitted */
+	assert(wl_client_get_object(client, id) == NULL);
+	assert(destroy_listener.link.prev == NULL);
+	assert(destroy_listener.link.next == NULL);
+
+	res = wl_resource_create(client, &wl_seat_interface, 2, 0);
+	assert(res);
+	destroyed = 0;
+	notify_called = 0;
+	wl_resource_set_destructor(res, res_destroy_func);
+	wl_resource_set_user_data(res, &destroyed);
+	wl_resource_add_destroy_listener(res, &destroy_listener);
+	/* client should destroy the resource upon its destruction */
+	wl_client_destroy(client);
+	assert(destroyed);
+	assert(notify_called);
+	assert(destroy_listener.link.prev == NULL);
+	assert(destroy_listener.link.next == NULL);
+
+	wl_display_destroy(display);
+	close(s1);
+}
+
+TEST(create_resource_with_same_id)
+{
+	struct wl_display *display;
+	struct wl_client *client;
+	struct wl_resource *res, *res2;
+	int s2;
+	uint32_t id;
+
+	assert(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, s) == 0);
+	display = wl_display_create();
+	assert(display);
+	client = wl_client_create(display, s0);
+	assert(client);
+
+	res = wl_resource_create(client, &wl_seat_interface, 2, 0);
+	assert(res);
+	id = wl_resource_get_id(res);
+	assert(wl_client_get_object(client, id) == res);
+
+	/* this one should replace the old one */
+	res2 = wl_resource_create(client, &wl_seat_interface, 1, id);
+	assert(res2 != NULL);
+	assert(wl_client_get_object(client, id) == res2);
+
+	wl_resource_destroy(res2);
+	wl_resource_destroy(res);
+
+	wl_client_destroy(client);
+	wl_display_destroy(display);
+	close(s1);
+}
+
+static void
+display_destroy_notify(struct wl_listener *l, void *data)
+{
+	l->link.prev = l->link.next = NULL;
+}
+
+TEST(free_without_remove)
+{
+	struct wl_display *display;
+	struct wl_listener a, b;
+
+	display = wl_display_create();
+	a.notify = display_destroy_notify;
+	b.notify = display_destroy_notify;

_service:tar_scm:wayland-1.21.0.tar.gz/tests/sanity-test.c Added

@@ -0,0 +1,250 @@
+/*
+ * Copyright © 2012 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include "test-runner.h"
+#include "wayland-util.h"
+#include "wayland-private.h"
+
+#include "test-compositor.h"
+
+extern int fd_leak_check_enabled;
+
+TEST(empty)
+{
+}
+
+TEST(exit_success)
+{
+	exit(EXIT_SUCCESS);
+}
+
+FAIL_TEST(exit_failure)
+{
+	exit(EXIT_FAILURE);
+}
+
+FAIL_TEST(fail_abort)
+{
+	test_disable_coredumps();
+	abort();
+}
+
+FAIL_TEST(fail_wl_abort)
+{
+	test_disable_coredumps();
+	wl_abort("Abort the program\n");
+}
+
+FAIL_TEST(fail_kill)
+{
+	kill(getpid(), SIGTERM);
+}
+
+FAIL_TEST(fail_segv)
+{
+	char * volatile *null = 0;
+
+	test_disable_coredumps();
+	*null = "Goodbye, world";
+}
+
+FAIL_TEST(sanity_assert)
+{
+	test_disable_coredumps();
+	/* must fail */
+	assert(0);
+}
+
+FAIL_TEST(sanity_fd_leak)
+{
+	int fd2;
+
+	assert(fd_leak_check_enabled);
+
+	/* leak 2 file descriptors */
+	if (pipe(fd) < 0)
+		exit(EXIT_SUCCESS); /* failed to fail */
+
+	test_disable_coredumps();
+}
+
+FAIL_TEST(sanity_fd_leak_exec)
+{
+	int fd2;
+	int nr_fds = count_open_fds();
+
+	/* leak 2 file descriptors */
+	if (pipe(fd) < 0)
+		exit(EXIT_SUCCESS); /* failed to fail */
+
+	test_disable_coredumps();
+	exec_fd_leak_check(nr_fds);
+}
+
+TEST(sanity_fd_exec)
+{
+	int fd2;
+	int nr_fds = count_open_fds();
+
+	/* create 2 file descriptors, that should pass over exec */
+	assert(pipe(fd) >= 0);
+
+	exec_fd_leak_check(nr_fds + 2);
+}
+
+static void
+sanity_fd_no_leak(void)
+{
+	int fd2;
+
+	assert(fd_leak_check_enabled);
+
+	/* leak 2 file descriptors */
+	if (pipe(fd) < 0)
+		exit(EXIT_SUCCESS); /* failed to fail */
+
+	close(fd0);
+	close(fd1);
+}
+
+static void
+sanity_client_no_leak(void)
+{
+	struct wl_display *display = wl_display_connect(NULL);
+	assert(display);
+
+	wl_display_disconnect(display);
+}
+
+TEST(tc_client_no_fd_leaks)
+{
+	struct display *d = display_create();
+
+	/* Client which does not consume the WAYLAND_DISPLAY socket. */
+	client_create_noarg(d, sanity_fd_no_leak);
+	display_run(d);
+
+	/* Client which does consume the WAYLAND_DISPLAY socket. */
+	client_create_noarg(d, sanity_client_no_leak);
+	display_run(d);
+
+	display_destroy(d);
+}
+
+FAIL_TEST(tc_client_fd_leaks)
+{
+	struct display *d = display_create();
+
+	client_create_noarg(d, sanity_fd_leak);
+	display_run(d);
+
+	test_disable_coredumps();
+	display_destroy(d);
+}
+
+FAIL_TEST(tc_client_fd_leaks_exec)
+{
+	struct display *d = display_create();
+
+	client_create_noarg(d, sanity_fd_leak_exec);
+	display_run(d);
+
+	test_disable_coredumps();
+	display_destroy(d);
+}
+
+FAIL_TEST(timeout_tst)
+{
+	test_set_timeout(1);
+	test_disable_coredumps();
+	/* test should reach timeout */
+	test_sleep(2);
+}
+
+TEST(timeout2_tst)
+{
+	/* the test should end before reaching timeout,
+	 * thus it should pass */
+	test_set_timeout(1);
+	/* 200 000 microsec = 0.2 sec */
+	test_usleep(200000);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/scanner-test.sh Added

@@ -0,0 +1,78 @@
+#!/bin/sh
+
+echo "srcdir: $srcdir"
+echo "scanner: $WAYLAND_SCANNER"
+echo "test_data_dir: $TEST_DATA_DIR"
+echo "test_output_dir: $TEST_OUTPUT_DIR"
+echo "pwd: $PWD"
+echo "sed: $SED"
+
+RETCODE=0
+
+hard_fail() {
+	echo "$@" "ERROR"
+	exit 99
+}
+
+fail() {
+	echo "$@" "FAIL"
+	RETCODE=1
+}
+
+mkdir -p "$TEST_OUTPUT_DIR" || hard_fail "setup"
+
+generate_and_compare() {
+	echo
+	echo "Testing $1 generation: $2 -> $3"
+
+	"$WAYLAND_SCANNER" $1 < "$TEST_DATA_DIR/$2" > "$TEST_OUTPUT_DIR/$3" || \
+		hard_fail "$2 -> $3"
+
+	"$SED" -i -e 's/Generated by wayland-scanner 0-9.*/SCANNER TEST/' \
+		"$TEST_OUTPUT_DIR/$3" || hard_fail "$2 -> $3"
+
+	diff -q "$TEST_DATA_DIR/$3" "$TEST_OUTPUT_DIR/$3" && \
+		echo "$2 -> $3 PASS" || \
+		fail "$2 -> $3"
+}
+
+verify_error() {
+	echo
+	echo "Checking that reading $1 gives an error on line $3"
+
+	 -f "$TEST_DATA_DIR/$1"  || hard_fail "$1 not present"
+
+	# Confirm failure error code
+	"$WAYLAND_SCANNER" server-header < "$TEST_DATA_DIR/$1" >/dev/null 2>"$TEST_OUTPUT_DIR/$2" && \
+		fail "$1 return code check"
+
+	# Verify that an error is produced at the correct line
+	grep -q "<stdin>:$3: error:" "$TEST_OUTPUT_DIR/$2" && echo "$1 PASS" || fail "$1 line number check"
+}
+
+generate_and_compare "code" "example.xml" "example-code.c"
+generate_and_compare "client-header" "example.xml" "example-client.h"
+generate_and_compare "server-header" "example.xml" "example-server.h"
+
+generate_and_compare "code" "small.xml" "small-code.c"
+generate_and_compare "client-header" "small.xml" "small-client.h"
+generate_and_compare "server-header" "small.xml" "small-server.h"
+
+generate_and_compare "-c code" "small.xml" "small-code-core.c"
+generate_and_compare "-c client-header" "small.xml" "small-client-core.h"
+generate_and_compare "-c server-header" "small.xml" "small-server-core.h"
+
+# The existing "code" must produce result identical to "public-code"
+generate_and_compare "code" "small.xml" "small-code.c"
+generate_and_compare "public-code" "small.xml" "small-code.c"
+generate_and_compare "private-code" "small.xml" "small-private-code.c"
+
+verify_error "bad-identifier-arg.xml" "bad-identifier-arg.log" 7
+verify_error "bad-identifier-entry.xml" "bad-identifier-entry.log" 8
+verify_error "bad-identifier-enum.xml" "bad-identifier-enum.log" 6
+verify_error "bad-identifier-event.xml" "bad-identifier-event.log" 6
+verify_error "bad-identifier-interface.xml" "bad-identifier-interface.log" 3
+verify_error "bad-identifier-protocol.xml" "bad-identifier-protocol.log" 2
+verify_error "bad-identifier-request.xml" "bad-identifier-request.log" 6
+
+exit $RETCODE

_service:tar_scm:wayland-1.21.0.tar.gz/tests/signal-test.c Added

@@ -0,0 +1,158 @@
+/*
+ * Copyright © 2013 Marek Chalupa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include "wayland-server.h"
+#include "test-runner.h"
+
+static void
+signal_notify(struct wl_listener *listener, void *data)
+{
+	/* only increase counter*/
+	++(*((int *) data));
+}
+
+TEST(signal_init)
+{
+	struct wl_signal signal;
+
+	wl_signal_init(&signal);
+
+	/* Test if listeners' list is initialized */
+	assert(&signal.listener_list == signal.listener_list.next
+		&& "Maybe wl_signal implementation changed?");
+	assert(signal.listener_list.next == signal.listener_list.prev
+		&& "Maybe wl_signal implementation changed?");
+}
+
+TEST(signal_add_get)
+{
+	struct wl_signal signal;
+
+	/* we just need different values of notify */
+	struct wl_listener l1 = {.notify = (wl_notify_func_t) 0x1};
+	struct wl_listener l2 = {.notify = (wl_notify_func_t) 0x2};
+	struct wl_listener l3 = {.notify = (wl_notify_func_t) 0x3};
+	/* one real, why not */
+	struct wl_listener l4 = {.notify = signal_notify};
+
+	wl_signal_init(&signal);
+
+	wl_signal_add(&signal, &l1);
+	wl_signal_add(&signal, &l2);
+	wl_signal_add(&signal, &l3);
+	wl_signal_add(&signal, &l4);
+
+	assert(wl_signal_get(&signal, signal_notify) == &l4);
+	assert(wl_signal_get(&signal, (wl_notify_func_t) 0x3) == &l3);
+	assert(wl_signal_get(&signal, (wl_notify_func_t) 0x2) == &l2);
+	assert(wl_signal_get(&signal, (wl_notify_func_t) 0x1) == &l1);
+
+	/* get should not be destructive */
+	assert(wl_signal_get(&signal, signal_notify) == &l4);
+	assert(wl_signal_get(&signal, (wl_notify_func_t) 0x3) == &l3);
+	assert(wl_signal_get(&signal, (wl_notify_func_t) 0x2) == &l2);
+	assert(wl_signal_get(&signal, (wl_notify_func_t) 0x1) == &l1);
+}
+
+TEST(signal_emit_to_one_listener)
+{
+	int count = 0;
+	int counter;
+
+	struct wl_signal signal;
+	struct wl_listener l1 = {.notify = signal_notify};
+
+	wl_signal_init(&signal);
+	wl_signal_add(&signal, &l1);
+
+	for (counter = 0; counter < 100; counter++)
+		wl_signal_emit(&signal, &count);
+
+	assert(counter == count);
+}
+
+TEST(signal_emit_to_more_listeners)
+{
+	int count = 0;
+	int counter;
+
+	struct wl_signal signal;
+	struct wl_listener l1 = {.notify = signal_notify};
+	struct wl_listener l2 = {.notify = signal_notify};
+	struct wl_listener l3 = {.notify = signal_notify};
+
+	wl_signal_init(&signal);
+	wl_signal_add(&signal, &l1);
+	wl_signal_add(&signal, &l2);
+	wl_signal_add(&signal, &l3);
+
+	for (counter = 0; counter < 100; counter++)
+		wl_signal_emit(&signal, &count);
+
+	assert(3 * counter == count);
+}
+
+struct signal_emit_mutable_data {
+	int count;
+	struct wl_listener *remove_listener;
+};
+
+static void
+signal_notify_mutable(struct wl_listener *listener, void *data)
+{
+	struct signal_emit_mutable_data *test_data = data;
+	test_data->count++;
+}
+
+static void
+signal_notify_and_remove_mutable(struct wl_listener *listener, void *data)
+{
+	struct signal_emit_mutable_data *test_data = data;
+	signal_notify_mutable(listener, test_data);
+	wl_list_remove(&test_data->remove_listener->link);
+}
+
+TEST(signal_emit_mutable)
+{
+	struct signal_emit_mutable_data data = {0};
+
+	/* l2 will remove l3 before l3 is notified */
+	struct wl_signal signal;
+	struct wl_listener l1 = {.notify = signal_notify_mutable};
+	struct wl_listener l2 = {.notify = signal_notify_and_remove_mutable};
+	struct wl_listener l3 = {.notify = signal_notify_mutable};
+
+	wl_signal_init(&signal);
+	wl_signal_add(&signal, &l1);
+	wl_signal_add(&signal, &l2);
+	wl_signal_add(&signal, &l3);
+
+	data.remove_listener = &l3;
+	wl_signal_emit_mutable(&signal, &data);
+
+	assert(data.count == 2);
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/socket-test.c Added

@@ -0,0 +1,289 @@
+/*
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "wayland-client.h"
+#include "wayland-os.h"
+#include "wayland-server.h"
+#include "test-runner.h"
+
+/* Paths longer than what the .sun_path array can contain must be rejected.
+ * This is a hard limitation of assigning a name to AF_UNIX/AF_LOCAL sockets.
+ * See `man 7 unix`.
+ */
+
+static struct sockaddr_un example_sockaddr_un;
+
+#define TOO_LONG (1 + sizeof example_sockaddr_un.sun_path)
+
+/* Ensure the connection doesn't fail due to lack of XDG_RUNTIME_DIR. */
+static const char *
+require_xdg_runtime_dir(void)
+{
+	char *val = getenv("XDG_RUNTIME_DIR");
+	assert(val && val0 == '/' && "set $XDG_RUNTIME_DIR to run this test");
+
+	return val;
+}
+
+TEST(socket_path_overflow_client_connect)
+{
+	char pathTOO_LONG;
+	struct wl_display *d;
+
+	require_xdg_runtime_dir();
+
+	memset(path, 'a', sizeof path);
+	pathsizeof path - 1 = '\0';
+
+	d = wl_display_connect(path);
+	assert(d == NULL);
+	assert(errno == ENAMETOOLONG);
+
+	/* This is useless, but prevents a warning about example_sockaddr_un
+	 * being discarded from the compilation unit. */
+	strcpy(example_sockaddr_un.sun_path, "happy now clang?");
+	assert(example_sockaddr_un.sun_path0 != '\0');
+}
+
+TEST(socket_path_overflow_server_create)
+{
+	char pathTOO_LONG;
+	struct wl_display *d;
+	int ret;
+
+	require_xdg_runtime_dir();
+
+	memset(path, 'a', sizeof path);
+	pathsizeof path - 1 = '\0';
+
+	d = wl_display_create();
+	assert(d != NULL);
+
+	ret = wl_display_add_socket(d, path);
+	assert(ret < 0);
+	assert(errno == ENAMETOOLONG);
+
+	wl_display_destroy(d);
+}
+
+TEST(add_existing_socket)
+{
+	char pathsizeof example_sockaddr_un.sun_path;
+	const char *name = "wayland-test-0";
+	const char *xdg_runtime_dir;
+	struct wl_display *d;
+	int ret;
+	size_t len;
+
+	xdg_runtime_dir = require_xdg_runtime_dir();
+
+	d = wl_display_create();
+	assert(d != NULL);
+
+	/* this one should be OK */
+	ret = wl_display_add_socket(d, name);
+	assert(ret == 0);
+
+	/* this one should fail */
+	ret = wl_display_add_socket(d, name);
+	assert(ret < 0);
+
+	/* the original socket should still exist.
+	 * this was a bug introduced in e2c0d47b0c77f18cd90e9c6eabb358c4d89681c8 */
+	len = snprintf(path, sizeof example_sockaddr_un.sun_path, "%s/%s",
+		       xdg_runtime_dir, name);
+	assert(len < sizeof example_sockaddr_un.sun_path
+	       && "Bug in test. Path too long");
+
+	assert(access(path, F_OK) != -1);
+
+	/* the original socket should still exist */
+	ret = wl_display_add_socket(d, name);
+	assert(ret < 0);
+
+	wl_display_destroy(d);
+}
+
+TEST(add_socket_auto)
+{
+	/* the number of auto sockets is currently 32,
+	 * set in wayland-server.c.
+	 */
+	const int MAX_SOCKETS = 32;
+
+	char pathsizeof example_sockaddr_un.sun_path;
+	const char *name;
+	const char *xdg_runtime_dir;
+	struct wl_display *d;
+	int i;
+	size_t len;
+
+	xdg_runtime_dir = require_xdg_runtime_dir();
+
+	d = wl_display_create();
+	assert(d != NULL);
+
+	for (i = 0; i <= MAX_SOCKETS; ++i) {
+		name = wl_display_add_socket_auto(d);
+		assert(name != NULL);
+
+		len = snprintf(path, sizeof example_sockaddr_un.sun_path,
+			       "%s/%s", xdg_runtime_dir, name);
+		assert(len < sizeof example_sockaddr_un.sun_path
+		       && "Bug in test. Path too long");
+
+		/* was the socket created correctly? */
+		assert(access(path, F_OK) != -1);
+
+		/* is the name sequential? */
+		len = snprintf(path, sizeof example_sockaddr_un.sun_path,
+			       "wayland-%d", i);
+		assert(strcmp(name, path) == 0);
+	}
+
+	/* next addition should return NULL */
+	name = wl_display_add_socket_auto(d);
+	assert(name == NULL);
+
+	/* check if the socket was not deleted the last time */
+	name = wl_display_add_socket_auto(d);
+	assert(name == NULL);
+
+	wl_display_destroy(d);
+}
+
+struct client_create_listener {
+	struct wl_listener listener;
+	struct wl_display *display;
+};
+
+struct client_destroy_listener {
+	struct wl_listener listener;
+	struct wl_display *display;
+};
+
+static void
+client_destroy_notify(struct wl_listener *l, void *data)
+{
+	struct client_destroy_listener *listener =

_service:tar_scm:wayland-1.21.0.tar.gz/tests/test-compositor.c Added

@@ -0,0 +1,535 @@
+/*
+ * Copyright (c) 2014 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+#define WL_HIDE_DEPRECATED
+
+#include "test-runner.h"
+#include "test-compositor.h"
+
+/* --- Protocol --- */
+struct test_compositor;
+
+static const struct wl_message tc_requests = {
+	/* this request serves as a barrier for synchronizing*/
+	{ "stop_display", "u", NULL },
+	{ "noop", "", NULL },
+};
+
+static const struct wl_message tc_events = {
+	{ "display_resumed", "", NULL }
+};
+
+const struct wl_interface test_compositor_interface = {
+	"test", 1,
+	2, tc_requests,
+	1, tc_events
+};
+
+struct test_compositor_interface {
+	void (*stop_display)(struct wl_client *client,
+			     struct wl_resource *resource,
+			     uint32_t num);
+	void (*noop)(struct wl_client *client,
+			     struct wl_resource *resource);
+};
+
+struct test_compositor_listener {
+	void (*display_resumed)(void *data, struct test_compositor *tc);
+
+};
+
+enum {
+	STOP_DISPLAY = 0,
+	TEST_NOOP = 1
+};
+
+enum {
+	DISPLAY_RESUMED = 0
+};
+
+/* Since tests can run parallelly, we need unique socket names
+ * for each test, otherwise the test can fail on wl_display_add_socket. */
+static const char *
+get_socket_name(void)
+{
+	struct timeval tv;
+	static char retval64;
+
+	gettimeofday(&tv, NULL);
+	snprintf(retval, sizeof retval, "wayland-test-%d-%ld%ld",
+		 getpid(), tv.tv_sec, tv.tv_usec);
+
+	return retval;
+}
+
+static void
+handle_client_destroy(void *data)
+{
+	struct client_info *ci = data;
+	struct display *d;
+	siginfo_t status;
+
+	d = ci->display;
+
+	assert(waitid(P_PID, ci->pid, &status, WEXITED) != -1);
+
+	switch (status.si_code) {
+	case CLD_KILLED:
+	case CLD_DUMPED:
+		fprintf(stderr, "Client '%s' was killed by signal %d\n",
+			ci->name, status.si_status);
+		ci->exit_code = status.si_status;
+		break;
+	case CLD_EXITED:
+		if (status.si_status != EXIT_SUCCESS)
+			fprintf(stderr, "Client '%s' exited with code %d\n",
+				ci->name, status.si_status);
+
+		ci->exit_code = status.si_status;
+		break;
+	}
+
+	++d->clients_terminated_no;
+	if (d->clients_no == d->clients_terminated_no) {
+		wl_display_terminate(d->wl_display);
+	}
+
+	/* the clients are not removed from the list, because
+	 * at the end of the test we check the exit codes of all
+	 * clients. In the case that the test would go through
+	 * the clients list manually, zero out the wl_client as a sign
+	 * that the client is not running anymore */
+}
+
+/**
+ * Check client's state and terminate display when all clients exited
+ */
+static void
+client_destroyed(struct wl_listener *listener, void *data)
+{
+	struct client_info *ci;
+	struct display *d;
+	struct wl_event_loop *loop;
+
+	/* Wait for client in an idle handler to avoid blocking the actual
+	 * client destruction (fd close etc. */
+	ci = wl_container_of(listener, ci, destroy_listener);
+	d = ci->display;
+	loop = wl_display_get_event_loop(d->wl_display);
+	wl_event_loop_add_idle(loop, handle_client_destroy, ci);
+
+	ci->wl_client = NULL;
+}
+
+static void
+run_client(void (*client_main)(void *data), void *data,
+	   int wayland_sock, int client_pipe)
+{
+	char s8;
+	int cur_fds;
+	int can_continue = 0;
+
+	/* Wait until display signals that client can continue */
+	assert(read(client_pipe, &can_continue, sizeof(int)) == sizeof(int));
+
+	if (can_continue == 0)
+		abort(); /* error in parent */
+
+	/* for wl_display_connect() */
+	snprintf(s, sizeof s, "%d", wayland_sock);
+	setenv("WAYLAND_SOCKET", s, 0);
+
+	cur_fds = count_open_fds();
+
+	client_main(data);
+
+	/* Clients using wl_display_connect() will end up closing the socket
+	 * passed in through the WAYLAND_SOCKET environment variable. When
+	 * doing this, it clears the environment variable, so if it's been
+	 * unset, then we assume the client consumed the file descriptor and
+	 * do not count it towards leak checking. */
+	if (!getenv("WAYLAND_SOCKET"))
+		cur_fds--;
+
+	check_fd_leaks(cur_fds);
+}
+
+static struct client_info *
+display_create_client(struct display *d,
+		      void (*client_main)(void *data),
+		      void *data,
+		      const char *name)
+{
+	int pipe_cli2;
+	int sock_wayl2;
+	pid_t pid;

_service:tar_scm:wayland-1.21.0.tar.gz/tests/test-compositor.h Added

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2014 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdint.h>
+#include <unistd.h>
+#include <stdatomic.h>
+
+#include "wayland-server.h"
+#include "wayland-client.h"
+
+/* info about a client on server side */
+struct client_info {
+	struct display *display;
+	struct wl_client *wl_client;
+	struct wl_listener destroy_listener;
+	const char *name; /* for debugging */
+
+	int pipe;
+	pid_t pid;
+	int exit_code;
+
+	struct wl_list link;
+	void *data; /* for arbitrary use */
+};
+
+struct display {
+	struct wl_display *wl_display;
+	struct wl_global *test_global;
+
+	struct wl_list clients;
+	uint32_t clients_no;
+	uint32_t clients_terminated_no;
+
+	/* list of clients waiting for display_resumed event */
+	struct wl_list waiting_for_resume;
+	uint32_t wfr_num;
+};
+
+/* This is a helper structure for clients.
+ * Instead of calling wl_display_connect() and all the other stuff,
+ * client can use client_connect and it will return this structure
+ * filled. */
+struct client {
+	struct wl_display *wl_display;
+	struct test_compositor *tc;
+
+	atomic_bool display_stopped;
+};
+
+struct client *client_connect(void);
+void client_disconnect(struct client *);
+int stop_display(struct client *, int);
+void noop_request(struct client *);
+
+/**
+ * Usual workflow:
+ *
+ *    d = display_create();
+ *
+ *    wl_global_create(d->wl_display, ...);
+ *    ... other setups ...
+ *
+ *    client_create(d, client_main, data);
+ *    client_create(d, client_main2, data);
+ *
+ *    display_run(d);
+ *    display_destroy(d);
+ */
+struct display *display_create(void);
+void display_destroy(struct display *d);
+void display_run(struct display *d);
+
+/* This function posts the display_resumed event to all waiting clients,
+ * so that after flushing events the clients will stop waiting and continue.
+ *
+ * (Calling `display_run` after this function will resume the display loop.)
+ */
+void display_post_resume_events(struct display *d);
+/* After n clients called stop_display(..., n), the display
+ * is stopped and can process the code after display_run().
+ *
+ * This function posts the display_resumed event to the waiting
+ * clients, so that the clients will stop waiting and continue;
+ * it then reruns the display. */
+void display_resume(struct display *d);
+
+
+struct client_info *client_create_with_name(struct display *d,
+					    void (*client_main)(void *data),
+					    void *data,
+					    const char *name);
+#define client_create(d, c, data) client_create_with_name((d), (c), data, (#c))
+#define client_create_noarg(d, c) \
+	client_create_with_name((d), (void(*)(void *)) (c), NULL, (#c))

_service:tar_scm:wayland-1.21.0.tar.gz/tests/test-helpers.c Added

@@ -0,0 +1,164 @@
+/*
+ * Copyright © 2012 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#ifdef HAVE_SYS_PRCTL_H
+#include <sys/prctl.h>
+#endif
+
+#include "test-runner.h"
+
+#if defined(__FreeBSD__)
+#include <sys/sysctl.h>
+
+/*
+ * On FreeBSD, get file descriptor information using sysctl() since that does
+ * not depend on a mounted fdescfs (which provides /dev/fd/N for N > 2).
+ */
+int
+count_open_fds(void)
+{
+	int error;
+	int nfds;
+	int mib4 = {CTL_KERN, KERN_PROC, KERN_PROC_NFDS, 0 };
+	size_t len;
+
+	len = sizeof(nfds);
+	error = sysctl(mib, 4, &nfds, &len, NULL, 0);
+	assert(error == 0 && "sysctl KERN_PROC_NFDS failed.");
+	return nfds;
+}
+#else
+int
+count_open_fds(void)
+{
+	DIR *dir;
+	struct dirent *ent;
+	int count = 0;
+
+	/*
+	 * Using /dev/fd instead of /proc/self/fd should allow this code to
+	 * work on non-Linux operating systems.
+	 */
+	dir = opendir("/dev/fd");
+	assert(dir && "opening /dev/fd failed.");
+
+	errno = 0;
+	while ((ent = readdir(dir))) {
+		const char *s = ent->d_name;
+		if (s0 == '.' && (s1 == 0 || (s1 == '.' && s2 == 0)))
+			continue;
+		count++;
+	}
+	assert(errno == 0 && "reading /dev/fd failed.");
+
+	closedir(dir);
+
+	return count;
+}
+#endif
+
+void
+exec_fd_leak_check(int nr_expected_fds)
+{
+	const char *exe = "exec-fd-leak-checker";
+	char number16 = { 0 };
+	const char *test_build_dir = getenv("TEST_BUILD_DIR");
+	char exe_path256 = { 0 };
+
+	if (test_build_dir == NULL || test_build_dir0 == 0) {
+	        test_build_dir = ".";
+	}
+
+	snprintf(exe_path, sizeof exe_path - 1, "%s/%s", test_build_dir, exe);
+
+	snprintf(number, sizeof number - 1, "%d", nr_expected_fds);
+	execl(exe_path, exe, number, (char *)NULL);
+	assert(0 && "execing fd leak checker failed");
+}
+
+#define USEC_TO_NSEC(n) (1000 * (n))
+
+/* our implementation of usleep and sleep functions that are safe to use with
+ * timeouts (timeouts are implemented using alarm(), so it is not safe use
+ * usleep and sleep. See man pages of these functions)
+ */
+void
+test_usleep(useconds_t usec)
+{
+	struct timespec ts = {
+		.tv_sec = 0,
+		.tv_nsec = USEC_TO_NSEC(usec)
+	};
+
+	assert(nanosleep(&ts, NULL) == 0);
+}
+
+/* we must write the whole function instead of
+ * wrapping test_usleep, because useconds_t may not
+ * be able to contain such a big number of microseconds */
+void
+test_sleep(unsigned int sec)
+{
+	struct timespec ts = {
+		.tv_sec = sec,
+		.tv_nsec = 0
+	};
+
+	assert(nanosleep(&ts, NULL) == 0);
+}
+
+/** Try to disable coredumps
+ *
+ * Useful for tests that crash on purpose, to avoid creating a core file
+ * or launching an application crash handler service or cluttering coredumpctl.
+ *
+ * NOTE: Calling this may make the process undebuggable.
+ */
+void
+test_disable_coredumps(void)
+{
+	struct rlimit r;
+
+	if (getrlimit(RLIMIT_CORE, &r) == 0) {
+		r.rlim_cur = 0;
+		setrlimit(RLIMIT_CORE, &r);
+	}
+
+#if defined(HAVE_PRCTL) && defined(PR_SET_DUMPABLE)
+	prctl(PR_SET_DUMPABLE, 0, 0, 0, 0);
+#endif
+}

_service:tar_scm:wayland-1.21.0.tar.gz/tests/test-runner.c Added

@@ -0,0 +1,414 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include "../config.h"
+
+#define _GNU_SOURCE
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <assert.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <sys/ptrace.h>
+#ifdef HAVE_SYS_PROCCTL_H
+#include <sys/procctl.h>
+#elif defined(HAVE_SYS_PRCTL_H)
+#include <sys/prctl.h>
+#ifndef PR_SET_PTRACER
+# define PR_SET_PTRACER 0x59616d61
+#endif
+#endif
+
+#include "test-runner.h"
+
+/* when set to 1, check if tests are not leaking opened files.
+ * It is turned on by default. It can be turned off by
+ * WAYLAND_TEST_NO_LEAK_CHECK environment variable. */
+int fd_leak_check_enabled;
+
+/* when this var is set to 0, every call to test_set_timeout() is
+ * suppressed - handy when debugging the test. Can be set by
+ * WAYLAND_TEST_NO_TIMEOUTS environment variable. */
+static int timeouts_enabled = 1;
+
+/* set to one if the output goes to the terminal */
+static int is_atty = 0;
+
+extern const struct test __start_test_section, __stop_test_section;
+
+static const struct test *
+find_test(const char *name)
+{
+	const struct test *t;
+
+	for (t = &__start_test_section; t < &__stop_test_section; t++)
+		if (strcmp(t->name, name) == 0)
+			return t;
+
+	return NULL;
+}
+
+static void
+usage(const char *name, int status)
+{
+	const struct test *t;
+
+	fprintf(stderr, "Usage: %s TEST\n\n"
+		"With no arguments, run all test.  Specify test case to run\n"
+		"only that test without forking.  Available tests:\n\n",
+		name);
+
+	for (t = &__start_test_section; t < &__stop_test_section; t++)
+		fprintf(stderr, "  %s\n", t->name);
+
+	fprintf(stderr, "\n");
+
+	exit(status);
+}
+
+void
+test_set_timeout(unsigned int to)
+{
+	int re;
+
+	if (!timeouts_enabled) {
+		fprintf(stderr, "Timeouts suppressed.\n");
+		return;
+	}
+
+	re = alarm(to);
+	fprintf(stderr, "Timeout was %sset", re ? "re-" : "");
+
+	if (to != 0)
+		fprintf(stderr, " to %d second%s from now.\n",
+			to, to > 1 ? "s" : "");
+	else
+		fprintf(stderr, " off.\n");
+}
+
+static void
+sigalrm_handler(int signum)
+{
+	fprintf(stderr, "Test timed out.\n");
+	abort();
+}
+
+void
+check_fd_leaks(int supposed_fds)
+{
+	int num_fds;
+
+	if (fd_leak_check_enabled) {
+		num_fds = count_open_fds();
+		if (supposed_fds != num_fds) {
+			fprintf(stderr, "fd leak detected in test. "
+				"Opened %d files, unclosed %d\n", num_fds,
+				num_fds - supposed_fds);
+			abort();
+		}
+	} else {
+		fprintf(stderr, "FD leak checks disabled\n");
+	}
+}
+
+static void
+run_test(const struct test *t)
+{
+	int cur_fds;
+	struct sigaction sa;
+
+	if (timeouts_enabled) {
+		sa.sa_handler = sigalrm_handler;
+		sa.sa_flags = 0;
+		sigemptyset(&sa.sa_mask);
+		assert(sigaction(SIGALRM, &sa, NULL) == 0);
+	}
+
+	//cur_alloc = get_current_alloc_num();
+	cur_fds = count_open_fds();
+
+	t->run();
+
+	/* turn off timeout (if any) after test completion */
+	if (timeouts_enabled)
+		alarm(0);
+
+	check_fd_leaks(cur_fds);
+
+	exit(EXIT_SUCCESS);
+}
+
+#ifndef PATH_MAX
+#define PATH_MAX 256
+#endif
+
+static void
+set_xdg_runtime_dir(void)
+{
+	char xdg_runtime_dirPATH_MAX;
+	const char *xrd_env;
+
+	xrd_env = getenv("XDG_RUNTIME_DIR");
+	/* if XDG_RUNTIME_DIR is not set in environ, fallback to /tmp */
+	assert((snprintf(xdg_runtime_dir, PATH_MAX, "%s/wayland-tests-XXXXXX",
+			 (xrd_env && xrd_env0 == '/') ? xrd_env : "/tmp") < PATH_MAX)
+		&& "test error: XDG_RUNTIME_DIR too long");
+
+	assert(mkdtemp(xdg_runtime_dir) && "test error: mkdtemp failed");
+	if (mkdir(xdg_runtime_dir, 0700) == -1)
+		if (errno != EEXIST) {
+			perror("Creating XDG_RUNTIME_DIR");
+			abort();
+		}
+
+	if (setenv("XDG_RUNTIME_DIR", xdg_runtime_dir, 1) == -1) {
+		perror("Setting XDG_RUNTIME_DIR");
+		abort();
+	}
+}
+
+static void

_service:tar_scm:wayland-1.21.0.tar.gz/tests/test-runner.h Added

@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef _TEST_RUNNER_H_
+#define _TEST_RUNNER_H_
+
+#ifdef NDEBUG
+#error "Tests must not be built with NDEBUG defined, they rely on assert()."
+#endif
+
+#include <unistd.h>
+
+struct test {
+	const char *name;
+	void (*run)(void);
+	int must_fail;
+} __attribute__ ((aligned (16)));
+
+#define TEST(name)							\
+	static void name(void);						\
+									\
+	const struct test test##name					\
+		 __attribute__ ((used, section ("test_section"))) = {	\
+		#name, name, 0						\
+	};								\
+									\
+	static void name(void)
+
+#define FAIL_TEST(name)							\
+	static void name(void);						\
+									\
+	const struct test test##name					\
+		 __attribute__ ((used, section ("test_section"))) = {	\
+		#name, name, 1						\
+	};								\
+									\
+	static void name(void)
+
+int
+count_open_fds(void);
+
+void
+exec_fd_leak_check(int nr_expected_fds); /* never returns */
+
+void
+check_fd_leaks(int supposed_fds);
+
+/*
+ * set/reset the timeout in seconds. The timeout starts
+ * at the point of invoking this function
+ */
+void
+test_set_timeout(unsigned int);
+
+/* test-runner uses alarm() and SIGALRM, so we can not
+ * use usleep and sleep functions in tests (see 'man usleep'
+ * or 'man sleep', respectively). Following functions are safe
+ * to use in tests */
+void
+test_usleep(useconds_t);
+
+void
+test_sleep(unsigned int);
+
+void
+test_disable_coredumps(void);
+
+#define DISABLE_LEAK_CHECKS				\
+	do {						\
+		extern int fd_leak_check_enabled;	\
+		fd_leak_check_enabled = 0;		\
+	} while (0);
+
+#endif

_service:tar_scm:wayland-1.21.0.tar.gz/wayland-scanner.m4 Added

_service:tar_scm:wayland-1.21.0.tar.gz/wayland-scanner.mk Added

_service:tar_scm:wayland-1648452085.d0c3026.tar/wayland-1.20.0.tar.xz Deleted

_service:tar_scm:wayland-1648452085.d0c3026.tar/wayland.spec Deleted

_service:tar_scm:wayland-1648452085.d0c3026.tar/wayland.yaml Deleted

_service:tar_scm:wayland.yaml Added