File gnome-remote-desktop-40.2.obscpio of Package gnome-remote-desktop

Overview Repositories Revisions Requests Users Attributes Meta

File gnome-remote-desktop-40.2.obscpio of Package gnome-remote-desktop (Revision c0a6a08948bbee2add3b86dc6af8d30c)

Currently displaying revision c0a6a08948bbee2add3b86dc6af8d30c , Show latest

07070100000000000081A40000000000000000000000016141EE1000000010000000000000000000000000000000000000002500000000gnome-remote-desktop-40.2/.gitignoreconfig.h
build/
07070100000001000041ED0000000000000000000000016141EE1000000000000000000000000000000000000000000000002500000000gnome-remote-desktop-40.2/.gitlab-ci07070100000002000081A40000000000000000000000016141EE10000009AB000000000000000000000000000000000000002900000000gnome-remote-desktop-40.2/.gitlab-ci.ymlinclude:
  - remote: 'https://gitlab.freedesktop.org/freedesktop/ci-templates/-/raw/8445ff7af2a68795afb98f486251f2ef8f90621c/templates/fedora.yml'

stages:
  - prepare
  - build
  - test

.gnome-remote-desktop.fedora:33@common:
  variables:
    FDO_DISTRIBUTION_VERSION: 34
    BASE_TAG: '2021-03-26.0'
    FDO_UPSTREAM_REPO: GNOME/gnome-remote-desktop
    FDO_DISTRIBUTION_EXEC: |
      dnf -y update && dnf -y upgrade &&

dnf install -y 'dnf-command(builddep)' &&

# To build
      dnf install -y meson &&
      dnf builddep -y gnome-remote-desktop &&

# To test
      dnf install -y 'pkgconfig(libvncclient)' &&
      dnf remove -y pipewire0.2-devel pipewire0.2-libs &&
      dnf install -y 'pkgconfig(libpipewire-0.3)' &&
      dnf install -y 'pkgconfig(fuse3)' &&
      dnf install -y dbus-daemon xorg-x11-server-Xvfb python3-dbus \
                     python3-gobject gnome-settings-daemon mesa-dri-drivers \
                     xorg-x11-server-Xwayland mutter &&

dnf clean all

.gnome-remote-desktop.fedora:33@x86_64:
  extends: .gnome-remote-desktop.fedora:33@common
  variables:
    FDO_DISTRIBUTION_TAG: "x86_64-${BASE_TAG}"

default:
  # Cancel jobs if newer commits are pushed to the branch
  interruptible: true
  # Auto-retry jobs in case of infra failures
  retry:
    max: 1
    when:
      - 'runner_system_failure'
      - 'stuck_or_timeout_failure'
      - 'scheduler_failure'
      - 'api_failure'

build-fedora-container@x86_64:
  extends:
    - .fdo.container-build@fedora@x86_64
    - .gnome-remote-desktop.fedora:33@x86_64
  stage: prepare
  variables:
    GIT_STRATEGY: none

build-gnome-remote-desktop:
  extends:
    - .fdo.distribution-image@fedora
    - .gnome-remote-desktop.fedora:33@x86_64
  stage: build
  script:
    - meson . build -Ddebugtype=debugoptimized --werror
    - ninja -C build
    - ninja -C build install
  needs:
    - build-fedora-container@x86_64
  artifacts:
    expire_in: 1 day
    paths:
      - build

test-gnome-remote-desktop:
  extends:
    - .fdo.distribution-image@fedora
    - .gnome-remote-desktop.fedora:33@x86_64
  stage: test
  dependencies:
    - build-gnome-remote-desktop
  variables:
    XDG_RUNTIME_DIR: "$CI_PROJECT_DIR/runtime-dir"
    GSETTINGS_SCHEMA_DIR: "$CI_PROJECT_DIR/build/src"
  script:
    - mkdir -m 700 $XDG_RUNTIME_DIR
    - glib-compile-schemas $GSETTINGS_SCHEMA_DIR
    - dbus-run-session -- ./.gitlab-ci/run-tests.sh
  needs:
    - build-gnome-remote-desktop
07070100000003000081ED0000000000000000000000016141EE1000000261000000000000000000000000000000000000003E00000000gnome-remote-desktop-40.2/.gitlab-ci/install-meson-project.sh#!/bin/bash

set -e

if [[ $# -lt 3 ]]; then
  echo Usage: $0 [options] [repo-url] [commit] [subdir]
  echo  Options:
  echo    -Dkey=val
  exit 1
fi

MESON_OPTIONS=()

while [[ $1 =~ ^-D ]]; do
  MESON_OPTIONS+=( "$1" )
  shift
done

REPO_URL="$1"
TAG_OR_BRANCH="$2"
SUBDIR="$3"
COMMIT="$4"

REPO_DIR="$(basename ${REPO_URL%.git})"

git clone --depth 1 "$REPO_URL" -b "$TAG_OR_BRANCH"
pushd "$REPO_DIR"
pushd "$SUBDIR"

if [ ! -z "$COMMIT" ]; then
  git fetch origin "$COMMIT"
  git checkout "$COMMIT"
fi

meson --prefix=/usr _build "${MESON_OPTIONS[@]}"
ninja -C _build install
popd
popd
rm -rf "$REPO_DIR"
07070100000004000081ED0000000000000000000000016141EE100000005B000000000000000000000000000000000000003200000000gnome-remote-desktop-40.2/.gitlab-ci/run-tests.sh#!/bin/sh
set -x
pipewire &
meson test -C build --no-rebuild --verbose --no-stdsplit -t 10
07070100000005000081A40000000000000000000000016141EE10000046AC000000000000000000000000000000000000002200000000gnome-remote-desktop-40.2/COPYING                    GNU GENERAL PUBLIC LICENSE
                       Version 2, June 1991

Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

Preamble

The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.)  You can apply it to
your programs, too.

When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and
modification follow.

GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

NO WARRANTY

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

<one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

<signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.
07070100000006000081A40000000000000000000000016141EE100000005B000000000000000000000000000000000000002100000000gnome-remote-desktop-40.2/READMEGNOME Remote Desktop
====================

Remote desktop daemon for GNOME using pipewire.
07070100000007000081A40000000000000000000000016141EE100000016D000000000000000000000000000000000000002900000000gnome-remote-desktop-40.2/config.h.meson/* config.h. Generated by meson. */

/* Project version */
#mesondefine VERSION

/* The prefix for our gettext translation domains. */
#mesondefine GETTEXT_PACKAGE

/* Defined if RDP backend enabled */
#mesondefine HAVE_RDP

/* Defined if VNC backend is enabled */
#mesondefine HAVE_VNC

/* Defined if FreeRDP >= 2.3.x is available */
#mesondefine HAVE_FREERDP_2_3
07070100000008000081A40000000000000000000000016141EE100000042A000000000000000000000000000000000000003400000000gnome-remote-desktop-40.2/gnome-remote-desktop.doap<Project xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
         xmlns:foaf="http://xmlns.com/foaf/0.1/"
         xmlns:gnome="http://api.gnome.org/doap-extensions#"
         xmlns="http://usefulinc.com/ns/doap#">

<name xml:lang="en">gnome-remote-desktop</name>
  <shortdesc xml:lang="en">GNOME Remote Desktop</shortdesc>
  <description>Remote desktop daemon for GNOME using pipewire.</description>
  
  <download-page rdf:resource="http://download.gnome.org/sources/gnome-remote-desktop/" />
  <bug-database rdf:resource="https://gitlab.gnome.org/GNOME/gnome-remote-desktop/issues/" />

<maintainer>
    <foaf:Person>
      <foaf:name>Jonas Ådahl</foaf:name>
      <foaf:mbox rdf:resource="mailto:jadahl@gmail.com" />
      <gnome:userid>jadahl</gnome:userid>
    </foaf:Person>
  </maintainer>
</Project>
07070100000009000081A40000000000000000000000016141EE1000000C8A000000000000000000000000000000000000002600000000gnome-remote-desktop-40.2/meson.buildproject('gnome-remote-desktop', 'c',
        version: '40.2',
        meson_version: '>= 0.47.0',
        default_options: ['warning_level=1',
                          'buildtype=debugoptimized'])

freerdp_req = '>= 2.2.0'
fuse_req = '>= 3.9.1'
xkbcommon_req = '>= 1.0.0'

gnome = import('gnome')

cairo_dep = dependency('cairo')
glib_dep = dependency('glib-2.0', version: '>= 2.68')
gio_dep = dependency('gio-2.0')
gio_unix_dep = dependency('gio-unix-2.0')
pipewire_dep = dependency('libpipewire-0.3', version: '>= 0.3.0')
systemd_dep = dependency('systemd')
libsecret_dep = dependency('libsecret-1')
libnotify_dep = dependency('libnotify')

have_rdp = get_option('rdp')
have_vnc = get_option('vnc')
have_freerdp_2_3 = true

if not have_rdp and not have_vnc
  error('Must enable at least one backend')
endif

if have_rdp
  add_global_arguments('-D_GNU_SOURCE', language : 'c')

freerdp_dep = dependency('freerdp2', version: '>= 2.3.0', required: false)
  if not freerdp_dep.found()
    freerdp_dep = dependency('freerdp2', version: freerdp_req)
    have_freerdp_2_3 = false
  endif

freerdp_client_dep = dependency('freerdp-client2', version: freerdp_req)
  freerdp_server_dep = dependency('freerdp-server2', version: freerdp_req)
  fuse_dep = dependency('fuse3', version: fuse_req)
  winpr_dep = dependency('winpr2', version: freerdp_req)
  xkbcommon_dep = dependency('xkbcommon', version: xkbcommon_req)
endif

if have_vnc
  libvncserver_dep = dependency('libvncserver')
  libvncclient_dep = dependency('libvncclient')
endif

cdata = configuration_data()
cdata.set_quoted('GETTEXT_PACKAGE', 'gnome-remote-desktop')
cdata.set_quoted('VERSION', meson.project_version())

cdata.set('HAVE_RDP', have_rdp)
cdata.set('HAVE_VNC', have_vnc)
cdata.set('HAVE_FREERDP_2_3', have_freerdp_2_3)

configure_file(input: 'config.h.meson',
               output: 'config.h',
               configuration: cdata)

configinc = include_directories('.')

servicedir = get_option('systemd_user_unit_dir')
if servicedir == ''
  servicedir = systemd_dep.get_pkgconfig_variable('systemduserunitdir')
endif

if servicedir == ''
  error('Couldn\'t determine systemd user unit service directory')
endif

top_srcdir = meson.current_source_dir()
builddir = meson.current_build_dir()

prefix = get_option('prefix')
libexecdir = join_paths(prefix, get_option('libexecdir'))
datadir = join_paths(prefix, get_option('datadir'))
schemadir = join_paths(datadir, 'glib-2.0', 'schemas')

subdir('src')
subdir('tests')

meson.add_install_script('meson_post_install.py')

output = [
  '',
  '',
  '   GNOME Remote Desktop ' + meson.project_version(),
  '  ============================',
  '',
  '    Prefix....................... ' + prefix,
  '    libexecdir................... ' + libexecdir,
  '    datadir...................... ' + datadir,
  '    systemd user unit dir........ ' + servicedir,
  '    GSettings schema dir......... ' + schemadir,
  '',
  '    Backends:',
  '',
  '        RDP...................... ' + have_rdp.to_string(),
  '        VNC...................... ' + have_vnc.to_string(),
  '',
  '  Now type \'ninja -C ' + meson.build_root() + '\' to build ' + meson.project_name(),
  '',
  '',
]
message('\n'.join(output))
0707010000000A000081A40000000000000000000000016141EE1000000151000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/meson_options.txtoption('rdp',
       type: 'boolean',
       value: true,
       description: 'Enable the RDP backend')

option('vnc',
       type: 'boolean',
       value: true,
       description: 'Enable the VNC backend')

option('systemd_user_unit_dir',
       type: 'string',
       value: '',
       description: 'systemd user service directory')
0707010000000B000081A40000000000000000000000016141EE100000013A000000000000000000000000000000000000003000000000gnome-remote-desktop-40.2/meson_post_install.py#!/usr/bin/env python3

import os
import subprocess

install_prefix = os.environ['MESON_INSTALL_PREFIX']
schemadir = os.path.join(install_prefix, 'share', 'glib-2.0', 'schemas')

if not os.environ.get('DESTDIR'):
    print('Compiling gsettings schemas...')
    subprocess.call(['glib-compile-schemas', schemadir])
0707010000000C000041ED0000000000000000000000016141EE1000000000000000000000000000000000000000000000001E00000000gnome-remote-desktop-40.2/src0707010000000D000081A40000000000000000000000016141EE10000000A3000000000000000000000000000000000000003E00000000gnome-remote-desktop-40.2/src/gnome-remote-desktop.service.in[Unit]
Description=GNOME Remote Desktop

[Service]
Type=dbus
BusName=org.gnome.RemoteDesktop
ExecStart=@libexecdir@/gnome-remote-desktop-daemon
Restart=on-failure
0707010000000E000081A40000000000000000000000016141EE100001350E000000000000000000000000000000000000003200000000gnome-remote-desktop-40.2/src/grd-clipboard-rdp.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-clipboard-rdp.h"

#include <glib/gstdio.h>
#include <winpr/clipboard.h>

#include "grd-rdp-fuse-clipboard.h"
#include "grd-session-rdp.h"

#define CLIPRDR_FILEDESCRIPTOR_SIZE (4 + 32 + 4 + 16 + 8 + 4 + 4 + 520)
#define MAX_WAIT_TIME 4000

typedef struct _ServerFormatListUpdateContext
{
  GrdClipboardRdp *clipboard_rdp;
  GList *mime_type_tables;
} ServerFormatListUpdateContext;

typedef struct _ServerFormatDataRequestContext
{
  GrdClipboardRdp *clipboard_rdp;
  GrdMimeType mime_type;
  uint32_t src_format_id;
  uint32_t dst_format_id;
  gboolean needs_null_terminator;
  gboolean needs_conversion;
} ServerFormatDataRequestContext;

typedef struct _ClipDataEntry
{
  uint32_t id;

wClipboard *system;
  wClipboardDelegate *delegate;
  uint64_t serial;

gboolean is_independent;
  gboolean has_file_list;
  gboolean requests_allowed;
} ClipDataEntry;

typedef struct _FormatData
{
  uint8_t *data;
  uint32_t size;
} FormatData;

struct _GrdClipboardRdp
{
  GrdClipboard parent;

CliprdrServerContext *cliprdr_context;
  HANDLE stop_event;

wClipboard *system;
  wClipboardDelegate *delegate;
  gboolean has_file_list;
  uint64_t serial;

GHashTable *allowed_server_formats;
  GList *pending_server_formats;
  GList *queued_server_formats;
  gboolean server_file_contents_requests_allowed;
  uint16_t format_list_response_msg_flags;

GHashTable *serial_entry_table;
  GHashTable *clip_data_table;
  struct
  {
    ClipDataEntry *entry;
    ClipDataEntry *entry_to_replace;
    gboolean serial_already_in_use;
  } clipboard_retrieval_context;
  struct
  {
    ClipDataEntry *entry;
  } clipboard_destruction_context;

char *fuse_mount_path;
  GrdRdpFuseClipboard *rdp_fuse_clipboard;
  GHashTable *format_data_cache;
  GrdMimeType which_unicode_format;

HANDLE format_data_received_event;
  CLIPRDR_FORMAT_DATA_RESPONSE *format_data_response;

HANDLE clip_data_entry_event;
  HANDLE completed_clip_data_entry_event;
  HANDLE completed_format_list_event;
  HANDLE completed_format_data_request_event;
  HANDLE format_list_received_event;
  HANDLE format_list_response_received_event;
  HANDLE format_data_request_received_event;
  unsigned int pending_server_formats_drop_id;
  unsigned int clipboard_retrieval_id;
  unsigned int clipboard_destruction_id;
  unsigned int server_format_list_update_id;
  unsigned int server_format_data_request_id;
  unsigned int client_format_list_response_id;
};

G_DEFINE_TYPE (GrdClipboardRdp, grd_clipboard_rdp, GRD_TYPE_CLIPBOARD);

static gboolean
retrieve_current_clipboard (gpointer user_data);

static gboolean
handle_clip_data_entry_destruction (gpointer user_data);

static void
create_new_winpr_clipboard (GrdClipboardRdp *clipboard_rdp);

static void
update_allowed_server_formats (GrdClipboardRdp *clipboard_rdp,
                               gboolean         received_response)
{
  GList *l;

if (received_response)
    g_debug ("[RDP.CLIPRDR] Handling format list response from client");

if (received_response &&
      clipboard_rdp->format_list_response_msg_flags & CB_RESPONSE_OK)
    {
      for (l = clipboard_rdp->pending_server_formats; l; l = l->next)
        {
          if (GPOINTER_TO_UINT (l->data) == GRD_MIME_TYPE_TEXT_URILIST)
            {
              ClipDataEntry *entry;

if (g_hash_table_lookup_extended (clipboard_rdp->serial_entry_table,
                                                GUINT_TO_POINTER (clipboard_rdp->serial),
                                                NULL, (gpointer *) &entry))
                entry->requests_allowed = TRUE;

clipboard_rdp->server_file_contents_requests_allowed = TRUE;
            }

g_hash_table_add (clipboard_rdp->allowed_server_formats, l->data);
        }

g_clear_pointer (&clipboard_rdp->pending_server_formats, g_list_free);

return;
    }

if (received_response &&
      !(clipboard_rdp->format_list_response_msg_flags & CB_RESPONSE_FAIL))
    {
      g_warning ("[RDP.CLIPRDR] Protocol violation: Client did not set response "
                 "flag. Assuming CB_RESPONSE_FAIL");
    }

clipboard_rdp->server_file_contents_requests_allowed = FALSE;
  g_hash_table_remove_all (clipboard_rdp->allowed_server_formats);
  g_clear_pointer (&clipboard_rdp->pending_server_formats, g_list_free);
}

static void
remove_clipboard_format_data_for_mime_type (GrdClipboardRdp *clipboard_rdp,
                                            GrdMimeType      mime_type)
{
  FormatData *format_data;

format_data = g_hash_table_lookup (clipboard_rdp->format_data_cache,
                                     GUINT_TO_POINTER (mime_type));
  if (!format_data)
    return;

g_free (format_data->data);
  g_free (format_data);

g_hash_table_remove (clipboard_rdp->format_data_cache,
                       GUINT_TO_POINTER (mime_type));
}

static void
remove_duplicated_clipboard_mime_types (GrdClipboardRdp  *clipboard_rdp,
                                        GList           **mime_type_list)
{
  GrdMimeType mime_type;

/**
   * Remove the "x-special/gnome-copied-files" mimetype, since we use the
   * "text/uri-list" mimetype instead.
   */
  mime_type = GRD_MIME_TYPE_XS_GNOME_COPIED_FILES;
  if (g_list_find (*mime_type_list, GUINT_TO_POINTER (mime_type)))
    {
      *mime_type_list = g_list_remove (*mime_type_list, GUINT_TO_POINTER (mime_type));
      remove_clipboard_format_data_for_mime_type (clipboard_rdp, mime_type);
    }

/**
   * We can only advertise CF_UNICODETEXT as remote format once, so ignore the
   * other local format if it exists.
   */
  if (g_list_find (*mime_type_list, GUINT_TO_POINTER (GRD_MIME_TYPE_TEXT_PLAIN_UTF8)) &&
      g_list_find (*mime_type_list, GUINT_TO_POINTER (GRD_MIME_TYPE_TEXT_UTF8_STRING)))
    {
      mime_type = GRD_MIME_TYPE_TEXT_PLAIN_UTF8;
      *mime_type_list = g_list_remove (*mime_type_list, GUINT_TO_POINTER (mime_type));
      remove_clipboard_format_data_for_mime_type (clipboard_rdp, mime_type);
    }
}

static void
update_clipboard_serial (GrdClipboardRdp *clipboard_rdp)
{
  ++clipboard_rdp->serial;
  while (g_hash_table_contains (clipboard_rdp->serial_entry_table,
                                GUINT_TO_POINTER (clipboard_rdp->serial)))
    ++clipboard_rdp->serial;

g_debug ("[RDP.CLIPRDR] Updated clipboard serial to %lu", clipboard_rdp->serial);
}

static void
send_mime_type_list (GrdClipboardRdp *clipboard_rdp,
                     GList           *mime_type_list)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = clipboard_rdp->rdp_fuse_clipboard;
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_FORMAT_LIST format_list = {0};
  CLIPRDR_FORMAT *cliprdr_formats;
  ClipDataEntry *entry;
  GrdMimeType mime_type;
  uint32_t n_formats;
  uint32_t i;
  GList *l;

if (g_hash_table_lookup_extended (clipboard_rdp->serial_entry_table,
                                    GUINT_TO_POINTER (clipboard_rdp->serial),
                                    NULL, (gpointer *) &entry))
    {
      g_debug ("[RDP.CLIPRDR] ClipDataEntry with id %u and serial %lu is now "
               "independent", entry->id, entry->serial);
      entry->is_independent = TRUE;

create_new_winpr_clipboard (clipboard_rdp);
    }
  update_clipboard_serial (clipboard_rdp);

n_formats = g_list_length (mime_type_list);
  cliprdr_formats = g_malloc0 (n_formats * sizeof (CLIPRDR_FORMAT));
  for (i = 0, l = mime_type_list; i < n_formats; ++i, l = l->next)
    {
      mime_type = GPOINTER_TO_UINT (l->data);
      switch (mime_type)
        {
        case GRD_MIME_TYPE_TEXT_PLAIN:
          cliprdr_formats[i].formatId = CF_TEXT;
          break;
        case GRD_MIME_TYPE_TEXT_PLAIN_UTF8:
        case GRD_MIME_TYPE_TEXT_UTF8_STRING:
          cliprdr_formats[i].formatId = CF_UNICODETEXT;
          clipboard_rdp->which_unicode_format = mime_type;
          break;
        case GRD_MIME_TYPE_TEXT_HTML:
          cliprdr_formats[i].formatId = CB_FORMAT_HTML;
          cliprdr_formats[i].formatName = "HTML Format";
          break;
        case GRD_MIME_TYPE_IMAGE_BMP:
          cliprdr_formats[i].formatId = CF_DIB;
          break;
        case GRD_MIME_TYPE_IMAGE_TIFF:
          cliprdr_formats[i].formatId = CF_TIFF;
          break;
        case GRD_MIME_TYPE_IMAGE_GIF:
          cliprdr_formats[i].formatId = CB_FORMAT_GIF;
          break;
        case GRD_MIME_TYPE_IMAGE_JPEG:
          cliprdr_formats[i].formatId = CB_FORMAT_JPEG;
          break;
        case GRD_MIME_TYPE_IMAGE_PNG:
          cliprdr_formats[i].formatId = CB_FORMAT_PNG;
          break;
        case GRD_MIME_TYPE_TEXT_URILIST:
          /**
           * FileGroupDescriptorW does not have a consistent format id. It is
           * identified by its name.
           * When the client requests the content, it MUST use the id that we
           * told the client before when the clipboard format with the name
           * "FileGroupDescriptorW" was advertised.
           *
           * See also 1.3.1.2 Clipboard Format
           */
          cliprdr_formats[i].formatId = CB_FORMAT_TEXTURILIST;
          cliprdr_formats[i].formatName = "FileGroupDescriptorW";
          clipboard_rdp->server_file_contents_requests_allowed = FALSE;
          grd_rdp_fuse_clipboard_clear_no_cdi_selection (rdp_fuse_clipboard);
          grd_rdp_fuse_clipboard_lazily_clear_all_cdi_selections (rdp_fuse_clipboard);
          break;
        default:
          g_assert_not_reached ();
        }

remove_clipboard_format_data_for_mime_type (clipboard_rdp, mime_type);
      g_hash_table_remove (clipboard_rdp->allowed_server_formats, l->data);

clipboard_rdp->pending_server_formats =
        g_list_append (clipboard_rdp->pending_server_formats, l->data);
    }

format_list.msgType = CB_FORMAT_LIST;
  format_list.formats = cliprdr_formats;
  format_list.numFormats = n_formats;

g_debug ("[RDP.CLIPRDR] Sending FormatList");
  cliprdr_context->ServerFormatList (cliprdr_context, &format_list);

g_free (cliprdr_formats);
  g_list_free (mime_type_list);
}

static gboolean
drop_pending_server_formats (gpointer user_data)
{
  GrdClipboardRdp *clipboard_rdp = user_data;
  GList *queued_server_formats;

g_warning ("[RDP.CLIPRDR] Possible protocol violation: Client did not send "
             "format list response (Timeout reached)");
  update_allowed_server_formats (clipboard_rdp, FALSE);

queued_server_formats = g_steal_pointer (&clipboard_rdp->queued_server_formats);
  if (queued_server_formats)
    send_mime_type_list (clipboard_rdp, queued_server_formats);

clipboard_rdp->pending_server_formats_drop_id = 0;

return G_SOURCE_REMOVE;
}

static void
grd_clipboard_rdp_update_client_mime_type_list (GrdClipboard *clipboard,
                                                GList        *mime_type_list)
{
  GrdClipboardRdp *clipboard_rdp = GRD_CLIPBOARD_RDP (clipboard);

remove_duplicated_clipboard_mime_types (clipboard_rdp, &mime_type_list);
  if (!mime_type_list)
    return;

if (clipboard_rdp->pending_server_formats)
    {
      if (clipboard_rdp->queued_server_formats)
        g_debug ("[RDP.CLIPRDR] Replacing queued server FormatList");
      g_clear_pointer (&clipboard_rdp->queued_server_formats, g_list_free);

g_debug ("[RDP.CLIPRDR] Queueing new FormatList");
      clipboard_rdp->queued_server_formats = mime_type_list;

if (!clipboard_rdp->pending_server_formats_drop_id)
        {
          clipboard_rdp->pending_server_formats_drop_id =
            g_timeout_add (MAX_WAIT_TIME, drop_pending_server_formats, clipboard_rdp);
        }

return;
    }

send_mime_type_list (clipboard_rdp, mime_type_list);
}

static CLIPRDR_FORMAT_DATA_RESPONSE *
get_format_data_response (GrdClipboardRdp             *clipboard_rdp,
                          CLIPRDR_FORMAT_DATA_REQUEST *format_data_request)
{
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_FORMAT_DATA_RESPONSE *format_data_response = NULL;
  HANDLE format_data_received_event = clipboard_rdp->format_data_received_event;
  HANDLE events[4];
  uint32_t error;

ResetEvent (format_data_received_event);
  error = cliprdr_context->ServerFormatDataRequest (cliprdr_context,
                                                    format_data_request);
  if (error)
    return NULL;

events[0] = clipboard_rdp->stop_event;
  events[1] = format_data_received_event;
  events[2] = clipboard_rdp->format_list_received_event;
  events[3] = clipboard_rdp->clip_data_entry_event;
  while (TRUE)
    {
      if (WaitForMultipleObjects (4, events, FALSE, MAX_WAIT_TIME) == WAIT_TIMEOUT)
        {
          g_warning ("[RDP.CLIPRDR] Possible protocol violation: Client did not "
                     "send format data response (Timeout reached)");
          break;
        }

if (WaitForSingleObject (clipboard_rdp->clip_data_entry_event, 0) == WAIT_TIMEOUT)
        break;

if (clipboard_rdp->clipboard_retrieval_id)
        {
          g_clear_handle_id (&clipboard_rdp->clipboard_retrieval_id,
                             g_source_remove);
          retrieve_current_clipboard (clipboard_rdp);
        }
      if (clipboard_rdp->clipboard_destruction_id)
        {
          g_clear_handle_id (&clipboard_rdp->clipboard_destruction_id,
                             g_source_remove);
          handle_clip_data_entry_destruction (clipboard_rdp);
        }
    }

if (WaitForSingleObject (format_data_received_event, 0) == WAIT_OBJECT_0)
    {
      format_data_response =
        g_steal_pointer (&clipboard_rdp->format_data_response);
    }

return format_data_response;
}

static uint8_t *
get_remote_format_data (GrdClipboardRdp *clipboard_rdp,
                        uint32_t         format_id,
                        uint32_t        *size)
{
  CLIPRDR_FORMAT_DATA_REQUEST format_data_request = {0};
  CLIPRDR_FORMAT_DATA_RESPONSE *format_data_response;
  uint8_t *data;
  gboolean response_ok;

*size = 0;

format_data_request.msgType = CB_FORMAT_DATA_REQUEST;
  format_data_request.dataLen = 4;
  format_data_request.requestedFormatId = format_id;
  format_data_response = get_format_data_response (clipboard_rdp,
                                                   &format_data_request);
  if (!format_data_response)
    return NULL;

data = (uint8_t *) format_data_response->requestedFormatData;
  *size = format_data_response->dataLen;

response_ok = format_data_response->msgFlags & CB_RESPONSE_OK;
  *size = response_ok && data ? *size : 0;
  g_free (format_data_response);

if (!response_ok)
    g_clear_pointer (&data, g_free);

return data;
}

void
grd_clipboard_rdp_lock_remote_clipboard_data (GrdClipboardRdp *clipboard_rdp,
                                              uint32_t         clip_data_id)
{
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_LOCK_CLIPBOARD_DATA lock_clipboard_data = {0};

g_debug ("[RDP.CLIPRDR] Locking clients clipboard data with clipDataId %u",
           clip_data_id);

lock_clipboard_data.msgType = CB_LOCK_CLIPDATA;
  lock_clipboard_data.clipDataId = clip_data_id;

cliprdr_context->ServerLockClipboardData (cliprdr_context,
                                            &lock_clipboard_data);
}

void
grd_clipboard_rdp_unlock_remote_clipboard_data (GrdClipboardRdp *clipboard_rdp,
                                                uint32_t         clip_data_id)
{
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_UNLOCK_CLIPBOARD_DATA unlock_clipboard_data = {0};

g_debug ("[RDP.CLIPRDR] Unlocking clients clipboard data associated to "
           "clipDataId %u", clip_data_id);

unlock_clipboard_data.msgType = CB_UNLOCK_CLIPDATA;
  unlock_clipboard_data.clipDataId = clip_data_id;

cliprdr_context->ServerUnlockClipboardData (cliprdr_context,
                                              &unlock_clipboard_data);
}

void
grd_clipboard_rdp_request_remote_file_size_async (GrdClipboardRdp *clipboard_rdp,
                                                  uint32_t         stream_id,
                                                  uint32_t         list_index,
                                                  gboolean         has_clip_data_id,
                                                  uint32_t         clip_data_id)
{
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_FILE_CONTENTS_REQUEST file_contents_request = {0};

file_contents_request.msgType = CB_FILECONTENTS_REQUEST;
  file_contents_request.streamId = stream_id;
  file_contents_request.listIndex = list_index;
  file_contents_request.dwFlags = FILECONTENTS_SIZE;
  file_contents_request.cbRequested = 0x8;
  file_contents_request.haveClipDataId = has_clip_data_id;
  file_contents_request.clipDataId = clip_data_id;

cliprdr_context->ServerFileContentsRequest (cliprdr_context,
                                              &file_contents_request);
}

void
grd_clipboard_rdp_request_remote_file_range_async (GrdClipboardRdp *clipboard_rdp,
                                                   uint32_t         stream_id,
                                                   uint32_t         list_index,
                                                   uint64_t         offset,
                                                   uint32_t         requested_size,
                                                   gboolean         has_clip_data_id,
                                                   uint32_t         clip_data_id)
{
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_FILE_CONTENTS_REQUEST file_contents_request = {0};

file_contents_request.msgType = CB_FILECONTENTS_REQUEST;
  file_contents_request.streamId = stream_id;
  file_contents_request.listIndex = list_index;
  file_contents_request.dwFlags = FILECONTENTS_RANGE;
  file_contents_request.nPositionLow = offset & 0xFFFFFFFF;
  file_contents_request.nPositionHigh = offset >> 32 & 0xFFFFFFFF;
  file_contents_request.cbRequested = requested_size;
  file_contents_request.haveClipDataId = has_clip_data_id;
  file_contents_request.clipDataId = clip_data_id;

cliprdr_context->ServerFileContentsRequest (cliprdr_context,
                                              &file_contents_request);
}

static uint8_t *
get_uri_list_from_packet_file_list (GrdClipboardRdp *clipboard_rdp,
                                    uint8_t         *src_data,
                                    uint32_t         src_size,
                                    uint32_t        *dst_size,
                                    uint32_t         clip_data_id)
{
#ifdef HAVE_FREERDP_2_3
  FILEDESCRIPTORW *files = NULL;
  FILEDESCRIPTORW *file;
#else
  FILEDESCRIPTOR *files = NULL;
  FILEDESCRIPTOR *file;
#endif /* HAVE_FREERDP_2_3 */
  uint32_t n_files = 0;
  char *clip_data_dir_name;
  char *filename = NULL;
  char *escaped_name;
  char *file_uri;
  GArray *dst_data;
  uint32_t i;

clip_data_dir_name = clipboard_rdp->cliprdr_context->canLockClipData ?
    g_strdup_printf ("%u", clip_data_id) :
    g_strdup_printf ("%lu", GRD_RDP_FUSE_CLIPBOARD_NO_CLIP_DATA_ID);

dst_data = g_array_new (TRUE, TRUE, sizeof (char));

cliprdr_parse_file_list (src_data, src_size, &files, &n_files);
  for (i = 0; i < n_files; ++i)
    {
      file = &files[i];

ConvertFromUnicode (CP_UTF8, 0, file->cFileName, -1, &filename, 0, NULL,
                          NULL);
      if (strchr (filename, '\\'))
        {
          g_free (filename);
          continue;
        }

escaped_name = g_uri_escape_string (filename,
                                          G_URI_RESERVED_CHARS_ALLOWED_IN_PATH,
                                          TRUE);
      file_uri = g_strdup_printf ("file://%s/%s/%s\r\n",
                                  clipboard_rdp->fuse_mount_path,
                                  clip_data_dir_name, escaped_name);
      g_array_append_vals (dst_data, file_uri, strlen (file_uri));

g_free (file_uri);
      g_free (escaped_name);
      g_free (filename);
    }

*dst_size = dst_data->len;

g_free (files);
  g_free (clip_data_dir_name);

return (uint8_t *) g_array_free (dst_data, FALSE);
}

static uint8_t *
convert_client_content_for_server (GrdClipboardRdp *clipboard_rdp,
                                   uint8_t         *src_data,
                                   uint32_t         src_size,
                                   GrdMimeType      mime_type,
                                   uint32_t         src_format_id,
                                   uint32_t        *dst_size,
                                   uint32_t         clip_data_id)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = clipboard_rdp->rdp_fuse_clipboard;
  uint32_t dst_format_id;
  uint8_t *dst_data;
  gboolean is_null_terminated = FALSE;
  BOOL success;

*dst_size = 0;

switch (mime_type)
    {
    case GRD_MIME_TYPE_TEXT_PLAIN_UTF8:
    case GRD_MIME_TYPE_TEXT_UTF8_STRING:
      is_null_terminated = TRUE;
      dst_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "UTF8_STRING");
      break;
    case GRD_MIME_TYPE_TEXT_HTML:
      is_null_terminated = TRUE;
      src_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "HTML Format");
      dst_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "text/html");
      break;
    case GRD_MIME_TYPE_IMAGE_BMP:
      dst_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "image/bmp");
      break;
    case GRD_MIME_TYPE_TEXT_URILIST:
    case GRD_MIME_TYPE_XS_GNOME_COPIED_FILES:
      src_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "FileGroupDescriptorW");
      dst_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "text/uri-list");
      break;
    default:
      g_assert_not_reached ();
    }

success = ClipboardSetData (clipboard_rdp->system,
                              src_format_id, src_data, src_size);
  if (!success)
    {
      g_warning ("[RDP.CLIPRDR] Converting clipboard content failed");
      return NULL;
    }

if (mime_type == GRD_MIME_TYPE_TEXT_URILIST ||
      mime_type == GRD_MIME_TYPE_XS_GNOME_COPIED_FILES)
    {
      dst_data = get_uri_list_from_packet_file_list (clipboard_rdp,
                                                     src_data, src_size,
                                                     dst_size, clip_data_id);
    }
  else
    {
      dst_data = ClipboardGetData (clipboard_rdp->system, dst_format_id,
                                   dst_size);
    }
  if (!dst_data)
    {
      g_warning ("[RDP.CLIPRDR] Converting clipboard content failed");
      return NULL;
    }

if (is_null_terminated)
    {
      uint8_t *null_terminator_pos = memchr (dst_data, '\0', *dst_size);
      if (null_terminator_pos)
        *dst_size = null_terminator_pos - dst_data;
    }

if (mime_type == GRD_MIME_TYPE_TEXT_URILIST ||
      mime_type == GRD_MIME_TYPE_XS_GNOME_COPIED_FILES)
    {
#ifdef HAVE_FREERDP_2_3
      FILEDESCRIPTORW *files = NULL;
      FILEDESCRIPTORW *file;
#else
      FILEDESCRIPTOR *files = NULL;
      FILEDESCRIPTOR *file;
#endif /* HAVE_FREERDP_2_3 */
      uint32_t n_files = 0;
      gboolean result;
      char *clip_data_dir_name;
      char *filename = NULL;
      char *escaped_name;
      char *full_filepath;
      GrdMimeType second_mime_type;
      FormatData *format_data;
      GArray *data_nautilus;
      const char *nautilus_header;
      uint8_t *dst_data_nautilus;
      uint32_t dst_size_nautilus;
      uint32_t i;

cliprdr_parse_file_list (src_data, src_size, &files, &n_files);
      if (clipboard_rdp->cliprdr_context->canLockClipData)
        {
          result = grd_rdp_fuse_clipboard_set_cdi_selection (rdp_fuse_clipboard,
                                                             files, n_files,
                                                             clip_data_id);
        }
      else
        {
          result = grd_rdp_fuse_clipboard_set_no_cdi_selection (rdp_fuse_clipboard,
                                                                files, n_files);
        }
      if (!result)
        {
          g_free (files);
          g_free (dst_data);
          return NULL;
        }

clip_data_dir_name = clipboard_rdp->cliprdr_context->canLockClipData ?
        g_strdup_printf ("%u", clip_data_id) :
        g_strdup_printf ("%lu", GRD_RDP_FUSE_CLIPBOARD_NO_CLIP_DATA_ID);

data_nautilus = g_array_new (TRUE, TRUE, sizeof (char));
      nautilus_header = "copy";
      g_array_append_vals (data_nautilus, nautilus_header,
                           strlen (nautilus_header));
      for (i = 0; i < n_files; ++i)
        {
          file = &files[i];

ConvertFromUnicode (CP_UTF8, 0, file->cFileName, -1, &filename,
                              0, NULL, NULL);
          if (strchr (filename, '\\'))
            {
              g_free (filename);
              continue;
            }

escaped_name = g_uri_escape_string (filename,
                           G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE);
          full_filepath = g_strdup_printf ("\nfile://%s/%s/%s",
                                           clipboard_rdp->fuse_mount_path,
                                           clip_data_dir_name, escaped_name);
          g_array_append_vals (data_nautilus, full_filepath,
                               strlen (full_filepath));

g_free (full_filepath);
          g_free (escaped_name);
          g_free (filename);
        }

dst_size_nautilus = data_nautilus->len;
      dst_data_nautilus = (uint8_t *) g_array_free (data_nautilus, FALSE);

format_data = g_malloc0 (sizeof (FormatData));
      if (mime_type == GRD_MIME_TYPE_TEXT_URILIST)
        {
          /**
           * Also create the format data for the
           * "x-special/gnome-copied-files" mimetype
           */
          second_mime_type = GRD_MIME_TYPE_XS_GNOME_COPIED_FILES;
          format_data->size = dst_size_nautilus;
          format_data->data = dst_data_nautilus;
        }
      else if (mime_type == GRD_MIME_TYPE_XS_GNOME_COPIED_FILES)
        {
          /**
           * Also create the format data for the "text/uri-list" mimetype
           */
          second_mime_type = GRD_MIME_TYPE_TEXT_URILIST;
          format_data->size = *dst_size;
          format_data->data = dst_data;

*dst_size = dst_size_nautilus;
          dst_data = dst_data_nautilus;
        }
      else
        {
          g_assert_not_reached ();
        }

g_hash_table_insert (clipboard_rdp->format_data_cache,
                           GUINT_TO_POINTER (second_mime_type),
                           format_data);

g_free (clip_data_dir_name);
      g_free (files);
    }

if (!dst_data)
    g_warning ("[RDP.CLIPRDR] Converting clipboard content failed");

return dst_data;
}

static uint8_t *
grd_clipboard_rdp_request_client_content_for_mime_type (GrdClipboard     *clipboard,
                                                        GrdMimeTypeTable *mime_type_table,
                                                        uint32_t         *size)
{
  GrdClipboardRdp *clipboard_rdp = GRD_CLIPBOARD_RDP (clipboard);
  GrdRdpFuseClipboard *rdp_fuse_clipboard = clipboard_rdp->rdp_fuse_clipboard;
  GrdMimeType mime_type = mime_type_table->mime_type;
  HANDLE completed_format_list_event = clipboard_rdp->completed_format_list_event;
  uint32_t src_format_id;
  uint8_t *src_data, *dst_data;
  uint32_t src_size, dst_size;
  uint32_t clip_data_id = 0;

*size = 0;
  if (mime_type == GRD_MIME_TYPE_NONE)
    return NULL;

if (g_hash_table_contains (clipboard_rdp->format_data_cache,
                             GUINT_TO_POINTER (mime_type)))
    {
      FormatData *format_data;

format_data = g_hash_table_lookup (clipboard_rdp->format_data_cache,
                                         GUINT_TO_POINTER (mime_type));
      *size = format_data->size;

return g_memdup2 (format_data->data, format_data->size);
    }

if (WaitForSingleObject (completed_format_list_event, 0) == WAIT_TIMEOUT)
    return NULL;

if (clipboard_rdp->cliprdr_context->canLockClipData &&
      (mime_type == GRD_MIME_TYPE_TEXT_URILIST ||
       mime_type == GRD_MIME_TYPE_XS_GNOME_COPIED_FILES))
    clip_data_id = grd_rdp_fuse_clipboard_clip_data_id_new (rdp_fuse_clipboard);

src_format_id = mime_type_table->rdp.format_id;
  src_data = get_remote_format_data (clipboard_rdp, src_format_id, &src_size);
  if (!src_data)
    {
      if (clipboard_rdp->cliprdr_context->canLockClipData &&
          (mime_type == GRD_MIME_TYPE_TEXT_URILIST ||
           mime_type == GRD_MIME_TYPE_XS_GNOME_COPIED_FILES))
        grd_rdp_fuse_clipboard_clip_data_id_free (rdp_fuse_clipboard, clip_data_id);

return NULL;
    }

dst_data = NULL;
  dst_size = 0;

switch (mime_type)
    {
    case GRD_MIME_TYPE_TEXT_PLAIN_UTF8:
    case GRD_MIME_TYPE_TEXT_UTF8_STRING:
    case GRD_MIME_TYPE_TEXT_HTML:
    case GRD_MIME_TYPE_IMAGE_BMP:
    case GRD_MIME_TYPE_TEXT_URILIST:
    case GRD_MIME_TYPE_XS_GNOME_COPIED_FILES:
      dst_data = convert_client_content_for_server (clipboard_rdp,
                                                    src_data, src_size,
                                                    mime_type, src_format_id,
                                                    &dst_size, clip_data_id);
      break;
    default:
      dst_data = g_steal_pointer (&src_data);
      dst_size = src_size;
    }

if (!dst_data && clipboard_rdp->cliprdr_context->canLockClipData &&
      (mime_type == GRD_MIME_TYPE_TEXT_URILIST ||
       mime_type == GRD_MIME_TYPE_XS_GNOME_COPIED_FILES))
    grd_rdp_fuse_clipboard_clip_data_id_free (rdp_fuse_clipboard, clip_data_id);

if (dst_data)
    {
      FormatData *format_data = g_malloc0 (sizeof (FormatData));

format_data->size = *size = dst_size;
      format_data->data = dst_data;

g_hash_table_insert (clipboard_rdp->format_data_cache,
                           GUINT_TO_POINTER (mime_type),
                           format_data);
    }

g_free (src_data);

return g_memdup2 (dst_data, dst_size);
}

/**
 * FreeRDP already updated our capabilites after the client told us
 * about its capabilities, there is nothing to do here
 */
static uint32_t
cliprdr_client_capabilities (CliprdrServerContext       *cliprdr_context,
                             const CLIPRDR_CAPABILITIES *capabilities)
{
  g_autoptr (GStrvBuilder) client_capabilities = NULL;
  char **client_caps_strings;
  g_autofree char *caps_string = NULL;

client_capabilities = g_strv_builder_new ();

if (cliprdr_context->useLongFormatNames)
    g_strv_builder_add (client_capabilities, "long format names");
  if (cliprdr_context->streamFileClipEnabled)
    g_strv_builder_add (client_capabilities, "stream file clipping");
  if (cliprdr_context->fileClipNoFilePaths)
    g_strv_builder_add (client_capabilities, "file clip no file paths");
  if (cliprdr_context->canLockClipData)
    g_strv_builder_add (client_capabilities, "can lock clip data");
#ifdef HAVE_FREERDP_2_3
  if (cliprdr_context->hasHugeFileSupport)
    g_strv_builder_add (client_capabilities, "huge file support");
#endif /* HAVE_FREERDP_2_3 */

client_caps_strings = g_strv_builder_end (client_capabilities);
  caps_string = g_strjoinv (", ", client_caps_strings);
  g_message ("[RDP.CLIPRDR] Client capabilities: %s", caps_string);

g_strfreev (client_caps_strings);

return CHANNEL_RC_OK;
}

/**
 * Client sent us a Temporary Directory PDU.
 * We don't handle the CF_HDROP format however. It's a relict of the past.
 */
static uint32_t
cliprdr_temp_directory (CliprdrServerContext         *cliprdr_context,
                        const CLIPRDR_TEMP_DIRECTORY *temp_directory)
{
  g_debug ("[RDP.CLIPRDR] Client sent a Temporary Directory PDU with path \"%s\"",
           temp_directory->szTempDir);

return CHANNEL_RC_OK;
}

static gboolean
update_server_format_list (gpointer user_data)
{
  ServerFormatListUpdateContext *update_context = user_data;
  GrdClipboardRdp *clipboard_rdp = update_context->clipboard_rdp;
  GrdClipboard *clipboard = GRD_CLIPBOARD (update_context->clipboard_rdp);
  GrdRdpFuseClipboard *rdp_fuse_clipboard = clipboard_rdp->rdp_fuse_clipboard;
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_FORMAT_LIST_RESPONSE format_list_response = {0};
  GList *mime_type_tables = update_context->mime_type_tables;
  GrdMimeTypeTable *mime_type_table;
  GList *l;

for (l = mime_type_tables; l; l = l->next)
    {
      mime_type_table = l->data;

/* Also indirectly handles the GRD_MIME_TYPE_XS_GNOME_COPIED_FILES case */
      if (mime_type_table->mime_type == GRD_MIME_TYPE_TEXT_URILIST)
        {
          clipboard_rdp->server_file_contents_requests_allowed = FALSE;

grd_rdp_fuse_clipboard_clear_no_cdi_selection (rdp_fuse_clipboard);
          grd_rdp_fuse_clipboard_lazily_clear_all_cdi_selections (rdp_fuse_clipboard);
        }

remove_clipboard_format_data_for_mime_type (clipboard_rdp,
                                                  mime_type_table->mime_type);
      g_hash_table_remove (clipboard_rdp->allowed_server_formats,
                           GUINT_TO_POINTER (mime_type_table->mime_type));
    }

grd_clipboard_update_server_mime_type_list (clipboard, mime_type_tables);

format_list_response.msgType = CB_FORMAT_LIST_RESPONSE;
  format_list_response.msgFlags = CB_RESPONSE_OK;

cliprdr_context->ServerFormatListResponse (cliprdr_context,
                                             &format_list_response);

/**
   * Any FileContentsRequest that is still waiting for a FileContentsResponse
   * won't get a response any more, when the client does not support clipboard
   * data locking. So, drop all requests without clipDataId here.
   */
  if (!cliprdr_context->canLockClipData)
    grd_rdp_fuse_clipboard_dismiss_all_no_cdi_requests (rdp_fuse_clipboard);

g_free (update_context);

WaitForSingleObject (clipboard_rdp->format_list_received_event, INFINITE);
  clipboard_rdp->server_format_list_update_id = 0;
  ResetEvent (clipboard_rdp->format_list_received_event);
  SetEvent (clipboard_rdp->completed_format_list_event);

return G_SOURCE_REMOVE;
}

/**
 * Client informs us that its clipboard is updated with new clipboard data
 */
static uint32_t
cliprdr_client_format_list (CliprdrServerContext      *cliprdr_context,
                            const CLIPRDR_FORMAT_LIST *format_list)
{
  GrdClipboardRdp *clipboard_rdp = cliprdr_context->custom;
  ServerFormatListUpdateContext *update_context;
  GrdMimeTypeTable *mime_type_table = NULL;
  GList *mime_type_tables = NULL;
  GrdMimeType mime_type;
  gboolean already_has_text_format = FALSE;
  HANDLE events[2];
  uint32_t i;

/**
   * The text format CF_TEXT can depend on the CF_LOCALE content. In such
   * situations, we might not get the correct content from WinPR.
   * CF_UNICODETEXT is not affected by the CF_LOCALE content, so try to find
   * the CF_UNICODETEXT first to ensure that we use CF_UNICODETEXT, when both
   * formats are available and CF_TEXT is listed first.
   */
  for (i = 0; i < format_list->numFormats; ++i)
    {
      if (format_list->formats[i].formatId == CF_UNICODETEXT)
        {
          mime_type = GRD_MIME_TYPE_TEXT_PLAIN_UTF8;

mime_type_table = g_malloc0 (sizeof (GrdMimeTypeTable));
          mime_type_table->mime_type = mime_type;
          mime_type_table->rdp.format_id = format_list->formats[i].formatId;
          mime_type_tables = g_list_append (mime_type_tables, mime_type_table);

mime_type = GRD_MIME_TYPE_TEXT_UTF8_STRING;

already_has_text_format = TRUE;
          g_debug ("[RDP.CLIPRDR] Force using CF_UNICODETEXT over CF_TEXT as "
                   "external format for text/plain;charset=utf-8 and UTF8_STRING");
          break;
        }
    }

for (i = 0; i < format_list->numFormats; ++i)
    {
      mime_type = GRD_MIME_TYPE_NONE;

/**
       * FileGroupDescriptorW does not have a consistent id. The name however,
       * is always the same.
       *
       * If the client uses short format names, the formatName is truncated to
       * either 32 ASCII 8 characters or 16 UTF-16 characters.
       */
      if (format_list->formats[i].formatName &&
          (strcmp (format_list->formats[i].formatName, "FileGroupDescriptorW") == 0 ||
           strcmp (format_list->formats[i].formatName, "FileGroupDescri") == 0))
        {
          /**
           * Advertise the "x-special/gnome-copied-files" format in addition to
           * the "text/uri-list" format
           */
          mime_type = GRD_MIME_TYPE_XS_GNOME_COPIED_FILES;

mime_type = GRD_MIME_TYPE_TEXT_URILIST;
        }
      else if (format_list->formats[i].formatName &&
               strcmp (format_list->formats[i].formatName, "HTML Format") == 0)
        {
          mime_type = GRD_MIME_TYPE_TEXT_HTML;
        }
      else
        {
          switch (format_list->formats[i].formatId)
            {
            case CF_TEXT:
            case CF_UNICODETEXT:
            case CF_OEMTEXT:
              if (!already_has_text_format)
                {
                  mime_type = GRD_MIME_TYPE_TEXT_PLAIN_UTF8;

mime_type_table = g_malloc0 (sizeof (GrdMimeTypeTable));
                  mime_type_table->mime_type = mime_type;
                  mime_type_table->rdp.format_id = format_list->formats[i].formatId;
                  mime_type_tables = g_list_append (mime_type_tables,
                                                    mime_type_table);

mime_type = GRD_MIME_TYPE_TEXT_UTF8_STRING;
                  already_has_text_format = TRUE;
                  g_debug ("[RDP.CLIPRDR] Client advertised data for "
                           "text/plain;charset=utf-8 and UTF8_STRING "
                           "(external format: id: %u, name: %s)",
                           format_list->formats[i].formatId,
                           format_list->formats[i].formatName);
                }
              break;
            case CF_DIB:
              mime_type = GRD_MIME_TYPE_IMAGE_BMP;
              break;
            case CF_TIFF:
              mime_type = GRD_MIME_TYPE_IMAGE_TIFF;
              break;
            case CB_FORMAT_GIF:
              mime_type = GRD_MIME_TYPE_IMAGE_GIF;
              break;
            case CB_FORMAT_JPEG:
              mime_type = GRD_MIME_TYPE_IMAGE_JPEG;
              break;
            case CB_FORMAT_PNG:
              mime_type = GRD_MIME_TYPE_IMAGE_PNG;
              break;
            default:
              g_debug ("[RDP.CLIPRDR] Client advertised unknown format: id: %u, "
                       "name: %s", format_list->formats[i].formatId,
                       format_list->formats[i].formatName);
            }
        }

if (mime_type != GRD_MIME_TYPE_NONE)
        {
          mime_type_table = g_malloc0 (sizeof (GrdMimeTypeTable));
          mime_type_table->mime_type = mime_type;
          mime_type_table->rdp.format_id = format_list->formats[i].formatId;
          mime_type_tables = g_list_append (mime_type_tables, mime_type_table);
        }
    }

if (clipboard_rdp->server_format_list_update_id)
    {
      g_debug ("[RDP.CLIPRDR] Wrong message sequence: Got new format list "
               "without being able to response to last update first");
    }

events[0] = clipboard_rdp->stop_event;
  events[1] = clipboard_rdp->completed_format_list_event;
  WaitForMultipleObjects (2, events, FALSE, INFINITE);

if (WaitForSingleObject (clipboard_rdp->stop_event, 0) == WAIT_OBJECT_0)
    {
      g_list_free_full (mime_type_tables, g_free);
      return CHANNEL_RC_OK;
    }

ResetEvent (clipboard_rdp->completed_format_list_event);
  update_context = g_malloc0 (sizeof (ServerFormatListUpdateContext));
  update_context->clipboard_rdp = clipboard_rdp;
  update_context->mime_type_tables = mime_type_tables;

clipboard_rdp->server_format_list_update_id =
    g_idle_add (update_server_format_list, update_context);
  SetEvent (clipboard_rdp->format_list_received_event);

return CHANNEL_RC_OK;
}

static gboolean
handle_format_list_response (gpointer user_data)
{
  GrdClipboardRdp *clipboard_rdp = user_data;
  GList *queued_server_formats;

if (clipboard_rdp->pending_server_formats)
    update_allowed_server_formats (clipboard_rdp, TRUE);

g_clear_handle_id (&clipboard_rdp->pending_server_formats_drop_id,
                     g_source_remove);

WaitForSingleObject (clipboard_rdp->format_list_response_received_event,
                       INFINITE);
  clipboard_rdp->client_format_list_response_id = 0;
  ResetEvent (clipboard_rdp->format_list_response_received_event);

queued_server_formats = g_steal_pointer (&clipboard_rdp->queued_server_formats);
  if (queued_server_formats)
    send_mime_type_list (clipboard_rdp, queued_server_formats);

return G_SOURCE_REMOVE;
}

/**
 * Client sent us a response to our format list pdu
 */
static uint32_t
cliprdr_client_format_list_response (CliprdrServerContext               *cliprdr_context,
                                     const CLIPRDR_FORMAT_LIST_RESPONSE *format_list_response)
{
  GrdClipboardRdp *clipboard_rdp = cliprdr_context->custom;
  HANDLE format_list_response_received_event;

format_list_response_received_event =
    clipboard_rdp->format_list_response_received_event;

if (WaitForSingleObject (format_list_response_received_event, 0) == WAIT_OBJECT_0)
    {
      g_warning ("[RDP.CLIPRDR] Wrong message sequence: Received an unexpected "
                 "format list response. Ignoring...");
      return CHANNEL_RC_OK;
    }

clipboard_rdp->format_list_response_msg_flags = format_list_response->msgFlags;
  clipboard_rdp->client_format_list_response_id =
    g_idle_add (handle_format_list_response, clipboard_rdp);
  SetEvent (format_list_response_received_event);

return CHANNEL_RC_OK;
}

static gboolean
retrieve_current_clipboard (gpointer user_data)
{
  GrdClipboardRdp *clipboard_rdp = user_data;
  ClipDataEntry *entry = clipboard_rdp->clipboard_retrieval_context.entry;
  ClipDataEntry *entry_to_replace;
  uint64_t serial = clipboard_rdp->serial;
  gboolean serial_already_in_use;

g_debug ("[RDP.CLIPRDR] Tracking serial %lu for ClipDataEntry",
           clipboard_rdp->serial);

entry_to_replace = clipboard_rdp->clipboard_retrieval_context.entry_to_replace;
  if (entry_to_replace)
    {
      g_hash_table_remove (clipboard_rdp->serial_entry_table,
                           GUINT_TO_POINTER (entry_to_replace->serial));
    }

serial_already_in_use = g_hash_table_contains (clipboard_rdp->serial_entry_table,
                                                 GUINT_TO_POINTER (serial));
  if (!serial_already_in_use)
    {
      g_hash_table_insert (clipboard_rdp->serial_entry_table,
                           GUINT_TO_POINTER (serial), entry);
    }
  clipboard_rdp->clipboard_retrieval_context.serial_already_in_use =
    serial_already_in_use;

entry->serial = serial;
  entry->has_file_list = clipboard_rdp->has_file_list;
  entry->requests_allowed = clipboard_rdp->server_file_contents_requests_allowed;

entry->system = clipboard_rdp->system;
  entry->delegate = clipboard_rdp->delegate;

WaitForSingleObject (clipboard_rdp->clip_data_entry_event, INFINITE);
  clipboard_rdp->clipboard_retrieval_id = 0;
  ResetEvent (clipboard_rdp->clip_data_entry_event);
  SetEvent (clipboard_rdp->completed_clip_data_entry_event);

return G_SOURCE_REMOVE;
}

static gboolean
is_clip_data_entry_user_of_serial (gpointer key,
                                   gpointer value,
                                   gpointer user_data)
{
  ClipDataEntry *entry = value;
  uint64_t serial = GPOINTER_TO_UINT (user_data);

return entry->serial == serial;
}

/**
 * Client requests us to retain all file stream data on the clipboard
 */
static uint32_t
cliprdr_client_lock_clipboard_data (CliprdrServerContext              *cliprdr_context,
                                    const CLIPRDR_LOCK_CLIPBOARD_DATA *lock_clipboard_data)
{
  GrdClipboardRdp *clipboard_rdp = cliprdr_context->custom;
  uint32_t clip_data_id = lock_clipboard_data->clipDataId;
  ClipDataEntry *entry;
  HANDLE events[2];

if (WaitForSingleObject (clipboard_rdp->stop_event, 0) == WAIT_OBJECT_0)
    return CHANNEL_RC_OK;

g_debug ("[RDP.CLIPRDR] Client requested a lock with clipDataId: %u",
           clip_data_id);

clipboard_rdp->clipboard_retrieval_context.entry_to_replace = NULL;
  if (g_hash_table_lookup_extended (clipboard_rdp->clip_data_table,
                                    GUINT_TO_POINTER (clip_data_id),
                                    NULL, (gpointer *) &entry))
    {
      g_warning ("[RDP.CLIPRDR] Protocol violation: Client requested a lock with"
                 " an existing clipDataId %u. Replacing existing ClipDataEntry",
                 clip_data_id);

clipboard_rdp->clipboard_retrieval_context.entry_to_replace = entry;
    }

ResetEvent (clipboard_rdp->completed_clip_data_entry_event);
  entry = g_malloc0 (sizeof (ClipDataEntry));
  clipboard_rdp->clipboard_retrieval_context.entry = entry;

clipboard_rdp->clipboard_retrieval_id =
    g_idle_add (retrieve_current_clipboard, clipboard_rdp);
  SetEvent (clipboard_rdp->clip_data_entry_event);

events[0] = clipboard_rdp->stop_event;
  events[1] = clipboard_rdp->completed_clip_data_entry_event;
  WaitForMultipleObjects (2, events, FALSE, INFINITE);

if (WaitForSingleObject (clipboard_rdp->stop_event, 0) == WAIT_OBJECT_0)
    return CHANNEL_RC_OK;

if (clipboard_rdp->clipboard_retrieval_context.serial_already_in_use)
    {
      uint64_t serial = entry->serial;

g_warning ("[RDP.CLIPRDR] Protocol violation: Double lock detected ("
                 "Clipboard serial already in use). Replacing the clipDataId.");

g_free (entry);
      entry = g_hash_table_find (clipboard_rdp->clip_data_table,
                                 is_clip_data_entry_user_of_serial,
                                 GUINT_TO_POINTER (serial));
      g_hash_table_steal (clipboard_rdp->clip_data_table,
                          GUINT_TO_POINTER (entry->id));
    }

entry->id = clip_data_id;

g_debug ("[RDP.CLIPRDR] Tracking lock with clipDataId %u", clip_data_id);
  g_hash_table_insert (clipboard_rdp->clip_data_table,
                       GUINT_TO_POINTER (clip_data_id),
                       entry);

return CHANNEL_RC_OK;
}

static gboolean
handle_clip_data_entry_destruction (gpointer user_data)
{
  GrdClipboardRdp *clipboard_rdp = user_data;
  ClipDataEntry *entry;

entry = g_steal_pointer (&clipboard_rdp->clipboard_destruction_context.entry);

g_debug ("[RDP.CLIPRDR] Deleting ClipDataEntry with serial %lu", entry->serial);
  g_hash_table_remove (clipboard_rdp->serial_entry_table,
                       GUINT_TO_POINTER (entry->serial));

WaitForSingleObject (clipboard_rdp->clip_data_entry_event, INFINITE);
  clipboard_rdp->clipboard_destruction_id = 0;
  ResetEvent (clipboard_rdp->clip_data_entry_event);
  SetEvent (clipboard_rdp->completed_clip_data_entry_event);

return G_SOURCE_REMOVE;
}

/**
 * Client informs us that the file stream data for a specific clip data id can
 * now be released
 */
static uint32_t
cliprdr_client_unlock_clipboard_data (CliprdrServerContext                *cliprdr_context,
                                      const CLIPRDR_UNLOCK_CLIPBOARD_DATA *unlock_clipboard_data)
{
  GrdClipboardRdp *clipboard_rdp = cliprdr_context->custom;
  uint32_t clip_data_id = unlock_clipboard_data->clipDataId;
  ClipDataEntry *entry;
  HANDLE events[2];

if (WaitForSingleObject (clipboard_rdp->stop_event, 0) == WAIT_OBJECT_0)
    return CHANNEL_RC_OK;

g_debug ("[RDP.CLIPRDR] Client requested an unlock with clipDataId: %u",
           clip_data_id);
  if (!g_hash_table_lookup_extended (clipboard_rdp->clip_data_table,
                                     GUINT_TO_POINTER (clip_data_id),
                                     NULL, (gpointer *) &entry))
    {
      g_warning ("[RDP.CLIPRDR] Protocol violation: ClipDataEntry with id %u "
                 "does not exist", clip_data_id);
      return CHANNEL_RC_OK;
    }

g_debug ("[RDP.CLIPRDR] Removing lock with clipDataId: %u", clip_data_id);

ResetEvent (clipboard_rdp->completed_clip_data_entry_event);
  clipboard_rdp->clipboard_destruction_context.entry = entry;

clipboard_rdp->clipboard_destruction_id =
    g_idle_add (handle_clip_data_entry_destruction, clipboard_rdp);
  SetEvent (clipboard_rdp->clip_data_entry_event);

events[0] = clipboard_rdp->stop_event;
  events[1] = clipboard_rdp->completed_clip_data_entry_event;
  WaitForMultipleObjects (2, events, FALSE, INFINITE);

g_debug ("[RDP.CLIPRDR] Untracking lock with clipDataId %u", clip_data_id);
  g_hash_table_remove (clipboard_rdp->clip_data_table,
                       GUINT_TO_POINTER (clip_data_id));

return CHANNEL_RC_OK;
}

static void
#ifdef HAVE_FREERDP_2_3
serialize_file_list (FILEDESCRIPTORW  *files,
                     uint32_t          n_files,
                     uint8_t         **dst_data,
                     uint32_t         *dst_size)
{
  FILEDESCRIPTORW *file;
#else
serialize_file_list (FILEDESCRIPTOR *files,
                     uint32_t         n_files,
                     uint8_t        **dst_data,
                     uint32_t        *dst_size)
{
  FILEDESCRIPTOR *file;
#endif /* HAVE_FREERDP_2_3 */
  wStream* s = NULL;
  uint64_t last_write_time;
  uint32_t i, j;

if (!files || !dst_data || !dst_size)
    return;

if (!(s = Stream_New (NULL, 4 + n_files * CLIPRDR_FILEDESCRIPTOR_SIZE)))
    return;

Stream_Write_UINT32 (s, n_files);                    /* cItems */
  for (i = 0; i < n_files; ++i)
    {
      file = &files[i];

Stream_Write_UINT32 (s, file->dwFlags);          /* flags */
      Stream_Zero (s, 32);                             /* reserved1 */
      Stream_Write_UINT32 (s, file->dwFileAttributes); /* fileAttributes */
      Stream_Zero (s, 16);                             /* reserved2 */

last_write_time = file->ftLastWriteTime.dwHighDateTime;
      last_write_time <<= 32;
      last_write_time += file->ftLastWriteTime.dwLowDateTime;

Stream_Write_UINT64 (s, last_write_time);        /* lastWriteTime */
      Stream_Write_UINT32 (s, file->nFileSizeHigh);    /* fileSizeHigh */
      Stream_Write_UINT32 (s, file->nFileSizeLow);     /* fileSizeLow */

for (j = 0; j < 260; j++)                        /* cFileName */
        Stream_Write_UINT16 (s, file->cFileName[j]);
    }

Stream_SealLength (s);
  Stream_GetLength (s, *dst_size);
  Stream_GetBuffer (s, *dst_data);

Stream_Free (s, FALSE);
}

static gboolean
request_server_format_data (gpointer user_data)
{
  ServerFormatDataRequestContext *request_context = user_data;
  GrdClipboardRdp *clipboard_rdp = request_context->clipboard_rdp;
  GrdClipboard *clipboard = GRD_CLIPBOARD (clipboard_rdp);
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_FORMAT_DATA_RESPONSE format_data_response = {0};
  GrdMimeType mime_type = request_context->mime_type;
  uint32_t src_format_id = request_context->src_format_id;
  uint32_t dst_format_id = request_context->dst_format_id;
  uint8_t *src_data, *dst_data;
  uint32_t src_size, dst_size;
  BOOL success;

dst_data = src_data = NULL;
  dst_size = src_size = 0;

if (g_hash_table_contains (clipboard_rdp->allowed_server_formats,
                             GUINT_TO_POINTER (mime_type)))
    {
      src_data = grd_clipboard_request_server_content_for_mime_type (clipboard,
                                                                     mime_type,
                                                                     &src_size);
    }
  if (src_data)
    {
      if (request_context->needs_conversion)
        {
          if (request_context->needs_null_terminator)
            {
              char *pnull_terminator;

src_data = g_realloc (src_data, src_size + 1);
              pnull_terminator = (char *) src_data + src_size;
              *pnull_terminator = '\0';
              ++src_size;
            }

success = ClipboardSetData (clipboard_rdp->system,
                                      src_format_id, src_data, src_size);
          if (success)
            {
              dst_data = ClipboardGetData (clipboard_rdp->system,
                                           dst_format_id, &dst_size);

if (dst_data && mime_type == GRD_MIME_TYPE_TEXT_URILIST)
                {
                  uint64_t serial = clipboard_rdp->serial;
                  ClipDataEntry *entry;
#ifdef HAVE_FREERDP_2_3
                  FILEDESCRIPTORW *files;
                  uint32_t n_files;

files = (FILEDESCRIPTORW *) dst_data;
                  n_files = dst_size / sizeof (FILEDESCRIPTORW);
#else
                  FILEDESCRIPTOR *files;
                  uint32_t n_files;

files = (FILEDESCRIPTOR *) dst_data;
                  n_files = dst_size / sizeof (FILEDESCRIPTOR);
#endif /* HAVE_FREERDP_2_3 */

dst_data = NULL;
                  dst_size = 0;
                  serialize_file_list (files, n_files, &dst_data, &dst_size);

g_free (files);

clipboard_rdp->has_file_list = TRUE;
                  if (g_hash_table_lookup_extended (clipboard_rdp->serial_entry_table,
                                                    GUINT_TO_POINTER (serial),
                                                    NULL, (gpointer *) &entry))
                    entry->has_file_list = TRUE;
                }
            }
          if (!success || !dst_data)
            g_warning ("[RDP.CLIPRDR] Converting clipboard content failed");
        }
      else
        {
          dst_data = g_steal_pointer (&src_data);
          dst_size = src_size;
        }
    }

format_data_response.msgType = CB_FORMAT_DATA_RESPONSE;
  format_data_response.msgFlags = dst_data ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;
  format_data_response.dataLen = dst_size;
  format_data_response.requestedFormatData = dst_data;

cliprdr_context->ServerFormatDataResponse (cliprdr_context,
                                             &format_data_response);

g_free (src_data);
  g_free (dst_data);
  g_free (request_context);

WaitForSingleObject (clipboard_rdp->format_data_request_received_event,
                       INFINITE);
  clipboard_rdp->server_format_data_request_id = 0;
  ResetEvent (clipboard_rdp->format_data_request_received_event);
  SetEvent (clipboard_rdp->completed_format_data_request_event);

return G_SOURCE_REMOVE;
}

/**
 * Client knows our format list, it requests now the data from our clipboard
 */
static uint32_t
cliprdr_client_format_data_request (CliprdrServerContext              *cliprdr_context,
                                    const CLIPRDR_FORMAT_DATA_REQUEST *format_data_request)
{
  GrdClipboardRdp *clipboard_rdp = cliprdr_context->custom;
  ServerFormatDataRequestContext *request_context;
  CLIPRDR_FORMAT_DATA_RESPONSE format_data_response = {0};
  GrdMimeType mime_type = GRD_MIME_TYPE_NONE;
  uint32_t src_format_id = 0;
  uint32_t dst_format_id;
  gboolean needs_null_terminator = FALSE;
  gboolean needs_conversion = FALSE;
  HANDLE events[2];

dst_format_id = format_data_request->requestedFormatId;
  switch (dst_format_id)
    {
    case CF_TEXT:
      mime_type = GRD_MIME_TYPE_TEXT_PLAIN;
      needs_null_terminator = TRUE;
      needs_conversion = TRUE;
      src_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "text/plain");
      break;
    case CF_UNICODETEXT:
      mime_type = clipboard_rdp->which_unicode_format;
      needs_null_terminator = TRUE;
      needs_conversion = TRUE;
      src_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "UTF8_STRING");
      break;
    case CB_FORMAT_HTML:
      mime_type = GRD_MIME_TYPE_TEXT_HTML;
      needs_null_terminator = TRUE;
      needs_conversion = TRUE;
      src_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "text/html");
      dst_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "HTML Format");
      break;
    case CF_DIB:
      mime_type = GRD_MIME_TYPE_IMAGE_BMP;
      needs_conversion = TRUE;
      src_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "image/bmp");
      break;
    case CF_TIFF:
      mime_type = GRD_MIME_TYPE_IMAGE_TIFF;
      break;
    case CB_FORMAT_GIF:
      mime_type = GRD_MIME_TYPE_IMAGE_GIF;
      break;
    case CB_FORMAT_JPEG:
      mime_type = GRD_MIME_TYPE_IMAGE_JPEG;
      break;
    case CB_FORMAT_PNG:
      mime_type = GRD_MIME_TYPE_IMAGE_PNG;
      break;
    case CB_FORMAT_TEXTURILIST:
      mime_type = GRD_MIME_TYPE_TEXT_URILIST;
      needs_conversion = TRUE;
      src_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "text/uri-list");
      dst_format_id = ClipboardGetFormatId (clipboard_rdp->system,
                                            "FileGroupDescriptorW");
      break;
    }

if (clipboard_rdp->server_format_data_request_id)
    {
      g_debug ("[RDP.CLIPRDR] Wrong message sequence: Got new format data "
               "request without being able to push response for last request "
               "yet.");
    }

events[0] = clipboard_rdp->stop_event;
  events[1] = clipboard_rdp->completed_format_data_request_event;
  WaitForMultipleObjects (2, events, FALSE, INFINITE);

if (WaitForSingleObject (clipboard_rdp->stop_event, 0) == WAIT_OBJECT_0)
    return CHANNEL_RC_OK;

if (mime_type != GRD_MIME_TYPE_NONE)
    {
      ResetEvent (clipboard_rdp->completed_format_data_request_event);
      request_context = g_malloc0 (sizeof (ServerFormatDataRequestContext));
      request_context->clipboard_rdp = clipboard_rdp;
      request_context->mime_type = mime_type;
      request_context->src_format_id = src_format_id;
      request_context->dst_format_id = dst_format_id;
      request_context->needs_null_terminator = needs_null_terminator;
      request_context->needs_conversion = needs_conversion;

clipboard_rdp->server_format_data_request_id =
        g_idle_add (request_server_format_data, request_context);
      SetEvent (clipboard_rdp->format_data_request_received_event);

return CHANNEL_RC_OK;
    }

format_data_response.msgType = CB_FORMAT_DATA_RESPONSE;
  format_data_response.msgFlags = CB_RESPONSE_FAIL;
  format_data_response.dataLen = 0;
  format_data_response.requestedFormatData = NULL;

return cliprdr_context->ServerFormatDataResponse (cliprdr_context,
                                                    &format_data_response);
}

/**
 * Clients response to our data request that we sent
 */
static uint32_t
cliprdr_client_format_data_response (CliprdrServerContext               *cliprdr_context,
                                     const CLIPRDR_FORMAT_DATA_RESPONSE *format_data_response)
{
  GrdClipboardRdp *clipboard_rdp = cliprdr_context->custom;

if (clipboard_rdp->format_data_response)
    g_free ((uint8_t *) clipboard_rdp->format_data_response->requestedFormatData);
  g_clear_pointer (&clipboard_rdp->format_data_response, g_free);

clipboard_rdp->format_data_response =
    g_memdup2 (format_data_response,
               sizeof (CLIPRDR_FORMAT_DATA_RESPONSE));
  clipboard_rdp->format_data_response->requestedFormatData =
    g_memdup2 (format_data_response->requestedFormatData,
               format_data_response->dataLen);
  SetEvent (clipboard_rdp->format_data_received_event);

return CHANNEL_RC_OK;
}

static uint32_t
delegate_request_file_contents_size (wClipboardDelegate                  *delegate,
                                     const CLIPRDR_FILE_CONTENTS_REQUEST *file_contents_request)
{
  wClipboardFileSizeRequest file_size_request = {0};

file_size_request.streamId = file_contents_request->streamId;
  file_size_request.listIndex = file_contents_request->listIndex;

return delegate->ClientRequestFileSize (delegate, &file_size_request);
}

static uint32_t
delegate_request_file_contents_range (wClipboardDelegate                  *delegate,
                                      const CLIPRDR_FILE_CONTENTS_REQUEST *file_contents_request)
{
  wClipboardFileRangeRequest file_range_request = {0};

file_range_request.streamId = file_contents_request->streamId;
  file_range_request.listIndex = file_contents_request->listIndex;
  file_range_request.nPositionLow = file_contents_request->nPositionLow;
  file_range_request.nPositionHigh = file_contents_request->nPositionHigh;
  file_range_request.cbRequested = file_contents_request->cbRequested;

return delegate->ClientRequestFileRange (delegate, &file_range_request);
}

static uint32_t
send_file_contents_response_failure (CliprdrServerContext *cliprdr_context,
                                     uint32_t              stream_id)
{
  CLIPRDR_FILE_CONTENTS_RESPONSE file_contents_response = {0};

file_contents_response.msgType = CB_FILECONTENTS_RESPONSE;
  file_contents_response.msgFlags = CB_RESPONSE_FAIL;
  file_contents_response.streamId = stream_id;

return cliprdr_context->ServerFileContentsResponse (cliprdr_context,
                                                      &file_contents_response);
}

/**
 * Client requests us to send either the size of the remote file or a portion
 * of the data in the file
 */
static uint32_t
cliprdr_client_file_contents_request (CliprdrServerContext                *cliprdr_context,
                                      const CLIPRDR_FILE_CONTENTS_REQUEST *file_contents_request)
{
  GrdClipboardRdp *clipboard_rdp = cliprdr_context->custom;
  wClipboardDelegate *delegate = clipboard_rdp->delegate;
  gboolean has_file_list = clipboard_rdp->has_file_list;
  gboolean requests_allowed = clipboard_rdp->server_file_contents_requests_allowed;
  uint32_t clip_data_id = file_contents_request->clipDataId;
  uint32_t stream_id = file_contents_request->streamId;
  ClipDataEntry *entry = NULL;
  uint32_t error = NO_ERROR;

if (file_contents_request->haveClipDataId)
    g_debug ("[RDP.CLIPRDR] FileContentsRequest has clipDataId %u", clip_data_id);
  else
    g_debug ("[RDP.CLIPRDR] FileContentsRequest does not have a clipDataId");

if (file_contents_request->haveClipDataId)
    {
      if (!g_hash_table_lookup_extended (clipboard_rdp->clip_data_table,
                                         GUINT_TO_POINTER (clip_data_id),
                                         NULL, (gpointer *) &entry))
        return send_file_contents_response_failure (cliprdr_context, stream_id);

if (!entry->requests_allowed)
        {
          g_debug ("[RDP.CLIPRDR] ClipDataEntry with id %u is not eligible of "
                   "requesting file contents.", clip_data_id);
        }

delegate = entry->delegate;
      has_file_list = entry->has_file_list;
      requests_allowed = entry->requests_allowed;
    }

if (!requests_allowed || !has_file_list)
    return send_file_contents_response_failure (cliprdr_context, stream_id);

if (file_contents_request->dwFlags & FILECONTENTS_SIZE &&
      file_contents_request->dwFlags & FILECONTENTS_RANGE)
    {
      /**
       * FILECONTENTS_SIZE and FILECONTENTS_RANGE are not allowed
       * to be set at the same time
       */
      return send_file_contents_response_failure (cliprdr_context, stream_id);
    }

if (file_contents_request->dwFlags & FILECONTENTS_SIZE)
    {
      error = delegate_request_file_contents_size (delegate,
                                                   file_contents_request);
    }
  else if (file_contents_request->dwFlags & FILECONTENTS_RANGE)
    {
      error = delegate_request_file_contents_range (delegate,
                                                    file_contents_request);
    }
  else
    {
      error = ERROR_INVALID_DATA;
    }

if (error)
    return send_file_contents_response_failure (cliprdr_context, stream_id);

return CHANNEL_RC_OK;
}

/**
 * Clients response to our file contents request that we sent
 */
static uint32_t
cliprdr_client_file_contents_response (CliprdrServerContext                 *cliprdr_context,
                                       const CLIPRDR_FILE_CONTENTS_RESPONSE *file_contents_response)
{
  GrdClipboardRdp *clipboard_rdp = cliprdr_context->custom;
  GrdRdpFuseClipboard *rdp_fuse_clipboard = clipboard_rdp->rdp_fuse_clipboard;

grd_rdp_fuse_clipboard_submit_file_contents_response (
    rdp_fuse_clipboard, file_contents_response->streamId,
    file_contents_response->msgFlags & CB_RESPONSE_OK,
    file_contents_response->requestedData,
    file_contents_response->cbRequested);

return CHANNEL_RC_OK;
}

static uint32_t
cliprdr_file_size_success (wClipboardDelegate              *delegate,
                           const wClipboardFileSizeRequest *file_size_request,
                           uint64_t                         file_size)
{
  GrdClipboardRdp *clipboard_rdp = delegate->custom;
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_FILE_CONTENTS_RESPONSE file_contents_response = {0};

file_contents_response.msgType = CB_FILECONTENTS_RESPONSE;
  file_contents_response.msgFlags = CB_RESPONSE_OK;
  file_contents_response.streamId = file_size_request->streamId;
  file_contents_response.cbRequested = sizeof (uint64_t);
  file_contents_response.requestedData = (uint8_t *) &file_size;

return cliprdr_context->ServerFileContentsResponse (cliprdr_context,
                                                      &file_contents_response);
}

static uint32_t
cliprdr_file_size_failure (wClipboardDelegate              *delegate,
                           const wClipboardFileSizeRequest *file_size_request,
                           uint32_t                         error)
{
  GrdClipboardRdp *clipboard_rdp = delegate->custom;

return send_file_contents_response_failure (clipboard_rdp->cliprdr_context,
                                              file_size_request->streamId);
}

static uint32_t
cliprdr_file_range_success (wClipboardDelegate               *delegate,
                            const wClipboardFileRangeRequest *file_range_request,
                            const uint8_t                    *data,
                            uint32_t                          size)
{
  GrdClipboardRdp *clipboard_rdp = delegate->custom;
  CliprdrServerContext *cliprdr_context = clipboard_rdp->cliprdr_context;
  CLIPRDR_FILE_CONTENTS_RESPONSE file_contents_response = {0};

file_contents_response.msgType = CB_FILECONTENTS_RESPONSE;
  file_contents_response.msgFlags = CB_RESPONSE_OK;
  file_contents_response.streamId = file_range_request->streamId;
  file_contents_response.cbRequested = size;
  file_contents_response.requestedData = data;

return cliprdr_context->ServerFileContentsResponse (cliprdr_context,
                                                      &file_contents_response);
}

static uint32_t
cliprdr_file_range_failure (wClipboardDelegate               *delegate,
                            const wClipboardFileRangeRequest *file_range_request,
                            uint32_t                          error)
{
  GrdClipboardRdp *clipboard_rdp = delegate->custom;

return send_file_contents_response_failure (clipboard_rdp->cliprdr_context,
                                              file_range_request->streamId);
}

static void
create_new_winpr_clipboard (GrdClipboardRdp *clipboard_rdp)
{
  g_debug ("[RDP.CLIPRDR] Creating new WinPR clipboard");

clipboard_rdp->system = ClipboardCreate ();
  clipboard_rdp->delegate = ClipboardGetDelegate (clipboard_rdp->system);
  clipboard_rdp->delegate->ClipboardFileSizeSuccess = cliprdr_file_size_success;
  clipboard_rdp->delegate->ClipboardFileSizeFailure = cliprdr_file_size_failure;
  clipboard_rdp->delegate->ClipboardFileRangeSuccess = cliprdr_file_range_success;
  clipboard_rdp->delegate->ClipboardFileRangeFailure = cliprdr_file_range_failure;
  clipboard_rdp->delegate->basePath = NULL;
  clipboard_rdp->delegate->custom = clipboard_rdp;

clipboard_rdp->has_file_list = FALSE;
}

GrdClipboardRdp *
grd_clipboard_rdp_new (GrdSessionRdp *session_rdp,
                       HANDLE         vcm,
                       HANDLE         stop_event)
{
  GrdClipboardRdp *clipboard_rdp;
  GrdClipboard *clipboard;
  CliprdrServerContext *cliprdr_context;

clipboard_rdp = g_object_new (GRD_TYPE_CLIPBOARD_RDP, NULL);
  cliprdr_context = cliprdr_server_context_new (vcm);
  if (!clipboard_rdp || !cliprdr_context)
    {
      g_warning ("[RDP.CLIPRDR] An error occurred while creating the RDP clipboard");
      g_clear_pointer (&cliprdr_context, cliprdr_server_context_free);
      g_clear_object (&clipboard_rdp);
      return NULL;
    }

clipboard_rdp->cliprdr_context = cliprdr_context;
  clipboard_rdp->stop_event = stop_event;

clipboard = GRD_CLIPBOARD (clipboard_rdp);
  grd_clipboard_initialize (clipboard, GRD_SESSION (session_rdp));

cliprdr_context->useLongFormatNames = TRUE;
  cliprdr_context->streamFileClipEnabled = TRUE;
  cliprdr_context->fileClipNoFilePaths = TRUE;
  cliprdr_context->canLockClipData = TRUE;
#ifdef HAVE_FREERDP_2_3
  cliprdr_context->hasHugeFileSupport = TRUE;
#endif /* HAVE_FREERDP_2_3 */

cliprdr_context->ClientCapabilities = cliprdr_client_capabilities;
  cliprdr_context->TempDirectory = cliprdr_temp_directory;
  cliprdr_context->ClientFormatList = cliprdr_client_format_list;
  cliprdr_context->ClientFormatListResponse = cliprdr_client_format_list_response;
  cliprdr_context->ClientLockClipboardData = cliprdr_client_lock_clipboard_data;
  cliprdr_context->ClientUnlockClipboardData = cliprdr_client_unlock_clipboard_data;
  cliprdr_context->ClientFormatDataRequest = cliprdr_client_format_data_request;
  cliprdr_context->ClientFormatDataResponse = cliprdr_client_format_data_response;
  cliprdr_context->ClientFileContentsRequest = cliprdr_client_file_contents_request;
  cliprdr_context->ClientFileContentsResponse = cliprdr_client_file_contents_response;
  cliprdr_context->custom = clipboard_rdp;

if (cliprdr_context->Start (cliprdr_context))
    {
      g_message ("[RDP.CLIPRDR] An error occurred while starting the RDP "
                 "clipboard. The RDP client might not support the CLIPRDR channel");
      g_clear_pointer (&clipboard_rdp->cliprdr_context,
                       cliprdr_server_context_free);
      g_clear_object (&clipboard_rdp);
      return NULL;
    }

return clipboard_rdp;
}

static gboolean
clear_format_data (gpointer key,
                   gpointer value,
                   gpointer user_data)
{
  FormatData *format_data = value;

g_free (format_data->data);
  g_free (format_data);

return TRUE;
}

static void
grd_clipboard_rdp_dispose (GObject *object)
{
  GrdClipboardRdp *clipboard_rdp = GRD_CLIPBOARD_RDP (object);
  GrdClipboard *clipboard = GRD_CLIPBOARD (clipboard_rdp);

if (clipboard_rdp->cliprdr_context)
    {
      clipboard_rdp->cliprdr_context->Stop (clipboard_rdp->cliprdr_context);
      grd_clipboard_disable_clipboard (clipboard);
    }

if (clipboard_rdp->format_data_response)
    g_free ((uint8_t *) clipboard_rdp->format_data_response->requestedFormatData);
  g_clear_pointer (&clipboard_rdp->format_data_response, g_free);

if (clipboard_rdp->clipboard_retrieval_id)
    g_clear_pointer (&clipboard_rdp->clipboard_retrieval_context.entry, g_free);

g_clear_pointer (&clipboard_rdp->queued_server_formats, g_list_free);
  g_clear_pointer (&clipboard_rdp->pending_server_formats, g_list_free);
  g_hash_table_foreach_remove (clipboard_rdp->format_data_cache,
                               clear_format_data,
                               NULL);

g_clear_object (&clipboard_rdp->rdp_fuse_clipboard);
  rmdir (clipboard_rdp->fuse_mount_path);
  g_clear_pointer (&clipboard_rdp->fuse_mount_path, g_free);
  g_clear_pointer (&clipboard_rdp->format_data_cache, g_hash_table_unref);
  g_clear_pointer (&clipboard_rdp->clip_data_table, g_hash_table_destroy);
  g_clear_pointer (&clipboard_rdp->serial_entry_table, g_hash_table_destroy);
  g_clear_pointer (&clipboard_rdp->allowed_server_formats, g_hash_table_destroy);
  g_clear_pointer (&clipboard_rdp->format_data_request_received_event,
                   CloseHandle);
  g_clear_pointer (&clipboard_rdp->format_list_response_received_event,
                   CloseHandle);
  g_clear_pointer (&clipboard_rdp->format_list_received_event, CloseHandle);
  g_clear_pointer (&clipboard_rdp->completed_format_data_request_event,
                   CloseHandle);
  g_clear_pointer (&clipboard_rdp->completed_format_list_event, CloseHandle);
  g_clear_pointer (&clipboard_rdp->completed_clip_data_entry_event,
                   CloseHandle);
  g_clear_pointer (&clipboard_rdp->clip_data_entry_event, CloseHandle);
  g_clear_pointer (&clipboard_rdp->format_data_received_event, CloseHandle);
  g_clear_pointer (&clipboard_rdp->system, ClipboardDestroy);
  g_clear_pointer (&clipboard_rdp->cliprdr_context, cliprdr_server_context_free);

g_clear_handle_id (&clipboard_rdp->pending_server_formats_drop_id, g_source_remove);
  g_clear_handle_id (&clipboard_rdp->clipboard_retrieval_id, g_source_remove);
  g_clear_handle_id (&clipboard_rdp->clipboard_destruction_id, g_source_remove);
  g_clear_handle_id (&clipboard_rdp->server_format_list_update_id, g_source_remove);
  g_clear_handle_id (&clipboard_rdp->server_format_data_request_id, g_source_remove);
  g_clear_handle_id (&clipboard_rdp->client_format_list_response_id, g_source_remove);

G_OBJECT_CLASS (grd_clipboard_rdp_parent_class)->dispose (object);
}

static void
clip_data_entry_free (gpointer data)
{
  ClipDataEntry *entry = data;

g_debug ("[RDP.CLIPRDR] Freeing ClipDataEntry with id %u and serial %lu. "
           "ClipDataEntry is independent: %s", entry->id, entry->serial,
           entry->is_independent ? "true" : "false");

if (entry->is_independent)
    g_clear_pointer (&entry->system, ClipboardDestroy);

g_free (entry);
}

static void
grd_clipboard_rdp_init (GrdClipboardRdp *clipboard_rdp)
{
  const char *grd_path = "/gnome-remote-desktop";
  const char *cliprdr_template = "/cliprdr-XXXXXX";
  g_autofree char *base_path = NULL;
  g_autofree char *template_path = NULL;

base_path = g_strdup_printf ("%s%s", g_get_user_runtime_dir (), grd_path);
  template_path = g_strdup_printf ("%s%s", base_path, cliprdr_template);

if (g_access (base_path, F_OK))
    {
      if (mkdir (base_path, 0700))
        {
          g_error ("Failed to create clipboard cache directory %s: %s",
                   base_path, g_strerror (errno));
        }
    }
  if (!mkdtemp (template_path))
    {
      g_error ("Failed to create clipboard file directory %s: %s",
               template_path, g_strerror (errno));
    }

clipboard_rdp->format_data_received_event =
    CreateEvent (NULL, TRUE, FALSE, NULL);
  clipboard_rdp->clip_data_entry_event =
    CreateEvent (NULL, TRUE, FALSE, NULL);
  clipboard_rdp->completed_clip_data_entry_event =
    CreateEvent (NULL, TRUE, TRUE, NULL);
  clipboard_rdp->completed_format_list_event =
    CreateEvent (NULL, TRUE, TRUE, NULL);
  clipboard_rdp->completed_format_data_request_event =
    CreateEvent (NULL, TRUE, TRUE, NULL);
  clipboard_rdp->format_list_received_event =
    CreateEvent (NULL, TRUE, FALSE, NULL);
  clipboard_rdp->format_list_response_received_event =
    CreateEvent (NULL, TRUE, FALSE, NULL);
  clipboard_rdp->format_data_request_received_event =
    CreateEvent (NULL, TRUE, FALSE, NULL);

clipboard_rdp->allowed_server_formats = g_hash_table_new (NULL, NULL);
  clipboard_rdp->serial_entry_table = g_hash_table_new_full (NULL, NULL, NULL,
                                                             clip_data_entry_free);
  clipboard_rdp->clip_data_table = g_hash_table_new (NULL, NULL);
  clipboard_rdp->format_data_cache = g_hash_table_new (NULL, NULL);

clipboard_rdp->fuse_mount_path = g_steal_pointer (&template_path);
  clipboard_rdp->rdp_fuse_clipboard =
    grd_rdp_fuse_clipboard_new (clipboard_rdp, clipboard_rdp->fuse_mount_path);
}

static void
grd_clipboard_rdp_class_init (GrdClipboardRdpClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GrdClipboardClass *clipboard_class = GRD_CLIPBOARD_CLASS (klass);

object_class->dispose = grd_clipboard_rdp_dispose;

clipboard_class->update_client_mime_type_list =
    grd_clipboard_rdp_update_client_mime_type_list;
  clipboard_class->request_client_content_for_mime_type =
    grd_clipboard_rdp_request_client_content_for_mime_type;
}
0707010000000F000081A40000000000000000000000016141EE1000000A9C000000000000000000000000000000000000003200000000gnome-remote-desktop-40.2/src/grd-clipboard-rdp.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_CLIPBOARD_RDP_H
#define GRD_CLIPBOARD_RDP_H

#include <freerdp/server/cliprdr.h>

#include "grd-clipboard.h"

#define GRD_TYPE_CLIPBOARD_RDP (grd_clipboard_rdp_get_type ())
G_DECLARE_FINAL_TYPE (GrdClipboardRdp,
                      grd_clipboard_rdp,
                      GRD, CLIPBOARD_RDP,
                      GrdClipboard);

GrdClipboardRdp *grd_clipboard_rdp_new (GrdSessionRdp *session_rdp,
                                        HANDLE         vcm,
                                        HANDLE         stop_event);

void grd_clipboard_rdp_lock_remote_clipboard_data (GrdClipboardRdp *clipboard_rdp,
                                                   uint32_t         clip_data_id);

void grd_clipboard_rdp_unlock_remote_clipboard_data (GrdClipboardRdp *clipboard_rdp,
                                                     uint32_t         clip_data_id);

void grd_clipboard_rdp_request_remote_file_size_async (GrdClipboardRdp *clipboard_rdp,
                                                       uint32_t         stream_id,
                                                       uint32_t         list_index,
                                                       gboolean         has_clip_data_id,
                                                       uint32_t         clip_data_id);

void grd_clipboard_rdp_request_remote_file_range_async (GrdClipboardRdp *clipboard_rdp,
                                                        uint32_t         stream_id,
                                                        uint32_t         list_index,
                                                        uint64_t         offset,
                                                        uint32_t         requested_size,
                                                        gboolean         has_clip_data_id,
                                                        uint32_t         clip_data_id);

#endif /* GRD_CLIPBOARD_RDP_H */
07070100000010000081A40000000000000000000000016141EE100000194E000000000000000000000000000000000000003200000000gnome-remote-desktop-40.2/src/grd-clipboard-vnc.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-clipboard-vnc.h"

#include "grd-session-vnc.h"

struct _GrdClipboardVnc
{
  GrdClipboard parent;

GrdSessionVnc *session_vnc;

char *clipboard_utf8_string;
};

G_DEFINE_TYPE (GrdClipboardVnc, grd_clipboard_vnc, GRD_TYPE_CLIPBOARD);

static void
update_vnc_clipboard (GrdClipboardVnc *clipboard_vnc,
                      GrdMimeType      text_mime_type)
{
  GrdClipboard *clipboard = GRD_CLIPBOARD (clipboard_vnc);
  g_autoptr (GError) error = NULL;
  uint8_t *src_data;
  uint32_t src_size;
  char *dst_data;

src_data = grd_clipboard_request_server_content_for_mime_type (clipboard,
                                                                 text_mime_type,
                                                                 &src_size);
  if (!src_data)
    return;

dst_data = g_convert ((char *) src_data, src_size,
                        "iso8859-1", "utf-8",
                        NULL, NULL, &error);
  if (!dst_data)
    {
      g_warning ("[VNC.Clipboard] Failed to convert clipboard content: %s",
                 error->message);
      return;
    }

grd_session_vnc_set_client_clipboard_text (clipboard_vnc->session_vnc,
                                             dst_data, strlen (dst_data));

g_free (dst_data);
}

static void
grd_clipboard_vnc_update_client_mime_type_list (GrdClipboard *clipboard,
                                                GList        *mime_type_list)
{
  GrdClipboardVnc *clipboard_vnc = GRD_CLIPBOARD_VNC (clipboard);
  gboolean found_utf8_string = FALSE;
  GrdMimeType mime_type;
  GList *l;

for (l = mime_type_list; l && !found_utf8_string; l = l->next)
    {
      mime_type = GPOINTER_TO_UINT (l->data);
      switch (mime_type)
        {
        case GRD_MIME_TYPE_TEXT_PLAIN:
          break;
        case GRD_MIME_TYPE_TEXT_PLAIN_UTF8:
        case GRD_MIME_TYPE_TEXT_UTF8_STRING:
          found_utf8_string = TRUE;
          break;
        case GRD_MIME_TYPE_TEXT_HTML:
        case GRD_MIME_TYPE_IMAGE_BMP:
        case GRD_MIME_TYPE_IMAGE_TIFF:
        case GRD_MIME_TYPE_IMAGE_GIF:
        case GRD_MIME_TYPE_IMAGE_JPEG:
        case GRD_MIME_TYPE_IMAGE_PNG:
        case GRD_MIME_TYPE_TEXT_URILIST:
        case GRD_MIME_TYPE_XS_GNOME_COPIED_FILES:
          break;
        default:
          g_assert_not_reached ();
        }
    }

if (found_utf8_string)
    {
      g_clear_pointer (&clipboard_vnc->clipboard_utf8_string, g_free);

update_vnc_clipboard (clipboard_vnc, mime_type);
    }

g_list_free (mime_type_list);
}

static uint8_t *
grd_clipboard_vnc_request_client_content_for_mime_type (GrdClipboard     *clipboard,
                                                        GrdMimeTypeTable *mime_type_table,
                                                        uint32_t         *size)
{
  GrdClipboardVnc *clipboard_vnc = GRD_CLIPBOARD_VNC (clipboard);

*size = strlen (clipboard_vnc->clipboard_utf8_string);

return g_memdup2 (clipboard_vnc->clipboard_utf8_string, *size);
}

void
grd_clipboard_vnc_maybe_enable_clipboard (GrdClipboardVnc *clipboard_vnc)
{
  grd_clipboard_maybe_enable_clipboard (GRD_CLIPBOARD (clipboard_vnc));
}

void
grd_clipboard_vnc_set_clipboard_text (GrdClipboardVnc *clipboard_vnc,
                                      char            *text,
                                      int              text_length)
{
  GrdClipboard *clipboard = GRD_CLIPBOARD (clipboard_vnc);
  g_autoptr (GError) error = NULL;
  GrdMimeTypeTable *mime_type_table;
  GList *mime_type_tables = NULL;

g_clear_pointer (&clipboard_vnc->clipboard_utf8_string, g_free);

clipboard_vnc->clipboard_utf8_string = g_convert (text, text_length,
                                                    "utf-8", "iso8859-1",
                                                    NULL, NULL, &error);
  if (!clipboard_vnc->clipboard_utf8_string)
    {
      g_warning ("[VNC.Clipboard] Failed to convert clipboard content: %s",
                 error->message);
      return;
    }

mime_type_table = g_malloc0 (sizeof (GrdMimeTypeTable));
  mime_type_table->mime_type = GRD_MIME_TYPE_TEXT_PLAIN_UTF8;
  mime_type_tables = g_list_append (mime_type_tables, mime_type_table);

mime_type_table = g_malloc0 (sizeof (GrdMimeTypeTable));
  mime_type_table->mime_type = GRD_MIME_TYPE_TEXT_UTF8_STRING;
  mime_type_tables = g_list_append (mime_type_tables, mime_type_table);

grd_clipboard_update_server_mime_type_list (clipboard, mime_type_tables);
}

GrdClipboardVnc *
grd_clipboard_vnc_new (GrdSessionVnc *session_vnc)
{
  GrdClipboardVnc *clipboard_vnc;

clipboard_vnc = g_object_new (GRD_TYPE_CLIPBOARD_VNC, NULL);
  clipboard_vnc->session_vnc = session_vnc;

grd_clipboard_initialize (GRD_CLIPBOARD (clipboard_vnc),
                            GRD_SESSION (session_vnc));

return clipboard_vnc;
}

static void
grd_clipboard_vnc_dispose (GObject *object)
{
  GrdClipboardVnc *clipboard_vnc = GRD_CLIPBOARD_VNC (object);

grd_clipboard_disable_clipboard (GRD_CLIPBOARD (clipboard_vnc));
  g_clear_pointer (&clipboard_vnc->clipboard_utf8_string, g_free);

G_OBJECT_CLASS (grd_clipboard_vnc_parent_class)->dispose (object);
}

static void
grd_clipboard_vnc_init (GrdClipboardVnc *clipboard_vnc)
{
}

static void
grd_clipboard_vnc_class_init (GrdClipboardVncClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GrdClipboardClass *clipboard_class = GRD_CLIPBOARD_CLASS (klass);

object_class->dispose = grd_clipboard_vnc_dispose;

clipboard_class->update_client_mime_type_list =
    grd_clipboard_vnc_update_client_mime_type_list;
  clipboard_class->request_client_content_for_mime_type =
    grd_clipboard_vnc_request_client_content_for_mime_type;
}
07070100000011000081A40000000000000000000000016141EE10000005C0000000000000000000000000000000000000003200000000gnome-remote-desktop-40.2/src/grd-clipboard-vnc.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_CLIPBOARD_VNC_H
#define GRD_CLIPBOARD_VNC_H

#include "grd-clipboard.h"

#define GRD_TYPE_CLIPBOARD_VNC (grd_clipboard_vnc_get_type ())
G_DECLARE_FINAL_TYPE (GrdClipboardVnc,
                      grd_clipboard_vnc,
                      GRD, CLIPBOARD_VNC,
                      GrdClipboard);

GrdClipboardVnc *grd_clipboard_vnc_new (GrdSessionVnc *session_vnc);

void grd_clipboard_vnc_maybe_enable_clipboard (GrdClipboardVnc *clipboard_vnc);

void grd_clipboard_vnc_set_clipboard_text (GrdClipboardVnc *clipboard_vnc,
                                           char            *text,
                                           int              text_length);

#endif /* GRD_CLIPBOARD_VNC_H */
07070100000012000081A40000000000000000000000016141EE1000001BEE000000000000000000000000000000000000002E00000000gnome-remote-desktop-40.2/src/grd-clipboard.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-clipboard.h"

#include "grd-session.h"

typedef struct _GrdClipboardPrivate
{
  GrdSession *session;

gboolean enabled;

GHashTable *client_mime_type_tables;
} GrdClipboardPrivate;

G_DEFINE_TYPE_WITH_PRIVATE (GrdClipboard, grd_clipboard, G_TYPE_OBJECT);

void
grd_clipboard_update_server_mime_type_list (GrdClipboard *clipboard,
                                            GList        *mime_type_tables)
{
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);
  GList *l;

g_debug ("Clipboard[SetSelection]: Updating servers clipboard");
  for (l = mime_type_tables; l; l = l->next)
    {
      GrdMimeTypeTable *mime_type_table = l->data;
      GrdMimeType mime_type;

mime_type = mime_type_table->mime_type;
      g_debug ("Clipboard[SetSelection]: Update contains mime type %s",
               grd_mime_type_to_string (mime_type));

g_hash_table_insert (priv->client_mime_type_tables,
                           GUINT_TO_POINTER (mime_type), mime_type_table);
    }

if (!priv->enabled)
    {
      g_debug ("Clipboard[EnableClipboard]: Enabling clipboard");
      priv->enabled = grd_session_enable_clipboard (priv->session,
                                                    clipboard, mime_type_tables);
      if (priv->enabled)
        g_debug ("Clipboard[EnableClipboard]: Clipboard enabled");
      else
        g_debug ("Clipboard[EnableClipboard]: Clipboard could not be enabled");
    }
  else
    {
      if (mime_type_tables)
        grd_session_set_selection (priv->session, mime_type_tables);
    }
  g_debug ("Clipboard[SetSelection]: Update complete");

g_list_free (mime_type_tables);
}

uint8_t *
grd_clipboard_request_server_content_for_mime_type (GrdClipboard *clipboard,
                                                    GrdMimeType   mime_type,
                                                    uint32_t     *size)
{
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);
  uint8_t *data;

*size = 0;
  if (!priv->enabled)
    return NULL;

g_debug ("Clipboard[SelectionRead]: Requesting data from servers clipboard"
           " (mime type: %s)", grd_mime_type_to_string (mime_type));
  data = grd_session_selection_read (priv->session, mime_type, size);
  if (data)
    g_debug ("Clipboard[SelectionRead]: Request successful");
  else
    g_debug ("Clipboard[SelectionRead]: Request failed");

return data;
}

void
grd_clipboard_initialize (GrdClipboard *clipboard,
                          GrdSession   *session)
{
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);

priv->session = session;
}

void
grd_clipboard_maybe_enable_clipboard (GrdClipboard *clipboard)
{
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);

g_debug ("Clipboard[EnableClipboard]: Enabling clipboard");
  if (priv->enabled)
    {
      g_debug ("Clipboard[EnableClipboard]: Clipboard already enabled");
      return;
    }

priv->enabled = grd_session_enable_clipboard (priv->session, clipboard, NULL);
  if (priv->enabled)
    g_debug ("Clipboard[EnableClipboard]: Clipboard enabled");
  else
    g_debug ("Clipboard[EnableClipboard]: Clipboard could not be enabled");
}

void
grd_clipboard_disable_clipboard (GrdClipboard *clipboard)
{
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);

if (!priv->enabled)
    return;

g_debug ("Clipboard[DisableClipboard]: Disabling clipboard");
  grd_session_disable_clipboard (priv->session);
  priv->enabled = FALSE;
}

void
grd_clipboard_update_client_mime_type_list (GrdClipboard *clipboard,
                                            GList        *mime_type_list)
{
  GrdClipboardClass *klass = GRD_CLIPBOARD_GET_CLASS (clipboard);
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);
  GList *l;

if (!klass->update_client_mime_type_list)
    return;

for (l = mime_type_list; l; l = l->next)
    g_hash_table_remove (priv->client_mime_type_tables, l->data);

g_debug ("Clipboard[SelectionOwnerChanged]: Updating clients clipboard");
  klass->update_client_mime_type_list (clipboard, mime_type_list);
  g_debug ("Clipboard[SelectionOwnerChanged]: Update complete");
}

uint8_t *
grd_clipboard_request_client_content_for_mime_type (GrdClipboard *clipboard,
                                                    GrdMimeType   mime_type,
                                                    uint32_t     *size)
{
  GrdClipboardClass *klass = GRD_CLIPBOARD_GET_CLASS (clipboard);
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);
  GrdMimeTypeTable *mime_type_table = NULL;
  uint8_t *mime_type_content = NULL;

*size = 0;

if (!klass->request_client_content_for_mime_type)
    return NULL;

g_debug ("Clipboard[SelectionTransfer]: Requesting data from clients clipboard"
           " (mime type: %s)", grd_mime_type_to_string (mime_type));
  mime_type_table = g_hash_table_lookup (priv->client_mime_type_tables,
                                         GUINT_TO_POINTER (mime_type));
  if (mime_type_table)
    {
      mime_type_content = klass->request_client_content_for_mime_type (
                            clipboard, mime_type_table, size);
    }
  if (mime_type_content)
    g_debug ("Clipboard[SelectionTransfer]: Request successful");
  else
    g_debug ("Clipboard[SelectionTransfer]: Request failed");

return mime_type_content;
}

static void
free_mime_type_table (gpointer data)
{
  GrdMimeTypeTable *mime_type_table = data;

g_free (mime_type_table);
}

static void
grd_clipboard_dispose (GObject *object)
{
  GrdClipboard *clipboard = GRD_CLIPBOARD (object);
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);

g_clear_pointer (&priv->client_mime_type_tables, g_hash_table_destroy);

G_OBJECT_CLASS (grd_clipboard_parent_class)->dispose (object);
}

static void
grd_clipboard_init (GrdClipboard *clipboard)
{
  GrdClipboardPrivate *priv = grd_clipboard_get_instance_private (clipboard);

priv->client_mime_type_tables = g_hash_table_new_full (NULL, NULL, NULL,
                                                         free_mime_type_table);
}

static void
grd_clipboard_class_init (GrdClipboardClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->dispose = grd_clipboard_dispose;
}
07070100000013000081A40000000000000000000000016141EE1000000A1C000000000000000000000000000000000000002E00000000gnome-remote-desktop-40.2/src/grd-clipboard.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_CLIPBOARD_H
#define GRD_CLIPBOARD_H

#include <glib-object.h>
#include <stdint.h>

#include "grd-mime-type.h"
#include "grd-types.h"

#define GRD_TYPE_CLIPBOARD (grd_clipboard_get_type ())
G_DECLARE_DERIVABLE_TYPE (GrdClipboard, grd_clipboard, GRD, CLIPBOARD, GObject);

struct _GrdClipboardClass
{
  GObjectClass parent_class;

void (*update_client_mime_type_list) (GrdClipboard *clipboard,
                                        GList        *mime_type_list);
  uint8_t *(*request_client_content_for_mime_type) (GrdClipboard     *clipboard,
                                                    GrdMimeTypeTable *mime_type_table,
                                                    uint32_t         *size);
};

void grd_clipboard_update_server_mime_type_list (GrdClipboard *clipboard,
                                                 GList        *mime_type_tables);

uint8_t *grd_clipboard_request_server_content_for_mime_type (GrdClipboard *clipboard,
                                                             GrdMimeType   mime_type,
                                                             uint32_t     *size);

void grd_clipboard_initialize (GrdClipboard *clipboard,
                               GrdSession   *session);

void grd_clipboard_maybe_enable_clipboard (GrdClipboard *clipboard);

void grd_clipboard_disable_clipboard (GrdClipboard *clipboard);

void grd_clipboard_update_client_mime_type_list (GrdClipboard *clipboard,
                                                 GList        *mime_type_list);

uint8_t *grd_clipboard_request_client_content_for_mime_type (GrdClipboard *clipboard,
                                                             GrdMimeType   mime_type,
                                                             uint32_t     *size);

#endif /* GRD_CLIPBOARD_H */
07070100000014000081A40000000000000000000000016141EE1000000E49000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/src/grd-context.c/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#include "config.h"

#include "grd-context.h"

#include "grd-dbus-remote-desktop.h"
#include "grd-dbus-screen-cast.h"

static const GDebugKey grd_debug_keys[] = {
  { "vnc", GRD_DEBUG_VNC },
};

struct _GrdContext
{
  GObject parent;

GMainContext *main_context;

GrdDBusRemoteDesktop *remote_desktop_proxy;
  GrdDBusScreenCast *screen_cast_proxy;

GrdSettings *settings;

GList *sessions;

GrdDebugFlags debug_flags;
};

G_DEFINE_TYPE (GrdContext, grd_context, G_TYPE_OBJECT);

GrdDBusRemoteDesktop *
grd_context_get_remote_desktop_proxy (GrdContext *context)
{
  return context->remote_desktop_proxy;
}

GrdDBusScreenCast *
grd_context_get_screen_cast_proxy (GrdContext *context)
{
  return context->screen_cast_proxy;
}

void
grd_context_set_remote_desktop_proxy (GrdContext           *context,
                                      GrdDBusRemoteDesktop *proxy)
{
  context->remote_desktop_proxy = proxy;
}

void
grd_context_set_screen_cast_proxy (GrdContext        *context,
                                   GrdDBusScreenCast *proxy)
{
  context->screen_cast_proxy = proxy;
}

GMainContext *
grd_context_get_main_context (GrdContext *context)
{
  return context->main_context;
}

static void
on_session_stopped (GrdSession *session,
                    GrdContext *context)
{
  context->sessions = g_list_remove (context->sessions, session);
}

void
grd_context_add_session (GrdContext *context,
                         GrdSession *session)
{
  context->sessions = g_list_append (context->sessions, session);
  g_signal_connect (session, "stopped",
                    G_CALLBACK (on_session_stopped), context);
}

GList *
grd_context_get_sessions (GrdContext *context)
{
  return context->sessions;
}

GrdSettings *
grd_context_get_settings (GrdContext *context)
{
  return context->settings;
}

GrdDebugFlags
grd_context_get_debug_flags (GrdContext *context)
{
  return context->debug_flags;
}

static void
init_debug_flags (GrdContext *context)
{
  const char *debug_env;

debug_env = g_getenv ("GNOME_REMOTE_DESKTOP_DEBUG");
  if (debug_env)
    {
      context->debug_flags =
        g_parse_debug_string (debug_env,
                              grd_debug_keys,
                              G_N_ELEMENTS (grd_debug_keys));
    }
}

static void
grd_context_finalize (GObject *object)
{
  GrdContext *context = GRD_CONTEXT (object);

g_clear_object (&context->settings);

G_OBJECT_CLASS (grd_context_parent_class)->finalize (object);
}

static void
grd_context_init (GrdContext *context)
{
  context->main_context = g_main_context_default ();

init_debug_flags (context);

context->settings = g_object_new (GRD_TYPE_SETTINGS, NULL);
}

static void
grd_context_class_init (GrdContextClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->finalize = grd_context_finalize;
}
07070100000015000081A40000000000000000000000016141EE1000000867000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/src/grd-context.h/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#ifndef GRD_CONTEXT_H
#define GRD_CONTEXT_H

#include <glib-object.h>

#include "grd-dbus-remote-desktop.h"
#include "grd-dbus-screen-cast.h"
#include "grd-settings.h"
#include "grd-types.h"

typedef enum _GrdDebugFlags
{
  GRD_DEBUG_NONE = 0,
  GRD_DEBUG_VNC = 1 << 0,
} GrdDebugFlags;

#define GRD_TYPE_CONTEXT (grd_context_get_type ())
G_DECLARE_FINAL_TYPE (GrdContext, grd_context, GRD, CONTEXT, GObject);

GrdDBusRemoteDesktop * grd_context_get_remote_desktop_proxy (GrdContext *context);

GrdDBusScreenCast * grd_context_get_screen_cast_proxy (GrdContext *context);

void grd_context_set_remote_desktop_proxy (GrdContext           *context,
                                           GrdDBusRemoteDesktop *proxy);

void grd_context_set_screen_cast_proxy (GrdContext        *context,
                                        GrdDBusScreenCast *proxy);

GrdPipeWireStreamMonitor *grd_context_get_pipewire_stream_monitor (GrdContext *context);

GMainContext *grd_context_get_main_context (GrdContext *context);

void grd_context_add_session (GrdContext *context,
                              GrdSession *session);

GList * grd_context_get_sessions (GrdContext *context);

GrdSettings * grd_context_get_settings (GrdContext *context);

GrdDebugFlags grd_context_get_debug_flags (GrdContext *context);

#endif /* GRD_CONTEXT_H */
07070100000016000081A40000000000000000000000016141EE10000008DE000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/src/grd-control.c/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#include "config.h"

#include <gio/gio.h>
#include <stdio.h>
#include <string.h>

#include "grd-private.h"

int
main (int argc, char **argv)
{
  g_autoptr(GApplication) app = NULL;
  gboolean terminate = FALSE;
  GOptionEntry entries[] = {
    { "terminate", 0, 0, G_OPTION_ARG_NONE, &terminate,
      "Terminate the daemon", NULL },
    { NULL }
  };
  GError *error = NULL;
  GOptionContext *context;

context = g_option_context_new ("- control gnome-remote-desktop");
  g_option_context_add_main_entries (context, entries, NULL);
  if (!g_option_context_parse (context, &argc, &argv, &error))
    {
      g_printerr ("Invalid option: %s\n", error->message);
      g_error_free (error);
      return 1;
    }

if (!terminate)
    {
      g_printerr ("%s", g_option_context_get_help (context, TRUE, NULL));
      return 1;
    }

app = g_application_new (GRD_DAEMON_APPLICATION_ID, 0);
  if (!g_application_register (app, NULL, NULL))
    {
      g_warning ("Failed to register with application\n");
      return 1;
    }
  if (!g_application_get_is_registered (app))
    {
      g_warning ("Not registered\n");
      return 1;
    }
  if (!g_application_get_is_remote (app))
    {
      g_warning ("Failed to connect to application\n");
      return 1;
    }

if (terminate)
    g_action_group_activate_action (G_ACTION_GROUP (app),
                                    "terminate", NULL);
  else
    g_assert_not_reached ();

return 0;
}
07070100000017000081A40000000000000000000000016141EE1000002981000000000000000000000000000000000000002B00000000gnome-remote-desktop-40.2/src/grd-daemon.c/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#include "config.h"

#include "grd-daemon.h"

#include <gio/gio.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>
#include <stdio.h>
#include <stdlib.h>

#include "grd-context.h"
#include "grd-dbus-remote-desktop.h"
#include "grd-private.h"
#include "grd-rdp-server.h"
#include "grd-session.h"
#include "grd-vnc-server.h"

struct _GrdDaemon
{
  GApplication parent;

GCancellable *cancellable;
  guint remote_desktop_watch_name_id;
  guint screen_cast_watch_name_id;

GrdContext *context;

#ifdef HAVE_RDP
  GrdRdpServer *rdp_server;
#endif
#ifdef HAVE_VNC
  GrdVncServer *vnc_server;
#endif
};

G_DEFINE_TYPE (GrdDaemon, grd_daemon, G_TYPE_APPLICATION)

static gboolean
is_daemon_ready (GrdDaemon *daemon)
{
  if (!grd_context_get_remote_desktop_proxy (daemon->context) ||
      !grd_context_get_screen_cast_proxy (daemon->context))
    return FALSE;

return TRUE;
}

#ifdef HAVE_RDP
static void
init_rdp_server (GrdDaemon *daemon)
{
  GrdSettings *settings = grd_context_get_settings (daemon->context);
  g_autoptr (GError) error = NULL;

daemon->rdp_server = NULL;
  if (!g_access (grd_settings_get_rdp_server_cert (settings), F_OK) &&
      !g_access (grd_settings_get_rdp_server_key (settings), F_OK))
    {
      daemon->rdp_server = grd_rdp_server_new (daemon->context);
      if (!grd_rdp_server_start (daemon->rdp_server, &error))
        g_warning ("Failed to initialize RDP server: %s\n", error->message);
      else
        g_message ("Initialized RDP server");
    }
  else
    {
      g_message ("Didn't initialize RDP server: not configured");
    }
}
#endif /* HAVE_RDP */

#ifdef HAVE_VNC
static void
init_vnc_server (GrdDaemon *daemon)
{
  g_autoptr (GError) error = NULL;

daemon->vnc_server = grd_vnc_server_new (daemon->context);
  if (!grd_vnc_server_start (daemon->vnc_server, &error))
    g_warning ("Failed to initialize VNC server: %s\n", error->message);
  else
    g_message ("Initialized VNC server");
}
#endif /* HAVE_VNC */

static void
maybe_enable_services (GrdDaemon *daemon)
{
  if (!is_daemon_ready (daemon))
    return;

#ifdef HAVE_RDP
  init_rdp_server (daemon);
#endif

#ifdef HAVE_VNC
  init_vnc_server (daemon);
#endif
}

static void
close_all_sessions (GrdDaemon *daemon)
{
  GList *l;

while ((l = grd_context_get_sessions (daemon->context)))
    {
      GrdSession *session = l->data;

grd_session_stop (session);
    }
}

static void
disable_services (GrdDaemon *daemon)
{
  close_all_sessions (daemon);
#ifdef HAVE_RDP
  g_clear_object (&daemon->rdp_server);
#endif
#ifdef HAVE_VNC
  g_clear_object (&daemon->vnc_server);
#endif
}

static void
on_remote_desktop_proxy_acquired (GObject      *object,
                                  GAsyncResult *result,
                                  gpointer      user_data)
{
  GrdDaemon *daemon = user_data;
  GrdDBusRemoteDesktop *proxy;
  GError *error = NULL;

proxy = grd_dbus_remote_desktop_proxy_new_for_bus_finish (result, &error);
  if (!proxy)
    {
      g_warning ("Failed to create remote desktop proxy: %s", error->message);
      g_error_free (error);
      return;
    }

grd_context_set_remote_desktop_proxy (daemon->context, proxy);

maybe_enable_services (daemon);
}

static void
on_screen_cast_proxy_acquired (GObject      *object,
                               GAsyncResult *result,
                               gpointer      user_data)
{
  GrdDaemon *daemon = user_data;
  GrdDBusScreenCast *proxy;
  GError *error = NULL;

proxy = grd_dbus_screen_cast_proxy_new_for_bus_finish (result, &error);
  if (!proxy)
    {
      g_warning ("Failed to create screen cast proxy: %s", error->message);
      return;
    }

grd_context_set_screen_cast_proxy (daemon->context, proxy);

maybe_enable_services (daemon);
}

static void
on_remote_desktop_name_appeared (GDBusConnection *connection,
                                 const char      *name,
                                 const char      *name_owner,
                                 gpointer         user_data)
{
  GrdDaemon *daemon = user_data;

grd_dbus_remote_desktop_proxy_new_for_bus (G_BUS_TYPE_SESSION,
                                             G_DBUS_PROXY_FLAGS_NONE,
                                             MUTTER_REMOTE_DESKTOP_BUS_NAME,
                                             MUTTER_REMOTE_DESKTOP_OBJECT_PATH,
                                             daemon->cancellable,
                                             on_remote_desktop_proxy_acquired,
                                             daemon);
}

static void
on_remote_desktop_name_vanished (GDBusConnection *connection,
                                 const char      *name,
                                 gpointer         user_data)
{
  GrdDaemon *daemon = user_data;

disable_services (daemon);
  grd_context_set_remote_desktop_proxy (daemon->context, NULL);
}

static void
on_screen_cast_name_appeared (GDBusConnection *connection,
                              const char      *name,
                              const char      *name_owner,
                              gpointer         user_data)
{
  GrdDaemon *daemon = user_data;

grd_dbus_screen_cast_proxy_new_for_bus (G_BUS_TYPE_SESSION,
                                          G_DBUS_PROXY_FLAGS_NONE,
                                          MUTTER_SCREEN_CAST_BUS_NAME,
                                          MUTTER_SCREEN_CAST_OBJECT_PATH,
                                          daemon->cancellable,
                                          on_screen_cast_proxy_acquired,
                                          daemon);
}

static void
on_screen_cast_name_vanished (GDBusConnection *connection,
                              const char      *name,
                              gpointer         user_data)
{
  GrdDaemon *daemon = user_data;

disable_services (daemon);
  grd_context_set_screen_cast_proxy (daemon->context, NULL);
}

static void
grd_daemon_init (GrdDaemon *daemon)
{
  daemon->context = g_object_new (GRD_TYPE_CONTEXT, NULL);
}

static void
grd_daemon_startup (GApplication *app)
{
  GrdDaemon *daemon = GRD_DAEMON (app);

daemon->remote_desktop_watch_name_id =
    g_bus_watch_name (G_BUS_TYPE_SESSION,
                      MUTTER_REMOTE_DESKTOP_BUS_NAME,
                      G_BUS_NAME_WATCHER_FLAGS_NONE,
                      on_remote_desktop_name_appeared,
                      on_remote_desktop_name_vanished,
                      daemon, NULL);

daemon->screen_cast_watch_name_id =
    g_bus_watch_name (G_BUS_TYPE_SESSION,
                      MUTTER_SCREEN_CAST_BUS_NAME,
                      G_BUS_NAME_WATCHER_FLAGS_NONE,
                      on_screen_cast_name_appeared,
                      on_screen_cast_name_vanished,
                      daemon, NULL);

daemon->cancellable = g_cancellable_new ();

/* Run indefinitely, until told to exit. */
  g_application_hold (app);

G_APPLICATION_CLASS (grd_daemon_parent_class)->startup (app);
}

static void
grd_daemon_shutdown (GApplication *app)
{
  GrdDaemon *daemon = GRD_DAEMON (app);

g_cancellable_cancel (daemon->cancellable);
  g_clear_object (&daemon->cancellable);

disable_services (daemon);

grd_context_set_remote_desktop_proxy (daemon->context, NULL);
  g_bus_unwatch_name (daemon->remote_desktop_watch_name_id);
  daemon->remote_desktop_watch_name_id = 0;

grd_context_set_screen_cast_proxy (daemon->context, NULL);
  g_bus_unwatch_name (daemon->screen_cast_watch_name_id);
  daemon->screen_cast_watch_name_id = 0;

G_APPLICATION_CLASS (grd_daemon_parent_class)->shutdown (app);
}

static void
grd_daemon_class_init (GrdDaemonClass *klass)
{
  GApplicationClass *g_application_class = G_APPLICATION_CLASS (klass);

g_application_class->startup = grd_daemon_startup;
  g_application_class->shutdown = grd_daemon_shutdown;
}

static void
activate_terminate (GAction   *action,
                    GVariant  *parameter,
                    GrdDaemon *daemon)
{
  g_application_release (G_APPLICATION (daemon));
}

static void
add_actions (GApplication *app)
{
  g_autoptr(GSimpleAction) action = NULL;

action = g_simple_action_new ("terminate", NULL);
  g_signal_connect (action, "activate", G_CALLBACK (activate_terminate), app);
  g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (action));
}

int
main (int argc, char **argv)
{
  GrdSettings *settings;
  gboolean print_version = FALSE;
  int rdp_port = -1;
  int vnc_port = -1;

GOptionEntry entries[] = {
    { "version", 0, 0, G_OPTION_ARG_NONE, &print_version,
      "Print version", NULL },
    { "rdp-port", 0, 0, G_OPTION_ARG_INT, &rdp_port,
      "RDP port", NULL },
    { "vnc-port", 0, 0, G_OPTION_ARG_INT, &vnc_port,
      "VNC port", NULL },
    { NULL }
  };
  g_autoptr(GOptionContext) context = NULL;
  g_autoptr(GApplication) app = NULL;
  GError *error = NULL;

g_set_application_name (_("GNOME Remote Desktop"));

context = g_option_context_new (NULL);
  g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
  if (!g_option_context_parse (context, &argc, &argv, &error))
    {
      g_printerr ("Invalid option: %s\n", error->message);
      g_error_free (error);
      return EXIT_FAILURE;
    }

if (print_version)
    {
      g_print ("GNOME Remote Desktop %s\n", VERSION);
      return EXIT_SUCCESS;
    }

app = g_object_new (GRD_TYPE_DAEMON,
                      "application-id", GRD_DAEMON_APPLICATION_ID,
                      "flags", G_APPLICATION_IS_SERVICE,
                      NULL);

add_actions (app);

settings = grd_context_get_settings (GRD_DAEMON (app)->context);
  if (rdp_port != -1)
    grd_settings_override_rdp_port (settings, rdp_port);
  if (vnc_port != -1)
    grd_settings_override_vnc_port (settings, vnc_port);

return g_application_run (app, argc, argv);
}
07070100000018000081A40000000000000000000000016141EE100000049C000000000000000000000000000000000000002B00000000gnome-remote-desktop-40.2/src/grd-daemon.h/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#ifndef GRD_DAEMON_H
#define GRD_DAEMON_H

#include <gio/gio.h>

#include "grd-dbus-remote-desktop.h"

typedef struct _GrdDaemon GrdDaemon;

#define GRD_TYPE_DAEMON (grd_daemon_get_type ())
G_DECLARE_FINAL_TYPE (GrdDaemon, grd_daemon, GRD, DAEMON, GApplication);

GrdDBusRemoteDesktop *grd_daemon_get_dbus_proxy (GrdDaemon *daemon);

#endif /* GRD_DAEMON_H */
07070100000019000081A40000000000000000000000016141EE1000000BDA000000000000000000000000000000000000003100000000gnome-remote-desktop-40.2/src/grd-damage-utils.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-damage-utils.h"

#include <string.h>

bool
grd_is_tile_dirty (cairo_rectangle_int_t *tile,
                   uint8_t               *current_data,
                   uint8_t               *prev_data,
                   uint32_t               stride,
                   uint32_t               bytes_per_pixel)
{
  uint32_t y;

for (y = tile->y; y < tile->y + tile->height; ++y)
    {
      if (memcmp (prev_data + y * stride + tile->x * bytes_per_pixel,
                  current_data + y * stride + tile->x * bytes_per_pixel,
                  tile->width * bytes_per_pixel))
        return true;
    }

return false;
}

cairo_region_t *
grd_get_damage_region (uint8_t  *current_data,
                       uint8_t  *prev_data,
                       uint32_t  desktop_width,
                       uint32_t  desktop_height,
                       uint32_t  tile_width,
                       uint32_t  tile_height,
                       uint32_t  stride,
                       uint32_t  bytes_per_pixel)
{
  cairo_region_t *damage_region;
  cairo_rectangle_int_t tile;
  uint32_t cols, rows;
  uint32_t x, y;

damage_region = cairo_region_create ();
  if (current_data == NULL || prev_data == NULL)
    {
      tile.x = tile.y = 0;
      tile.width = desktop_width;
      tile.height = desktop_height;
      cairo_region_union_rectangle (damage_region, &tile);

return damage_region;
    }

cols = desktop_width / tile_width + (desktop_width % tile_width ? 1 : 0);
  rows = desktop_height / tile_height + (desktop_height % tile_height ? 1 : 0);

for (y = 0; y < rows; ++y)
    {
      for (x = 0; x < cols; ++x)
        {
          tile.x = x * tile_width;
          tile.y = y * tile_height;
          tile.width = desktop_width - tile.x < tile_width ? desktop_width - tile.x
                                                           : tile_width;
          tile.height = desktop_height - tile.y < tile_height ? desktop_height - tile.y
                                                              : tile_height;

if (grd_is_tile_dirty (&tile, current_data, prev_data, stride, bytes_per_pixel))
            cairo_region_union_rectangle (damage_region, &tile);
        }
    }

return damage_region;
}
0707010000001A000081A40000000000000000000000016141EE10000006AF000000000000000000000000000000000000003100000000gnome-remote-desktop-40.2/src/grd-damage-utils.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_DAMAGE_UTILS_H
#define GRD_DAMAGE_UTILS_H

#include <cairo/cairo.h>
#include <stdbool.h>
#include <stdint.h>

cairo_region_t *grd_get_damage_region (uint8_t  *current_data,
                                       uint8_t  *prev_data,
                                       uint32_t  desktop_width,
                                       uint32_t  desktop_height,
                                       uint32_t  tile_width,
                                       uint32_t  tile_height,
                                       uint32_t  stride,
                                       uint32_t  bytes_per_pixel);

bool grd_is_tile_dirty (cairo_rectangle_int_t *tile,
                        uint8_t               *current_data,
                        uint8_t               *prev_data,
                        uint32_t               stride,
                        uint32_t               bytes_per_pixel);

#endif /* GRD_DAMAGE_UTILS_H */
0707010000001B000081A40000000000000000000000016141EE10000003A1000000000000000000000000000000000000002A00000000gnome-remote-desktop-40.2/src/grd-enums.h/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#ifndef GRD_ENUMS_H
#define GRD_ENUMS_H

typedef enum
{
  GRD_VNC_AUTH_METHOD_PROMPT,
  GRD_VNC_AUTH_METHOD_PASSWORD
} GrdVncAuthMethod;

#endif /* GRD_ENUMS_H */
0707010000001C000081A40000000000000000000000016141EE1000000B60000000000000000000000000000000000000002E00000000gnome-remote-desktop-40.2/src/grd-mime-type.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-mime-type.h"

#include <gio/gio.h>

const char *
grd_mime_type_to_string (GrdMimeType mime_type)
{
  switch (mime_type)
    {
    case GRD_MIME_TYPE_TEXT_PLAIN:
      return "text/plain";
    case GRD_MIME_TYPE_TEXT_PLAIN_UTF8:
      return "text/plain;charset=utf-8";
    case GRD_MIME_TYPE_TEXT_UTF8_STRING:
      return "UTF8_STRING";
    case GRD_MIME_TYPE_TEXT_HTML:
      return "text/html";
    case GRD_MIME_TYPE_IMAGE_BMP:
      return "image/bmp";
    case GRD_MIME_TYPE_IMAGE_TIFF:
      return "image/tiff";
    case GRD_MIME_TYPE_IMAGE_GIF:
      return "image/gif";
    case GRD_MIME_TYPE_IMAGE_JPEG:
      return "image/jpeg";
    case GRD_MIME_TYPE_IMAGE_PNG:
      return "image/png";
    case GRD_MIME_TYPE_TEXT_URILIST:
      return "text/uri-list";
    case GRD_MIME_TYPE_XS_GNOME_COPIED_FILES:
      return "x-special/gnome-copied-files";
    default:
      return NULL;
    }

g_assert_not_reached ();
}

GrdMimeType
grd_mime_type_from_string (const char *mime_type_string)
{
  if (strcmp (mime_type_string, "text/plain") == 0)
    return GRD_MIME_TYPE_TEXT_PLAIN;
  else if (strcmp (mime_type_string, "text/plain;charset=utf-8") == 0)
    return GRD_MIME_TYPE_TEXT_PLAIN_UTF8;
  else if (strcmp (mime_type_string, "UTF8_STRING") == 0)
    return GRD_MIME_TYPE_TEXT_UTF8_STRING;
  else if (strcmp (mime_type_string, "text/html") == 0)
    return GRD_MIME_TYPE_TEXT_HTML;
  else if (strcmp (mime_type_string, "image/bmp") == 0)
    return GRD_MIME_TYPE_IMAGE_BMP;
  else if (strcmp (mime_type_string, "image/tiff") == 0)
    return GRD_MIME_TYPE_IMAGE_TIFF;
  else if (strcmp (mime_type_string, "image/gif") == 0)
    return GRD_MIME_TYPE_IMAGE_GIF;
  else if (strcmp (mime_type_string, "image/jpeg") == 0)
    return GRD_MIME_TYPE_IMAGE_JPEG;
  else if (strcmp (mime_type_string, "image/png") == 0)
    return GRD_MIME_TYPE_IMAGE_PNG;
  else if (strcmp (mime_type_string, "text/uri-list") == 0)
    return GRD_MIME_TYPE_TEXT_URILIST;
  else if (strcmp (mime_type_string, "x-special/gnome-copied-files") == 0)
    return GRD_MIME_TYPE_XS_GNOME_COPIED_FILES;

return GRD_MIME_TYPE_NONE;
}
0707010000001D000081A40000000000000000000000016141EE100000072E000000000000000000000000000000000000002E00000000gnome-remote-desktop-40.2/src/grd-mime-type.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_MIME_TYPE_H
#define GRD_MIME_TYPE_H

#include <stdint.h>

typedef enum _GrdMimeType
{
  GRD_MIME_TYPE_NONE,
  GRD_MIME_TYPE_TEXT_PLAIN,            /* text/plain */
  GRD_MIME_TYPE_TEXT_PLAIN_UTF8,       /* text/plain;charset=utf-8 */
  GRD_MIME_TYPE_TEXT_UTF8_STRING,      /* UTF8_STRING */
  GRD_MIME_TYPE_TEXT_HTML,             /* text/html */
  GRD_MIME_TYPE_IMAGE_BMP,             /* image/bmp */
  GRD_MIME_TYPE_IMAGE_TIFF,            /* image/tiff */
  GRD_MIME_TYPE_IMAGE_GIF,             /* image/gif */
  GRD_MIME_TYPE_IMAGE_JPEG,            /* image/jpeg */
  GRD_MIME_TYPE_IMAGE_PNG,             /* image/png */
  GRD_MIME_TYPE_TEXT_URILIST,          /* text/uri-list */
  GRD_MIME_TYPE_XS_GNOME_COPIED_FILES, /* x-special/gnome-copied-files */
} GrdMimeType;

typedef struct _GrdMimeTypeTable
{
  GrdMimeType mime_type;

struct
  {
    uint32_t format_id;
  } rdp;
} GrdMimeTypeTable;

const char *grd_mime_type_to_string (GrdMimeType mime_type);

GrdMimeType grd_mime_type_from_string (const char *mime_type_string);

#endif /* GRD_MIME_TYPE_H */
0707010000001E000081A40000000000000000000000016141EE10000007F0000000000000000000000000000000000000003300000000gnome-remote-desktop-40.2/src/grd-pipewire-utils.c/*
 * Copyright (C) 2015 Red Hat Inc.
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-pipewire-utils.h"

#include <linux/dma-buf.h>
#include <pipewire/pipewire.h>
#include <spa/param/video/raw.h>
#include <sys/ioctl.h>
#include <errno.h>

static gboolean is_pipewire_initialized = FALSE;

void
grd_maybe_initialize_pipewire (void)
{
  if (!is_pipewire_initialized)
    {
      pw_init (NULL, NULL);
      is_pipewire_initialized = TRUE;
    }
}

gboolean
grd_spa_pixel_format_to_grd_pixel_format (uint32_t        spa_format,
                                          GrdPixelFormat *out_format)
{
  if (spa_format == SPA_VIDEO_FORMAT_RGBA)
    *out_format = GRD_PIXEL_FORMAT_RGBA8888;
  else
    return FALSE;

return TRUE;
}

void
grd_sync_dma_buf (int      fd,
                  uint64_t start_or_end)
{
  struct dma_buf_sync sync = { 0 };

sync.flags = start_or_end | DMA_BUF_SYNC_READ;

while (TRUE)
    {
      int ret;

ret = ioctl (fd, DMA_BUF_IOCTL_SYNC, &sync);
      if (ret == -1 && errno == EINTR)
        {
          continue;
        }
      else if (ret == -1)
        {
          g_warning ("Failed to synchronize DMA buffer: %s",
                     g_strerror (errno));
          break;
        }
      else
        {
          break;
        }
    }
}
0707010000001F000081A40000000000000000000000016141EE10000005AE000000000000000000000000000000000000003300000000gnome-remote-desktop-40.2/src/grd-pipewire-utils.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_PIPEWIRE_UTILS_H
#define GRD_PIPEWIRE_UTILS_H

#include <gio/gio.h>
#include <stdint.h>

#include "grd-types.h"

#define CURSOR_META_SIZE(width, height) \
 (sizeof(struct spa_meta_cursor) + \
  sizeof(struct spa_meta_bitmap) + width * height * 4)

typedef struct _GrdPipeWireSource
{
  GSource base;

struct pw_loop *pipewire_loop;
} GrdPipeWireSource;

void grd_maybe_initialize_pipewire (void);

gboolean grd_spa_pixel_format_to_grd_pixel_format (uint32_t        spa_format,
                                                   GrdPixelFormat *out_format);

void grd_sync_dma_buf (int      fd,
                       uint64_t start_or_end);

#endif /* GRD_PIPEWIRE_UTILS_H */
07070100000020000081A40000000000000000000000016141EE10000004D5000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/src/grd-private.h/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#ifndef GRD_PRIVATE_H
#define GRD_PRIVATE_H

#define GRD_DAEMON_APPLICATION_ID "org.gnome.RemoteDesktop"
#define MUTTER_REMOTE_DESKTOP_BUS_NAME "org.gnome.Mutter.RemoteDesktop"
#define MUTTER_REMOTE_DESKTOP_OBJECT_PATH "/org/gnome/Mutter/RemoteDesktop"
#define MUTTER_SCREEN_CAST_BUS_NAME "org.gnome.Mutter.ScreenCast"
#define MUTTER_SCREEN_CAST_OBJECT_PATH "/org/gnome/Mutter/ScreenCast"

#endif /* GRD_PRIVATE_H */
07070100000021000081A40000000000000000000000016141EE100000147E000000000000000000000000000000000000002B00000000gnome-remote-desktop-40.2/src/grd-prompt.c/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#include "config.h"

#include <glib/gi18n.h>
#include <libnotify/notify.h>

#include "grd-prompt.h"

typedef struct _GrdPromptResult
{
  GrdPromptResponse response;
} GrdPromptResult;

struct _GrdPrompt
{
  GObject parent;
};

G_DEFINE_TYPE (GrdPrompt, grd_prompt, G_TYPE_OBJECT)

static void
handle_notification_response (NotifyNotification *notification,
                              char               *response,
                              gpointer            user_data)
{
  GTask *task = G_TASK (user_data);

if (g_strcmp0 (response, "accept") == 0)
    {
      g_task_return_int (task, GRD_PROMPT_RESPONSE_ACCEPT);
    }
  else if (g_strcmp0 (response, "refuse") == 0 ||
           g_strcmp0 (response, "closed") == 0)
    {
      g_task_return_int (task, GRD_PROMPT_RESPONSE_REFUSE);
    }
  else
    {
      g_warning ("Unknown prompt response '%s'", response);
      g_task_return_int (task, GRD_PROMPT_RESPONSE_REFUSE);
    }
}

static void
on_notification_closed (NotifyNotification *notification,
                        gpointer            user_data)
{
  handle_notification_response (notification, "closed", user_data);
}

static gboolean
cancelled_idle_callback (gpointer user_data)
{
  GTask *task = G_TASK (user_data);

g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_CANCELLED,
                           "Prompt was cancelled");
  return G_SOURCE_REMOVE;
}

static void
on_cancellable_cancelled (GCancellable *cancellable,
                          GTask        *task)
{
  NotifyNotification *notification =
    NOTIFY_NOTIFICATION (g_task_get_task_data (task));

notify_notification_close (notification, NULL);
  g_idle_add (cancelled_idle_callback, task);
}

static gboolean
show_notification_idle_callback (gpointer user_data)
{
  GTask *task = G_TASK (user_data);
  GCancellable *cancellable = g_task_get_cancellable (task);
  NotifyNotification *notification;
  GError *error = NULL;

if (g_cancellable_is_cancelled (cancellable))
    return G_SOURCE_REMOVE;

notification = g_task_get_task_data (task);

if (!notify_notification_show (notification, &error))
    g_task_return_error (task, error);

return G_SOURCE_REMOVE;
}

void
grd_prompt_query_async (GrdPrompt           *prompt,
                        const char          *remote_host,
                        GCancellable        *cancellable,
                        GAsyncReadyCallback  callback,
                        gpointer             user_data)
{
  NotifyNotification *notification;
  GTask *task;
  g_autofree char *summary = NULL;
  g_autofree char *body = NULL;

task = g_task_new (G_OBJECT (prompt), cancellable, callback, user_data);

summary = g_strdup_printf (_("Do you want to share your desktop?"));
  body = g_strdup_printf (_("A user on the computer '%s' is trying to remotely view or control your desktop."),
                          remote_host);
  notification = notify_notification_new (summary, body,
                                          "preferences-desktop-remote-desktop");
  notify_notification_add_action (notification,
                                  "refuse",
                                  _("Refuse"),
                                  handle_notification_response,
                                  task, NULL);
  notify_notification_add_action (notification,
                                  "accept",
                                  _("Accept"),
                                  handle_notification_response,
                                  task, NULL);
  g_task_set_task_data (task, notification, g_object_unref);

g_signal_connect (notification, "closed",
                    G_CALLBACK (on_notification_closed), task);
  g_cancellable_connect (cancellable,
                         G_CALLBACK (on_cancellable_cancelled),
                         task, NULL);

g_idle_add (show_notification_idle_callback, task);
}

gboolean
grd_prompt_query_finish (GrdPrompt          *prompt,
                         GAsyncResult       *result,
                         GrdPromptResponse  *out_response,
                         GError            **error)
{
  g_autoptr(GTask) task = G_TASK (result);
  GrdPromptResponse response;

response = g_task_propagate_int (task, error);
  if (response == -1)
    return FALSE;

*out_response = response;
  return TRUE;
}

static void
grd_prompt_init (GrdPrompt *prompt)
{
}

static void
grd_prompt_class_init (GrdPromptClass *klass)
{
  notify_init (g_get_application_name ());
}
07070100000022000081A40000000000000000000000016141EE1000000659000000000000000000000000000000000000002B00000000gnome-remote-desktop-40.2/src/grd-prompt.h/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#ifndef GRD_PROMPT_H
#define GRD_PROMPT_H

typedef enum _GrdPromptResponse
{
  GRD_PROMPT_RESPONSE_ACCEPT,
  GRD_PROMPT_RESPONSE_REFUSE
} GrdPromptResponse;

#define GRD_TYPE_PROMPT (grd_prompt_get_type ())
G_DECLARE_FINAL_TYPE (GrdPrompt, grd_prompt, GRD, PROMPT, GObject)

void grd_prompt_query_async (GrdPrompt           *prompt,
                             const char          *remote_host,
                             GCancellable        *cancellable,
                             GAsyncReadyCallback  callback,
                             gpointer             user_data);

gboolean grd_prompt_query_finish (GrdPrompt          *prompt,
                                  GAsyncResult       *result,
                                  GrdPromptResponse  *response,
                                  GError            **error);

#endif /* GRD_PROMPT_H */
07070100000023000081A40000000000000000000000016141EE1000003099000000000000000000000000000000000000003400000000gnome-remote-desktop-40.2/src/grd-rdp-event-queue.c/*
 * Copyright (C) 2021 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-rdp-event-queue.h"

#include <xkbcommon/xkbcommon-keysyms.h>

typedef enum _RdpEventType
{
  RDP_EVENT_TYPE_NONE,
  RDP_EVENT_TYPE_INPUT_KBD_KEYCODE,
  RDP_EVENT_TYPE_INPUT_KBD_KEYSYM,
  RDP_EVENT_TYPE_INPUT_PTR_MOTION_ABS,
  RDP_EVENT_TYPE_INPUT_PTR_BUTTON,
  RDP_EVENT_TYPE_INPUT_PTR_AXIS,
} RdpEventType;

typedef struct _RdpEvent
{
  RdpEventType type;

/* RDP_EVENT_TYPE_INPUT_KBD_KEYCODE */
  struct
  {
    uint32_t keycode;
    GrdKeyState state;
  } input_kbd_keycode;

/* RDP_EVENT_TYPE_INPUT_KBD_KEYSYM */
  struct
  {
    uint32_t keysym;
    GrdKeyState state;
  } input_kbd_keysym;

/* RDP_EVENT_TYPE_INPUT_PTR_MOTION_ABS */
  struct
  {
    double x;
    double y;
  } input_ptr_motion_abs;

/* RDP_EVENT_TYPE_INPUT_PTR_BUTTON */
  struct
  {
    int32_t button;
    GrdButtonState state;
  } input_ptr_button;

/* RDP_EVENT_TYPE_INPUT_PTR_AXIS */
  struct
  {
    double dx;
    double dy;
    GrdPointerAxisFlags flags;
  } input_ptr_axis;
} RdpEvent;

typedef struct _RdpSynchronizationEvent
{
  gboolean caps_lock_state;
  gboolean num_lock_state;
} RdpSynchronizationEvent;

struct _GrdRdpEventQueue
{
  GObject parent;

GrdSessionRdp *session_rdp;
  GSource *flush_source;

GMutex event_mutex;
  GQueue *queue;
  RdpSynchronizationEvent *rdp_sync_event;

gboolean pending_sync_caps_lock;
  gboolean pending_sync_num_lock;
  gboolean caps_lock_state;
  gboolean num_lock_state;
};

G_DEFINE_TYPE (GrdRdpEventQueue, grd_rdp_event_queue, G_TYPE_OBJECT);

static void
queue_rdp_event (GrdRdpEventQueue *rdp_event_queue,
                 RdpEvent         *rdp_event)
{
  g_mutex_lock (&rdp_event_queue->event_mutex);
  g_queue_push_tail (rdp_event_queue->queue, rdp_event);
  g_mutex_unlock (&rdp_event_queue->event_mutex);

g_source_set_ready_time (rdp_event_queue->flush_source, 0);
}

void
grd_rdp_event_queue_add_input_event_keyboard_keycode (GrdRdpEventQueue *rdp_event_queue,
                                                      uint32_t          keycode,
                                                      GrdKeyState       state)
{
  RdpEvent *rdp_event;

rdp_event = g_malloc0 (sizeof (RdpEvent));
  rdp_event->type = RDP_EVENT_TYPE_INPUT_KBD_KEYCODE;
  rdp_event->input_kbd_keycode.keycode = keycode;
  rdp_event->input_kbd_keycode.state = state;

queue_rdp_event (rdp_event_queue, rdp_event);
}

void
grd_rdp_event_queue_add_input_event_keyboard_keysym (GrdRdpEventQueue *rdp_event_queue,
                                                     uint32_t          keysym,
                                                     GrdKeyState       state)
{
  RdpEvent *rdp_event;

rdp_event = g_malloc0 (sizeof (RdpEvent));
  rdp_event->type = RDP_EVENT_TYPE_INPUT_KBD_KEYSYM;
  rdp_event->input_kbd_keysym.keysym = keysym;
  rdp_event->input_kbd_keysym.state = state;

queue_rdp_event (rdp_event_queue, rdp_event);
}

void
grd_rdp_event_queue_add_input_event_pointer_motion_abs (GrdRdpEventQueue *rdp_event_queue,
                                                        double            x,
                                                        double            y)
{
  RdpEvent *rdp_event;

rdp_event = g_malloc0 (sizeof (RdpEvent));
  rdp_event->type = RDP_EVENT_TYPE_INPUT_PTR_MOTION_ABS;
  rdp_event->input_ptr_motion_abs.x = x;
  rdp_event->input_ptr_motion_abs.y = y;

queue_rdp_event (rdp_event_queue, rdp_event);
}

void
grd_rdp_event_queue_add_input_event_pointer_button (GrdRdpEventQueue *rdp_event_queue,
                                                    int32_t           button,
                                                    GrdButtonState    state)
{
  RdpEvent *rdp_event;

rdp_event = g_malloc0 (sizeof (RdpEvent));
  rdp_event->type = RDP_EVENT_TYPE_INPUT_PTR_BUTTON;
  rdp_event->input_ptr_button.button = button;
  rdp_event->input_ptr_button.state = state;

queue_rdp_event (rdp_event_queue, rdp_event);
}

void
grd_rdp_event_queue_add_input_event_pointer_axis (GrdRdpEventQueue    *rdp_event_queue,
                                                  double               dx,
                                                  double               dy,
                                                  GrdPointerAxisFlags  flags)
{
  RdpEvent *rdp_event;

rdp_event = g_malloc0 (sizeof (RdpEvent));
  rdp_event->type = RDP_EVENT_TYPE_INPUT_PTR_AXIS;
  rdp_event->input_ptr_axis.dx = dx;
  rdp_event->input_ptr_axis.dy = dy;
  rdp_event->input_ptr_axis.flags = flags;

queue_rdp_event (rdp_event_queue, rdp_event);
}

void
grd_rdp_event_queue_update_caps_lock_state (GrdRdpEventQueue *rdp_event_queue,
                                            gboolean          caps_lock_state)
{
  rdp_event_queue->caps_lock_state = caps_lock_state;
  rdp_event_queue->pending_sync_caps_lock = FALSE;

if (rdp_event_queue->pending_sync_num_lock)
    return;

g_source_set_ready_time (rdp_event_queue->flush_source, 0);
}

void
grd_rdp_event_queue_update_num_lock_state (GrdRdpEventQueue *rdp_event_queue,
                                           gboolean          num_lock_state)
{
  rdp_event_queue->num_lock_state = num_lock_state;
  rdp_event_queue->pending_sync_num_lock = FALSE;

if (rdp_event_queue->pending_sync_caps_lock)
    return;

g_source_set_ready_time (rdp_event_queue->flush_source, 0);
}

void
grd_rdp_event_queue_add_synchronization_event (GrdRdpEventQueue *rdp_event_queue,
                                               gboolean          caps_lock_state,
                                               gboolean          num_lock_state)
{
  RdpSynchronizationEvent *rdp_sync_event;

rdp_sync_event = g_malloc0 (sizeof (RdpSynchronizationEvent));
  rdp_sync_event->caps_lock_state = caps_lock_state;
  rdp_sync_event->num_lock_state = num_lock_state;

g_mutex_lock (&rdp_event_queue->event_mutex);
  g_clear_pointer (&rdp_event_queue->rdp_sync_event, g_free);
  rdp_event_queue->rdp_sync_event = rdp_sync_event;
  g_mutex_unlock (&rdp_event_queue->event_mutex);

g_source_set_ready_time (rdp_event_queue->flush_source, 0);
}

static void
handle_synchronization_event (GrdRdpEventQueue *rdp_event_queue)
{
  GrdSession *session = GRD_SESSION (rdp_event_queue->session_rdp);
  RdpSynchronizationEvent *rdp_sync_event;

rdp_sync_event = g_steal_pointer (&rdp_event_queue->rdp_sync_event);

if (rdp_sync_event->caps_lock_state != rdp_event_queue->caps_lock_state)
    {
      g_debug ("Synchronizing caps lock state to be %s",
               rdp_sync_event->caps_lock_state ? "locked": "unlocked");

grd_session_notify_keyboard_keysym (session, XKB_KEY_Caps_Lock,
                                          GRD_KEY_STATE_PRESSED);
      grd_session_notify_keyboard_keysym (session, XKB_KEY_Caps_Lock,
                                          GRD_KEY_STATE_RELEASED);

rdp_event_queue->pending_sync_caps_lock = TRUE;
    }
  if (rdp_sync_event->num_lock_state != rdp_event_queue->num_lock_state)
    {
      g_debug ("Synchronizing num lock state to be %s",
               rdp_sync_event->num_lock_state ? "locked": "unlocked");

grd_session_notify_keyboard_keysym (session, XKB_KEY_Num_Lock,
                                          GRD_KEY_STATE_PRESSED);
      grd_session_notify_keyboard_keysym (session, XKB_KEY_Num_Lock,
                                          GRD_KEY_STATE_RELEASED);

rdp_event_queue->pending_sync_num_lock = TRUE;
    }

g_free (rdp_sync_event);
}

static void
process_rdp_events (GrdRdpEventQueue *rdp_event_queue)
{
  GrdSession *session = GRD_SESSION (rdp_event_queue->session_rdp);
  RdpEvent *rdp_event;

if (rdp_event_queue->rdp_sync_event &&
      !rdp_event_queue->pending_sync_caps_lock &&
      !rdp_event_queue->pending_sync_num_lock)
    handle_synchronization_event (rdp_event_queue);

while ((rdp_event = g_queue_pop_head (rdp_event_queue->queue)))
    {
      switch (rdp_event->type)
        {
        case RDP_EVENT_TYPE_NONE:
          break;
        case RDP_EVENT_TYPE_INPUT_KBD_KEYCODE:
          grd_session_notify_keyboard_keycode (
            session, rdp_event->input_kbd_keycode.keycode,
            rdp_event->input_kbd_keycode.state);
          break;
        case RDP_EVENT_TYPE_INPUT_KBD_KEYSYM:
          grd_session_notify_keyboard_keysym (session,
                                              rdp_event->input_kbd_keysym.keysym,
                                              rdp_event->input_kbd_keysym.state);
          break;
        case RDP_EVENT_TYPE_INPUT_PTR_MOTION_ABS:
          grd_session_notify_pointer_motion_absolute (
            session, rdp_event->input_ptr_motion_abs.x,
            rdp_event->input_ptr_motion_abs.y);
          break;
        case RDP_EVENT_TYPE_INPUT_PTR_BUTTON:
          grd_session_notify_pointer_button (session,
                                             rdp_event->input_ptr_button.button,
                                             rdp_event->input_ptr_button.state);
          break;
        case RDP_EVENT_TYPE_INPUT_PTR_AXIS:
          grd_session_notify_pointer_axis (session,
                                           rdp_event->input_ptr_axis.dx,
                                           rdp_event->input_ptr_axis.dy,
                                           rdp_event->input_ptr_axis.flags);
          break;
        }

g_free (rdp_event);
    }
}

static gboolean
flush_rdp_events (gpointer user_data)
{
  GrdRdpEventQueue *rdp_event_queue = user_data;

g_mutex_lock (&rdp_event_queue->event_mutex);
  process_rdp_events (rdp_event_queue);
  g_mutex_unlock (&rdp_event_queue->event_mutex);

return G_SOURCE_CONTINUE;
}

static gboolean
flush_source_dispatch (GSource     *source,
                       GSourceFunc  callback,
                       gpointer     user_data)
{
  g_source_set_ready_time (source, -1);

return callback (user_data);
}

static GSourceFuncs flush_source_funcs =
{
  .dispatch = flush_source_dispatch,
};

GrdRdpEventQueue *
grd_rdp_event_queue_new (GrdSessionRdp *session_rdp)
{
  GrdRdpEventQueue *rdp_event_queue;
  GSource *flush_source;

rdp_event_queue = g_object_new (GRD_TYPE_RDP_EVENT_QUEUE, NULL);
  rdp_event_queue->session_rdp = session_rdp;

flush_source = g_source_new (&flush_source_funcs, sizeof (GSource));
  g_source_set_callback (flush_source, flush_rdp_events, rdp_event_queue, NULL);
  g_source_set_ready_time (flush_source, -1);
  g_source_attach (flush_source, g_main_context_get_thread_default ());
  rdp_event_queue->flush_source = flush_source;

return rdp_event_queue;
}

void
free_rdp_event (gpointer data)
{
  RdpEvent *rdp_event = data;

g_free (rdp_event);
}

static void
grd_rdp_event_queue_dispose (GObject *object)
{
  GrdRdpEventQueue *rdp_event_queue = GRD_RDP_EVENT_QUEUE (object);

/**
   * Process all events to ensure that remaining keysym-released events are sent
   */
  process_rdp_events (rdp_event_queue);

g_clear_pointer (&rdp_event_queue->rdp_sync_event, g_free);
  g_queue_free_full (rdp_event_queue->queue, free_rdp_event);

g_source_destroy (rdp_event_queue->flush_source);
  g_clear_pointer (&rdp_event_queue->flush_source, g_source_unref);

G_OBJECT_CLASS (grd_rdp_event_queue_parent_class)->dispose (object);
}

static void
grd_rdp_event_queue_init (GrdRdpEventQueue *rdp_event_queue)
{
  rdp_event_queue->queue = g_queue_new ();

g_mutex_init (&rdp_event_queue->event_mutex);

rdp_event_queue->pending_sync_caps_lock = TRUE;
  rdp_event_queue->pending_sync_num_lock = TRUE;
}

static void
grd_rdp_event_queue_class_init (GrdRdpEventQueueClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->dispose = grd_rdp_event_queue_dispose;
}
07070100000024000081A40000000000000000000000016141EE1000000C7D000000000000000000000000000000000000003400000000gnome-remote-desktop-40.2/src/grd-rdp-event-queue.h/*
 * Copyright (C) 2021 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_RDP_EVENT_QUEUE_H
#define GRD_RDP_EVENT_QUEUE_H

#include <glib-object.h>
#include <stdint.h>

#include "grd-session.h"
#include "grd-types.h"

#define GRD_TYPE_RDP_EVENT_QUEUE (grd_rdp_event_queue_get_type ())
G_DECLARE_FINAL_TYPE (GrdRdpEventQueue, grd_rdp_event_queue,
                      GRD, RDP_EVENT_QUEUE, GObject);

GrdRdpEventQueue *grd_rdp_event_queue_new (GrdSessionRdp *session_rdp);

void grd_rdp_event_queue_add_input_event_keyboard_keycode (GrdRdpEventQueue *rdp_event_queue,
                                                           uint32_t          keycode,
                                                           GrdKeyState       state);

void grd_rdp_event_queue_add_input_event_keyboard_keysym (GrdRdpEventQueue *rdp_event_queue,
                                                          uint32_t          keysym,
                                                          GrdKeyState       state);

void grd_rdp_event_queue_add_input_event_pointer_motion_abs (GrdRdpEventQueue *rdp_event_queue,
                                                             double            x,
                                                             double            y);

void grd_rdp_event_queue_add_input_event_pointer_button (GrdRdpEventQueue *rdp_event_queue,
                                                         int32_t           button,
                                                         GrdButtonState    state);

void grd_rdp_event_queue_add_input_event_pointer_axis (GrdRdpEventQueue    *rdp_event_queue,
                                                       double               dx,
                                                       double               dy,
                                                       GrdPointerAxisFlags  flags);

void grd_rdp_event_queue_update_caps_lock_state (GrdRdpEventQueue *rdp_event_queue,
                                                 gboolean          caps_lock_state);

void grd_rdp_event_queue_update_num_lock_state (GrdRdpEventQueue *rdp_event_queue,
                                                gboolean          num_lock_state);

void grd_rdp_event_queue_add_synchronization_event (GrdRdpEventQueue *rdp_event_queue,
                                                    gboolean          caps_lock_state,
                                                    gboolean          num_lock_state);

#endif /* GRD_RDP_EVENT_QUEUE_H */
07070100000025000081A40000000000000000000000016141EE100000CCB7000000000000000000000000000000000000003700000000gnome-remote-desktop-40.2/src/grd-rdp-fuse-clipboard.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-rdp-fuse-clipboard.h"

#define FUSE_USE_VERSION 35

#include <fuse3/fuse_lowlevel.h>
#include <unistd.h>

#include "grd-clipboard-rdp.h"

#define CLIP_DATA_ENTRY_DROP_TIMEOUT_MS (60 * 1000)
#define CLIP_DATA_ENTRY_DROP_TIMEOUT_DELTA_US (10 * G_USEC_PER_SEC)
#define WIN32_FILETIME_TO_UNIX_EPOCH UINT64_C (11644473600)

typedef enum _FuseLowlevelOperationType
{
  FUSE_LL_OPERATION_NONE,
  FUSE_LL_OPERATION_LOOKUP,
  FUSE_LL_OPERATION_GETATTR,
  FUSE_LL_OPERATION_READ,
} FuseLowlevelOperationType;

typedef struct _FuseFileStealContext
{
  gboolean all_files;
  gboolean has_clip_data_id;
  uint32_t clip_data_id;

GList *fuse_files;
} FuseFileStealContext;

typedef struct _ClearRdpFuseRequestContext
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard;
  gboolean all_files;
  gboolean has_clip_data_id;
  uint32_t clip_data_id;
} ClearRdpFuseRequestContext;

typedef struct _FuseFile FuseFile;
typedef struct _ClipDataEntry ClipDataEntry;

struct _FuseFile
{
  FuseFile *parent;
  GList *children;

char *filename;
  char *filename_with_root;
  uint32_t list_idx;
  fuse_ino_t ino;

gboolean is_directory;
  gboolean is_readonly;

gboolean has_size;
  uint64_t size;

gboolean has_last_write_time;
  uint64_t last_write_time_unix;

gboolean has_clip_data_id;
  uint32_t clip_data_id;

ClipDataEntry *entry;
};

struct _ClipDataEntry
{
  FuseFile *clip_data_dir;

gboolean has_clip_data_id;
  uint32_t clip_data_id;

GrdClipboardRdp *clipboard_rdp;

gboolean had_file_contents_request;

struct
  {
    GrdRdpFuseClipboard *rdp_fuse_clipboard;
    unsigned int drop_id;
    int64_t drop_id_timeout_set_us;
  } drop_context;
};

typedef struct _RdpFuseFileContentsRequest
{
  FuseFile *fuse_file;

fuse_req_t fuse_req;
  FuseLowlevelOperationType operation_type;

uint32_t stream_id;
} RdpFuseFileContentsRequest;

struct _GrdRdpFuseClipboard
{
  GObject parent;

GrdClipboardRdp *clipboard_rdp;
  char *mount_path;

GThread *fuse_thread;
  struct fuse_session *fuse_handle;
  HANDLE start_event;
  HANDLE stop_event;

GSource *timeout_reset_source;
  GHashTable *timeouts_to_reset;

GMutex filesystem_mutex;
  GMutex selection_mutex;
  GHashTable *inode_table;
  GHashTable *clip_data_table;
  GHashTable *request_table;
  FuseFile *root_dir;

ClipDataEntry *no_cdi_entry;

fuse_ino_t next_ino;
  uint32_t next_clip_data_id;
  uint32_t next_stream_id;
};

G_DEFINE_TYPE (GrdRdpFuseClipboard, grd_rdp_fuse_clipboard, G_TYPE_OBJECT);

static gboolean
should_remove_fuse_file (FuseFile *fuse_file,
                         gboolean  all_files,
                         gboolean  has_clip_data_id,
                         uint32_t  clip_data_id)
{
  if (all_files)
    return TRUE;

if (fuse_file->ino == FUSE_ROOT_ID)
    return FALSE;
  if (!fuse_file->has_clip_data_id && !has_clip_data_id)
    return TRUE;
  if (fuse_file->has_clip_data_id && has_clip_data_id &&
      fuse_file->clip_data_id == clip_data_id)
    return TRUE;

return FALSE;
}

static gboolean
collect_fuse_file_to_steal (gpointer key,
                            gpointer value,
                            gpointer user_data)
{
  FuseFile *fuse_file = value;
  FuseFileStealContext *steal_context = user_data;

if (!should_remove_fuse_file (fuse_file,
                                steal_context->all_files,
                                steal_context->has_clip_data_id,
                                steal_context->clip_data_id))
    return FALSE;

steal_context->fuse_files = g_list_prepend (steal_context->fuse_files,
                                              fuse_file);

return TRUE;
}

static gboolean
maybe_clear_rdp_fuse_request (gpointer key,
                              gpointer value,
                              gpointer user_data)
{
  RdpFuseFileContentsRequest *rdp_fuse_request = value;
  ClearRdpFuseRequestContext *clear_context = user_data;
  GrdRdpFuseClipboard *rdp_fuse_clipboard = clear_context->rdp_fuse_clipboard;

if (!should_remove_fuse_file (rdp_fuse_request->fuse_file,
                                clear_context->all_files,
                                clear_context->has_clip_data_id,
                                clear_context->clip_data_id))
    return FALSE;

if (rdp_fuse_clipboard->fuse_handle)
    fuse_reply_err (rdp_fuse_request->fuse_req, EIO);
  g_free (rdp_fuse_request);

return TRUE;
}

void
grd_rdp_fuse_clipboard_dismiss_all_no_cdi_requests (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  ClearRdpFuseRequestContext clear_context = {0};

clear_context.rdp_fuse_clipboard = rdp_fuse_clipboard;

g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  g_hash_table_foreach_remove (rdp_fuse_clipboard->request_table,
                               maybe_clear_rdp_fuse_request, &clear_context);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
}

static void
invalidate_inode (gpointer data,
                  gpointer user_data)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = user_data;
  FuseFile *fuse_file = data;
  FuseFile *child;
  GList *l;

for (l = fuse_file->children; l; l = l->next)
    {
      child = l->data;

fuse_lowlevel_notify_delete (rdp_fuse_clipboard->fuse_handle,
                                   fuse_file->ino, child->ino,
                                   child->filename, strlen (child->filename));
    }
  g_debug ("[FUSE Clipboard] Invalidating inode %lu for file \"%s\"",
           fuse_file->ino, fuse_file->filename);
  fuse_lowlevel_notify_inval_inode (rdp_fuse_clipboard->fuse_handle,
                                    fuse_file->ino, 0, 0);
  g_debug ("[FUSE Clipboard] Inode %lu invalidated", fuse_file->ino);
}

static void
fuse_file_free (gpointer data)
{
  FuseFile *fuse_file = data;

g_list_free (fuse_file->children);
  g_free (fuse_file->filename_with_root);
  g_free (fuse_file);
}

static void
clear_selection (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                 gboolean             all_selections,
                 ClipDataEntry       *entry)
{
  FuseFileStealContext steal_context = {0};
  ClearRdpFuseRequestContext clear_context = {0};
  FuseFile *clip_data_dir = NULL;

g_assert (!g_mutex_trylock (&rdp_fuse_clipboard->selection_mutex));
  g_assert (!g_mutex_trylock (&rdp_fuse_clipboard->filesystem_mutex));

if (entry)
    {
      FuseFile *root_dir = rdp_fuse_clipboard->root_dir;

clip_data_dir = g_steal_pointer (&entry->clip_data_dir);
      root_dir->children = g_list_remove (root_dir->children, clip_data_dir);

steal_context.has_clip_data_id = clear_context.has_clip_data_id =
        entry->has_clip_data_id;
      steal_context.clip_data_id = clear_context.clip_data_id =
        entry->clip_data_id;
    }
  steal_context.all_files = clear_context.all_files = all_selections;
  clear_context.rdp_fuse_clipboard = rdp_fuse_clipboard;

if (entry && entry->has_clip_data_id)
    g_debug ("[FUSE Clipboard] Clearing selection for clipDataId %u", entry->clip_data_id);
  else
    g_debug ("[FUSE Clipboard] Clearing selection%s", all_selections ? "s" : "");
  g_hash_table_foreach_remove (rdp_fuse_clipboard->request_table,
                               maybe_clear_rdp_fuse_request, &clear_context);

g_hash_table_foreach_steal (rdp_fuse_clipboard->inode_table,
                              collect_fuse_file_to_steal, &steal_context);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

/**
   * fuse_lowlevel_notify_inval_inode() is a blocking operation. If we receive
   * a FUSE request (e.g. read()), then FUSE would block in read() since
   * filesystem_mutex would still be locked, if we wouldn't unlock it here.
   * fuse_lowlevel_notify_inval_inode() will block, since it waits on the FUSE
   * operation to finish.
   * So, to avoid a deadlock here, unlock the mutex and reply all incoming
   * operations with -ENOENT until the invalidation process is complete.
   */
  g_list_foreach (steal_context.fuse_files, invalidate_inode, rdp_fuse_clipboard);
  if (clip_data_dir)
    {
      fuse_lowlevel_notify_delete (rdp_fuse_clipboard->fuse_handle,
                                   rdp_fuse_clipboard->root_dir->ino,
                                   clip_data_dir->ino, clip_data_dir->filename,
                                   strlen (clip_data_dir->filename));
    }
  g_list_free_full (steal_context.fuse_files, fuse_file_free);

g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  if (entry && entry->has_clip_data_id)
    g_debug ("[FUSE Clipboard] Selection cleared for clipDataId %u", entry->clip_data_id);
  else
    g_debug ("[FUSE Clipboard] Selection%s cleared", all_selections ? "s" : "");
}

static void
clear_all_selections (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  g_mutex_lock (&rdp_fuse_clipboard->selection_mutex);
  g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);

clear_selection (rdp_fuse_clipboard, TRUE, NULL);

g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);
}

static void
clear_entry_selection (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                       ClipDataEntry       *entry)
{
  clear_selection (rdp_fuse_clipboard, FALSE, entry);
}

uint32_t
grd_rdp_fuse_clipboard_clip_data_id_new (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  GrdClipboardRdp *clipboard_rdp = rdp_fuse_clipboard->clipboard_rdp;
  ClipDataEntry *entry = NULL;

g_mutex_lock (&rdp_fuse_clipboard->selection_mutex);
  g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);

if (G_UNLIKELY (g_hash_table_size (rdp_fuse_clipboard->clip_data_table) >= UINT32_MAX))
    {
      GHashTableIter iter;
      ClipDataEntry *iter_value;

g_debug ("[FUSE Clipboard] All clipDataIds still used. Removing the oldest one");

g_hash_table_iter_init (&iter, rdp_fuse_clipboard->clip_data_table);
      while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &iter_value))
        {
          g_assert (iter_value->drop_context.drop_id);
          if (!entry || entry->drop_context.drop_id_timeout_set_us >
                        iter_value->drop_context.drop_id_timeout_set_us)
            entry = iter_value;
        }

g_debug ("[FUSE Clipboard] Force clearing selection with clipDataId %u",
               entry->clip_data_id);
      clear_entry_selection (rdp_fuse_clipboard, entry);

g_hash_table_remove (rdp_fuse_clipboard->clip_data_table,
                           GUINT_TO_POINTER (entry->clip_data_id));
    }

entry = g_malloc0 (sizeof (ClipDataEntry));
  entry->clipboard_rdp = clipboard_rdp;
  entry->has_clip_data_id = TRUE;

entry->clip_data_id = rdp_fuse_clipboard->next_clip_data_id;
  while (g_hash_table_contains (rdp_fuse_clipboard->clip_data_table,
                                GUINT_TO_POINTER (entry->clip_data_id)))
    ++entry->clip_data_id;

rdp_fuse_clipboard->next_clip_data_id = entry->clip_data_id + 1;

g_hash_table_insert (rdp_fuse_clipboard->clip_data_table,
                       GUINT_TO_POINTER (entry->clip_data_id), entry);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);

grd_clipboard_rdp_lock_remote_clipboard_data (clipboard_rdp, entry->clip_data_id);

return entry->clip_data_id;
}

void
grd_rdp_fuse_clipboard_clip_data_id_free (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                                          uint32_t             clip_data_id)
{
  ClipDataEntry *entry;

g_mutex_lock (&rdp_fuse_clipboard->selection_mutex);
  g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  if (!g_hash_table_lookup_extended (rdp_fuse_clipboard->clip_data_table,
                                     GUINT_TO_POINTER (clip_data_id),
                                     NULL, (gpointer *) &entry))
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);
      return;
    }
  clear_entry_selection (rdp_fuse_clipboard, entry);

g_hash_table_remove (rdp_fuse_clipboard->clip_data_table,
                       GUINT_TO_POINTER (clip_data_id));
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);
}

void
grd_rdp_fuse_clipboard_clear_no_cdi_selection (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  g_mutex_lock (&rdp_fuse_clipboard->selection_mutex);
  g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);

if (rdp_fuse_clipboard->no_cdi_entry)
    clear_entry_selection (rdp_fuse_clipboard, rdp_fuse_clipboard->no_cdi_entry);

g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);
}

static gboolean
drop_clip_data_entry (gpointer user_data)
{
  ClipDataEntry *entry = user_data;
  GrdRdpFuseClipboard *rdp_fuse_clipboard = entry->drop_context.rdp_fuse_clipboard;

g_debug ("[FUSE Clipboard] Dropping ClipDataEntry with clipDataId %u",
           entry->clip_data_id);

g_mutex_lock (&rdp_fuse_clipboard->selection_mutex);
  g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  clear_entry_selection (rdp_fuse_clipboard, entry);

entry->drop_context.drop_id = 0;
  g_hash_table_remove (rdp_fuse_clipboard->clip_data_table,
                       GUINT_TO_POINTER (entry->clip_data_id));
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);

return G_SOURCE_REMOVE;
}

static void
collect_instant_droppable_clip_data_entry (gpointer key,
                                           gpointer value,
                                           gpointer user_data)
{
  ClipDataEntry *entry = value;
  GList **droppable_clip_data_entries = user_data;

if (!entry->had_file_contents_request)
    {
      *droppable_clip_data_entries = g_list_prepend (*droppable_clip_data_entries,
                                                     entry);
    }
}

static void
clear_instant_droppable_clip_data_entry (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  GList *droppable_clip_data_entries = NULL;
  GList *l;

g_assert (!g_mutex_trylock (&rdp_fuse_clipboard->selection_mutex));
  g_assert (!g_mutex_trylock (&rdp_fuse_clipboard->filesystem_mutex));

g_hash_table_foreach (rdp_fuse_clipboard->clip_data_table,
                        collect_instant_droppable_clip_data_entry,
                        &droppable_clip_data_entries);
  for (l = droppable_clip_data_entries; l; l = l->next)
    {
      ClipDataEntry *entry = l->data;

g_debug ("[FUSE Clipboard] Instantly clearing selection for clipDataId %u",
               entry->clip_data_id);
      clear_entry_selection (rdp_fuse_clipboard, entry);

g_hash_table_remove (rdp_fuse_clipboard->clip_data_table,
                           GUINT_TO_POINTER (entry->clip_data_id));
    }

g_list_free (droppable_clip_data_entries);
}

static void
maybe_set_clip_data_entry_timeout (gpointer key,
                                   gpointer value,
                                   gpointer user_data)
{
  ClipDataEntry *entry = value;

if (entry->drop_context.drop_id)
    return;

g_debug ("[FUSE Clipboard] Setting timeout for selection with clipDataId %u",
           entry->clip_data_id);
  entry->drop_context.rdp_fuse_clipboard = user_data;
  entry->drop_context.drop_id = g_timeout_add (CLIP_DATA_ENTRY_DROP_TIMEOUT_MS,
                                               drop_clip_data_entry, entry);
  entry->drop_context.drop_id_timeout_set_us = g_get_monotonic_time ();
}

void
grd_rdp_fuse_clipboard_lazily_clear_all_cdi_selections (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  g_debug ("[FUSE Clipboard] Lazily clearing all selections with clipDataId");

g_mutex_lock (&rdp_fuse_clipboard->selection_mutex);
  g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  clear_instant_droppable_clip_data_entry (rdp_fuse_clipboard);

g_hash_table_foreach (rdp_fuse_clipboard->clip_data_table,
                        maybe_set_clip_data_entry_timeout,
                        rdp_fuse_clipboard);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);
}

static fuse_ino_t
get_next_free_inode (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  fuse_ino_t ino = rdp_fuse_clipboard->next_ino;

while (ino == 0 || ino == FUSE_ROOT_ID ||
         g_hash_table_contains (rdp_fuse_clipboard->inode_table,
                                GUINT_TO_POINTER (ino)))
    ++ino;

rdp_fuse_clipboard->next_ino = ino + 1;

return ino;
}

static FuseFile *
clip_data_dir_new (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                   gboolean             has_clip_data_id,
                   uint32_t             clip_data_id)
{
  FuseFile *root_dir = rdp_fuse_clipboard->root_dir;
  FuseFile *clip_data_dir;

clip_data_dir = g_malloc0 (sizeof (FuseFile));
  clip_data_dir->parent = rdp_fuse_clipboard->root_dir;
  clip_data_dir->filename_with_root =
    has_clip_data_id ? g_strdup_printf ("/%u", clip_data_id)
                     : g_strdup_printf ("/%lu", GRD_RDP_FUSE_CLIPBOARD_NO_CLIP_DATA_ID);
  clip_data_dir->filename =
    strrchr (clip_data_dir->filename_with_root, '/') + 1;
  clip_data_dir->ino = get_next_free_inode (rdp_fuse_clipboard);
  clip_data_dir->is_directory = TRUE;
  clip_data_dir->is_readonly = TRUE;
  clip_data_dir->has_clip_data_id = has_clip_data_id;
  clip_data_dir->clip_data_id = clip_data_id;

root_dir->children = g_list_append (root_dir->children, clip_data_dir);
  clip_data_dir->parent = root_dir;

g_hash_table_insert (rdp_fuse_clipboard->inode_table,
                       GUINT_TO_POINTER (clip_data_dir->ino), clip_data_dir);

return clip_data_dir;
}

static gboolean
is_fuse_file_parent (gpointer key,
                     gpointer value,
                     gpointer user_data)
{
  FuseFile *fuse_file = value;
  const char *parent_path = user_data;

if (strcmp (parent_path, fuse_file->filename_with_root) == 0)
    return TRUE;

return FALSE;
}

static FuseFile *
get_parent_directory (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                      const char          *path)
{
  FuseFile *parent;
  char *parent_path;

parent_path = g_path_get_dirname (path);
  parent = g_hash_table_find (rdp_fuse_clipboard->inode_table,
                              is_fuse_file_parent, parent_path);

g_free (parent_path);

return parent;
}

static gboolean
set_selection_for_clip_data_entry (GrdRdpFuseClipboard *rdp_fuse_clipboard,
#ifdef HAVE_FREERDP_2_3
                                   FILEDESCRIPTORW     *files,
#else
                                   FILEDESCRIPTOR      *files,
#endif /* HAVE_FREERDP_2_3 */
                                   uint32_t             n_files,
                                   ClipDataEntry       *entry)
{
  FuseFile *clip_data_dir = entry->clip_data_dir;
  uint32_t clip_data_id = clip_data_dir->clip_data_id;
  uint32_t i;

if (entry->has_clip_data_id)
    g_debug ("[FUSE Clipboard] Setting selection for clipDataId %u", clip_data_id);
  else
    g_debug ("[FUSE Clipboard] Setting selection");

for (i = 0; i < n_files; ++i)
    {
#ifdef HAVE_FREERDP_2_3
      FILEDESCRIPTORW *file;
#else
      FILEDESCRIPTOR *file;
#endif /* HAVE_FREERDP_2_3 */
      FuseFile *fuse_file, *parent;
      char *filename = NULL;
      uint32_t j;

file = &files[i];

fuse_file = g_malloc0 (sizeof (FuseFile));
      if (!(file->dwFlags & FD_ATTRIBUTES))
        g_warning ("[RDP.CLIPRDR] Client did not set the FD_ATTRIBUTES flag");

if (ConvertFromUnicode (CP_UTF8, 0, file->cFileName, -1, &filename,
                              0, NULL, NULL) <= 0)
        {
          g_warning ("[RDP.CLIPRDR] Failed to convert filename. Aborting "
                     "SelectionTransfer");
          clear_entry_selection (rdp_fuse_clipboard, entry);

g_free (fuse_file);

return FALSE;
        }

for (j = 0; filename[j]; ++j)
        {
          if (filename[j] == '\\')
            filename[j] = '/';
        }
      fuse_file->filename_with_root =
        g_strdup_printf ("%s/%s", clip_data_dir->filename_with_root, filename);
      fuse_file->filename = strrchr (fuse_file->filename_with_root, '/') + 1;
      g_free (filename);

parent = get_parent_directory (rdp_fuse_clipboard,
                                     fuse_file->filename_with_root);
      parent->children = g_list_append (parent->children, fuse_file);
      fuse_file->parent = parent;

fuse_file->list_idx = i;
      fuse_file->ino = get_next_free_inode (rdp_fuse_clipboard);
      fuse_file->has_clip_data_id = entry->has_clip_data_id;
      fuse_file->clip_data_id = clip_data_id;
      fuse_file->entry = entry;
      if (file->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        fuse_file->is_directory = TRUE;
      if (file->dwFileAttributes & FILE_ATTRIBUTE_READONLY)
        fuse_file->is_readonly = TRUE;
      if (file->dwFlags & FD_FILESIZE)
        {
          fuse_file->size = ((uint64_t) file->nFileSizeHigh << 32) +
                            file->nFileSizeLow;
          fuse_file->has_size = TRUE;
        }
#ifdef HAVE_FREERDP_2_3
      if (file->dwFlags & FD_WRITETIME)
#else
      if (file->dwFlags & FD_WRITESTIME)
#endif /* HAVE_FREERDP_2_3 */
        {
          uint64_t filetime;

filetime = file->ftLastWriteTime.dwHighDateTime;
          filetime <<= 32;
          filetime += file->ftLastWriteTime.dwLowDateTime;

fuse_file->last_write_time_unix = filetime / (10 * G_USEC_PER_SEC) -
                                            WIN32_FILETIME_TO_UNIX_EPOCH;
          fuse_file->has_last_write_time = TRUE;
        }
      g_hash_table_insert (rdp_fuse_clipboard->inode_table,
                           GUINT_TO_POINTER (fuse_file->ino), fuse_file);
    }
  if (entry->has_clip_data_id)
    g_debug ("[FUSE Clipboard] Selection set for clipDataId %u", clip_data_id);
  else
    g_debug ("[FUSE Clipboard] Selection set");

return TRUE;
}

gboolean
grd_rdp_fuse_clipboard_set_cdi_selection (GrdRdpFuseClipboard *rdp_fuse_clipboard,
#ifdef HAVE_FREERDP_2_3
                                          FILEDESCRIPTORW     *files,
#else
                                          FILEDESCRIPTOR      *files,
#endif /* HAVE_FREERDP_2_3 */
                                          uint32_t             n_files,
                                          uint32_t             clip_data_id)
{
  ClipDataEntry *entry;
  gboolean result;

entry->clip_data_dir = clip_data_dir_new (rdp_fuse_clipboard,
                                            TRUE, clip_data_id);

result = set_selection_for_clip_data_entry (rdp_fuse_clipboard,
                                              files, n_files, entry);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);

return result;
}

gboolean
grd_rdp_fuse_clipboard_set_no_cdi_selection (GrdRdpFuseClipboard *rdp_fuse_clipboard,
#ifdef HAVE_FREERDP_2_3
                                             FILEDESCRIPTORW     *files,
#else
                                             FILEDESCRIPTOR      *files,
#endif /* HAVE_FREERDP_2_3 */
                                             uint32_t             n_files)
{
  gboolean result;

g_mutex_lock (&rdp_fuse_clipboard->selection_mutex);
  g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  if (!rdp_fuse_clipboard->no_cdi_entry)
    rdp_fuse_clipboard->no_cdi_entry = g_malloc0 (sizeof (ClipDataEntry));
  if (rdp_fuse_clipboard->no_cdi_entry->clip_data_dir)
    clear_entry_selection (rdp_fuse_clipboard, rdp_fuse_clipboard->no_cdi_entry);

rdp_fuse_clipboard->no_cdi_entry->clip_data_dir =
    clip_data_dir_new (rdp_fuse_clipboard, FALSE, 0);

result = set_selection_for_clip_data_entry (rdp_fuse_clipboard, files, n_files,
                                              rdp_fuse_clipboard->no_cdi_entry);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_unlock (&rdp_fuse_clipboard->selection_mutex);

return result;
}

static void
write_file_attributes (FuseFile    *fuse_file,
                       struct stat *attr)
{
  memset (attr, 0, sizeof (struct stat));

if (!fuse_file)
    return;

attr->st_ino = fuse_file->ino;
  if (fuse_file->is_directory)
    {
      attr->st_mode = S_IFDIR | (fuse_file->is_readonly ? 0555 : 0755);
      attr->st_nlink = 2;
    }
  else
    {
      attr->st_mode = S_IFREG | (fuse_file->is_readonly ? 0444 : 0644);
      attr->st_nlink = 1;
      attr->st_size = fuse_file->size;
    }
  attr->st_uid = getuid ();
  attr->st_gid = getgid ();
  attr->st_atime = attr->st_mtime = attr->st_ctime =
    (fuse_file->has_last_write_time ? fuse_file->last_write_time_unix
                                    : time (NULL));
}

static void
maybe_queue_clip_data_entry_timeout_reset (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                                           ClipDataEntry       *entry)
{
  int64_t drop_id_timeout_set_us = entry->drop_context.drop_id_timeout_set_us;
  int64_t now_us;

if (!entry->drop_context.drop_id)
    return;

now_us = g_get_monotonic_time ();
  if (now_us - drop_id_timeout_set_us < CLIP_DATA_ENTRY_DROP_TIMEOUT_DELTA_US)
    return;

g_debug ("[FUSE Clipboard] Queueing a timeout reset for selection with "
           "clipDataId %u", entry->clip_data_id);
  g_hash_table_add (rdp_fuse_clipboard->timeouts_to_reset,
                    GUINT_TO_POINTER (entry->clip_data_id));
  g_source_set_ready_time (rdp_fuse_clipboard->timeout_reset_source, 0);
}

void
grd_rdp_fuse_clipboard_submit_file_contents_response (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                                                      uint32_t             stream_id,
                                                      gboolean             response_ok,
                                                      const uint8_t       *data,
                                                      uint32_t             size)
{
  RdpFuseFileContentsRequest *rdp_fuse_request;
  struct fuse_entry_param entry = {0};

g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  if (!g_hash_table_steal_extended (rdp_fuse_clipboard->request_table,
                                    GUINT_TO_POINTER (stream_id),
                                    NULL, (gpointer *) &rdp_fuse_request))
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      return;
    }

if (!response_ok)
    {
      g_warning ("[RDP.CLIPRDR] Failed to retrieve file data for file \"%s\" "
                 "from the client", rdp_fuse_request->fuse_file->filename);
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

fuse_reply_err (rdp_fuse_request->fuse_req, EIO);
      g_free (rdp_fuse_request);
      return;
    }

maybe_queue_clip_data_entry_timeout_reset (rdp_fuse_clipboard,
                                             rdp_fuse_request->fuse_file->entry);

if (rdp_fuse_request->operation_type == FUSE_LL_OPERATION_LOOKUP ||
      rdp_fuse_request->operation_type == FUSE_LL_OPERATION_GETATTR)
    {
      g_debug ("[FUSE Clipboard] Received file size for file \"%s\" with stream "
               "id %u", rdp_fuse_request->fuse_file->filename, stream_id);

rdp_fuse_request->fuse_file->size = *((uint64_t *) data);
      rdp_fuse_request->fuse_file->has_size = TRUE;

entry.ino = rdp_fuse_request->fuse_file->ino;
      write_file_attributes (rdp_fuse_request->fuse_file, &entry.attr);
      entry.attr_timeout = 1.0;
      entry.entry_timeout = 1.0;
    }
  else if (rdp_fuse_request->operation_type == FUSE_LL_OPERATION_READ)
    {
      g_debug ("[FUSE Clipboard] Received file range for file \"%s\" with stream "
               "id %u", rdp_fuse_request->fuse_file->filename, stream_id);
    }
  else
    {
      g_assert_not_reached ();
    }
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

switch (rdp_fuse_request->operation_type)
    {
    case FUSE_LL_OPERATION_NONE:
      break;
    case FUSE_LL_OPERATION_LOOKUP:
      fuse_reply_entry (rdp_fuse_request->fuse_req, &entry);
      break;
    case FUSE_LL_OPERATION_GETATTR:
      fuse_reply_attr (rdp_fuse_request->fuse_req, &entry.attr, entry.attr_timeout);
      break;
    case FUSE_LL_OPERATION_READ:
      fuse_reply_buf (rdp_fuse_request->fuse_req, (const char *) data, size);
      break;
    }

g_free (rdp_fuse_request);
}

static RdpFuseFileContentsRequest *
rdp_fuse_file_contents_request_new (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                                    FuseFile            *fuse_file,
                                    fuse_req_t           fuse_req)
{
  RdpFuseFileContentsRequest *rdp_fuse_request;
  uint32_t stream_id = rdp_fuse_clipboard->next_stream_id;

fuse_file->entry->had_file_contents_request = TRUE;
  maybe_queue_clip_data_entry_timeout_reset (rdp_fuse_clipboard,
                                             fuse_file->entry);

rdp_fuse_request = g_malloc0 (sizeof (RdpFuseFileContentsRequest));
  rdp_fuse_request->fuse_file = fuse_file;
  rdp_fuse_request->fuse_req = fuse_req;

while (g_hash_table_contains (rdp_fuse_clipboard->request_table,
                                GUINT_TO_POINTER (stream_id)))
    ++stream_id;
  rdp_fuse_request->stream_id = stream_id;

rdp_fuse_clipboard->next_stream_id = stream_id + 1;

return rdp_fuse_request;
}

static void
request_file_size_async (GrdRdpFuseClipboard       *rdp_fuse_clipboard,
                         FuseFile                  *fuse_file,
                         fuse_req_t                 fuse_req,
                         FuseLowlevelOperationType  operation_type)
{
  GrdClipboardRdp *clipboard_rdp = rdp_fuse_clipboard->clipboard_rdp;
  RdpFuseFileContentsRequest *rdp_fuse_request;

rdp_fuse_request = rdp_fuse_file_contents_request_new (rdp_fuse_clipboard,
                                                         fuse_file,
                                                         fuse_req);
  rdp_fuse_request->operation_type = operation_type;

g_hash_table_insert (rdp_fuse_clipboard->request_table,
                       GUINT_TO_POINTER (rdp_fuse_request->stream_id),
                       rdp_fuse_request);

g_debug ("[FUSE Clipboard] Requesting file size for file \"%s\" with stream id"
           " %u", fuse_file->filename, rdp_fuse_request->stream_id);
  grd_clipboard_rdp_request_remote_file_size_async (clipboard_rdp,
                                                    rdp_fuse_request->stream_id,
                                                    fuse_file->list_idx,
                                                    fuse_file->has_clip_data_id,
                                                    fuse_file->clip_data_id);
}

static void
request_file_range_async (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                          FuseFile            *fuse_file,
                          fuse_req_t           fuse_req,
                          uint64_t             offset,
                          uint32_t             requested_size)
{
  GrdClipboardRdp *clipboard_rdp = rdp_fuse_clipboard->clipboard_rdp;
  RdpFuseFileContentsRequest *rdp_fuse_request;

rdp_fuse_request = rdp_fuse_file_contents_request_new (rdp_fuse_clipboard,
                                                         fuse_file,
                                                         fuse_req);
  rdp_fuse_request->operation_type = FUSE_LL_OPERATION_READ;

g_hash_table_insert (rdp_fuse_clipboard->request_table,
                       GUINT_TO_POINTER (rdp_fuse_request->stream_id),
                       rdp_fuse_request);

g_debug ("[FUSE Clipboard] Requesting file range (%u Bytes at offset %lu) for "
           "file \"%s\" with stream id %u", requested_size, offset,
           fuse_file->filename, rdp_fuse_request->stream_id);
  grd_clipboard_rdp_request_remote_file_range_async (clipboard_rdp,
                                                     rdp_fuse_request->stream_id,
                                                     fuse_file->list_idx,
                                                     offset, requested_size,
                                                     fuse_file->has_clip_data_id,
                                                     fuse_file->clip_data_id);
}

static FuseFile *
get_fuse_file_by_ino (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                      fuse_ino_t           fuse_ino)
{
  FuseFile *fuse_file;

fuse_file = g_hash_table_lookup (rdp_fuse_clipboard->inode_table,
                                   GUINT_TO_POINTER (fuse_ino));

return fuse_file;
}

static FuseFile *
get_fuse_file_by_name_from_parent (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                                   FuseFile            *parent,
                                   const char          *name)
{
  FuseFile *child;
  GList *l;

for (l = parent->children; l; l = l->next)
    {
      child = l->data;

if (strcmp (name, child->filename) == 0)
        return child;
    }

/**
   * This is not an error since several applications try to find specific files,
   * e.g. nautilus tries to find "/.Trash", etc.
   */
  g_debug ("[FUSE Clipboard] Requested file \"%s\" in directory \"%s\" does not "
           "exist", name, parent->filename);

return NULL;
}

static void
fuse_ll_lookup (fuse_req_t  fuse_req,
                fuse_ino_t  parent_ino,
                const char *name)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = fuse_req_userdata (fuse_req);
  FuseFile *parent, *fuse_file;
  struct fuse_entry_param entry = {0};

g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  if (!(parent = get_fuse_file_by_ino (rdp_fuse_clipboard, parent_ino)) ||
      !parent->is_directory)
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, ENOENT);
      return;
    }
  if (!(fuse_file = get_fuse_file_by_name_from_parent (
                      rdp_fuse_clipboard, parent, name)))
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, ENOENT);
      return;
    }

g_debug ("[FUSE Clipboard] lookup() has been called for \"%s\"", name);
  g_debug ("[FUSE Clipboard] Parent is \"%s\", child is \"%s\"",
           parent->filename_with_root, fuse_file->filename_with_root);

if (!fuse_file->is_directory && !fuse_file->has_size)
    {
      request_file_size_async (rdp_fuse_clipboard, fuse_file, fuse_req,
                               FUSE_LL_OPERATION_LOOKUP);
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      return;
    }

entry.ino = fuse_file->ino;
  write_file_attributes (fuse_file, &entry.attr);
  entry.attr_timeout = 1.0;
  entry.entry_timeout = 1.0;
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

fuse_reply_entry (fuse_req, &entry);
}

static void
fuse_ll_getattr (fuse_req_t             fuse_req,
                 fuse_ino_t             fuse_ino,
                 struct fuse_file_info *file_info)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = fuse_req_userdata (fuse_req);
  FuseFile *fuse_file;
  struct stat attr = {0};

g_debug ("[FUSE Clipboard] getattr() has been called for file \"%s\"",
           fuse_file->filename_with_root);

if (!fuse_file->is_directory && !fuse_file->has_size)
    {
      request_file_size_async (rdp_fuse_clipboard, fuse_file, fuse_req,
                               FUSE_LL_OPERATION_GETATTR);
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      return;
    }

write_file_attributes (fuse_file, &attr);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

fuse_reply_attr (fuse_req, &attr, 1.0);
}

static void
fuse_ll_open (fuse_req_t             fuse_req,
              fuse_ino_t             fuse_ino,
              struct fuse_file_info *file_info)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = fuse_req_userdata (fuse_req);
  FuseFile *fuse_file;

g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  if (!(fuse_file = get_fuse_file_by_ino (rdp_fuse_clipboard, fuse_ino)))
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, ENOENT);
      return;
    }
  if (fuse_file->is_directory)
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, EISDIR);
      return;
    }
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

if ((file_info->flags & O_ACCMODE) != O_RDONLY)
    {
      fuse_reply_err (fuse_req, EACCES);
      return;
    }

/* Using direct_io also increases FUSE_MAX_PAGES_PER_REQ */
  file_info->direct_io = 1;

g_debug ("[FUSE Clipboard] Opening file \"%s\"", fuse_file->filename_with_root);
  fuse_reply_open (fuse_req, file_info);
}

static void
fuse_ll_read (fuse_req_t             fuse_req,
              fuse_ino_t             fuse_ino,
              size_t                 size,
              off_t                  offset,
              struct fuse_file_info *file_info)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = fuse_req_userdata (fuse_req);
  FuseFile *fuse_file;

g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  if (!(fuse_file = get_fuse_file_by_ino (rdp_fuse_clipboard, fuse_ino)))
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, ENOENT);
      return;
    }
  if (fuse_file->is_directory)
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, EISDIR);
      return;
    }
  if (!fuse_file->has_size || offset > fuse_file->size)
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, EINVAL);
      return;
    }

size = MIN (size, 8 * 1024 * 1024);
  g_assert (size > 0);

request_file_range_async (rdp_fuse_clipboard, fuse_file, fuse_req,
                            offset, size);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
}

static void
fuse_ll_opendir (fuse_req_t             fuse_req,
                 fuse_ino_t             fuse_ino,
                 struct fuse_file_info *file_info)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = fuse_req_userdata (fuse_req);
  FuseFile *fuse_file;

g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  if (!(fuse_file = get_fuse_file_by_ino (rdp_fuse_clipboard, fuse_ino)))
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, ENOENT);
      return;
    }
  if (!fuse_file->is_directory)
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_err (fuse_req, ENOTDIR);
      return;
    }
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

if ((file_info->flags & O_ACCMODE) != O_RDONLY)
    {
      fuse_reply_err (fuse_req, EACCES);
      return;
    }

g_debug ("[FUSE Clipboard] Opening directory \"%s\"",
           fuse_file->filename_with_root);
  fuse_reply_open (fuse_req, file_info);
}

static void
fuse_ll_readdir (fuse_req_t             fuse_req,
                 fuse_ino_t             fuse_ino,
                 size_t                 max_size,
                 off_t                  offset,
                 struct fuse_file_info *file_info)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = fuse_req_userdata (fuse_req);
  FuseFile *fuse_file, *child;
  struct stat attr = {0};
  size_t written_size, entry_size;
  char *filename;
  char *buf;
  off_t i;
  GList *l;

g_debug ("[FUSE Clipboard] Reading directory \"%s\" at offset %lu",
           fuse_file->filename_with_root, offset);

if (offset >= g_list_length (fuse_file->children) + 1)
    {
      g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);
      fuse_reply_buf (fuse_req, NULL, 0);
      return;
    }

buf = g_malloc0 (max_size);
  written_size = 0;

for (i = offset; i < 2; ++i)
    {
      if (i == 0)
        {
          write_file_attributes (fuse_file, &attr);
          filename = ".";
        }
      else if (i == 1)
        {
          write_file_attributes (fuse_file->parent, &attr);
          attr.st_ino = fuse_file->parent ? attr.st_ino : FUSE_ROOT_ID;
          attr.st_mode = fuse_file->parent ? attr.st_mode : 0555;
          filename = "..";
        }
      else
        {
          g_assert_not_reached ();
        }

/**
       * buf needs to be large enough to hold the entry. If it's not, then the
       * entry is not filled in but the size of the entry is still returned.
       */
      entry_size = fuse_add_direntry (fuse_req, buf + written_size,
                                      max_size - written_size,
                                      filename, &attr, i);
      if (entry_size > max_size - written_size)
        break;

written_size += entry_size;
    }

for (l = fuse_file->children, i = 2; l; l = l->next, ++i)
    {
      if (i <= offset)
        continue;

child = l->data;

write_file_attributes (child, &attr);
      entry_size = fuse_add_direntry (fuse_req, buf + written_size,
                                      max_size - written_size,
                                      child->filename, &attr, i);
      if (entry_size > max_size - written_size)
        break;

written_size += entry_size;
    }
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

fuse_reply_buf (fuse_req, buf, written_size);
  g_free (buf);
}

static const struct fuse_lowlevel_ops fuse_ll_ops =
{
  .lookup = fuse_ll_lookup,
  .getattr = fuse_ll_getattr,
  .open = fuse_ll_open,
  .read = fuse_ll_read,
  .opendir = fuse_ll_opendir,
  .readdir = fuse_ll_readdir,
};

static gpointer
fuse_thread_func (gpointer data)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = data;
  struct fuse_args args = {0};
  char *argv[1];
  int result;

g_debug ("[FUSE Clipboard] FUSE thread started");

argv[0] = program_invocation_name;
  args.argc = 1;
  args.argv = argv;

rdp_fuse_clipboard->fuse_handle = fuse_session_new (&args, &fuse_ll_ops,
                                                      sizeof (fuse_ll_ops),
                                                      rdp_fuse_clipboard);
  if (!rdp_fuse_clipboard->fuse_handle)
    g_error ("[FUSE Clipboard] Failed to create FUSE filesystem");

if (fuse_session_mount (rdp_fuse_clipboard->fuse_handle,
                          rdp_fuse_clipboard->mount_path))
    g_error ("[FUSE Clipboard] Failed to mount FUSE filesystem");

fuse_daemonize (1);

SetEvent (rdp_fuse_clipboard->start_event);

g_debug ("[FUSE Clipboard] Starting FUSE session");
  result = fuse_session_loop (rdp_fuse_clipboard->fuse_handle);
  if (result < 0)
    g_error ("fuse_loop() failed: %s", g_strerror (-result));

g_debug ("[FUSE Clipboard] Unmounting FUSE filesystem");
  fuse_session_unmount (rdp_fuse_clipboard->fuse_handle);

WaitForSingleObject (rdp_fuse_clipboard->stop_event, INFINITE);
  g_clear_pointer (&rdp_fuse_clipboard->fuse_handle, fuse_session_destroy);

return NULL;
}

GrdRdpFuseClipboard *
grd_rdp_fuse_clipboard_new (GrdClipboardRdp *clipboard_rdp,
                            const char      *mount_path)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard;

rdp_fuse_clipboard = g_object_new (GRD_TYPE_RDP_FUSE_CLIPBOARD, NULL);
  rdp_fuse_clipboard->clipboard_rdp = clipboard_rdp;
  rdp_fuse_clipboard->mount_path = g_strdup (mount_path);

rdp_fuse_clipboard->start_event = CreateEvent (NULL, TRUE, FALSE, NULL);
  rdp_fuse_clipboard->stop_event = CreateEvent (NULL, TRUE, FALSE, NULL);
  rdp_fuse_clipboard->fuse_thread = g_thread_new ("RDP FUSE clipboard thread",
                                                  fuse_thread_func,
                                                  rdp_fuse_clipboard);
  if (!rdp_fuse_clipboard->fuse_thread)
    g_error ("[FUSE Clipboard] Failed to create FUSE thread");

WaitForSingleObject (rdp_fuse_clipboard->start_event, INFINITE);
  g_clear_pointer (&rdp_fuse_clipboard->start_event, CloseHandle);

return rdp_fuse_clipboard;
}

static void
dismiss_all_requests (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  ClearRdpFuseRequestContext clear_context = {0};

clear_context.rdp_fuse_clipboard = rdp_fuse_clipboard;
  clear_context.all_files = TRUE;

static void
grd_rdp_fuse_clipboard_dispose (GObject *object)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = GRD_RDP_FUSE_CLIPBOARD (object);

if (rdp_fuse_clipboard->timeout_reset_source)
    g_source_destroy (rdp_fuse_clipboard->timeout_reset_source);
  g_clear_pointer (&rdp_fuse_clipboard->timeout_reset_source, g_source_unref);

if (rdp_fuse_clipboard->fuse_thread)
    {
      struct stat attr;

g_assert (rdp_fuse_clipboard->fuse_handle);
      g_assert (!rdp_fuse_clipboard->start_event);

clear_all_selections (rdp_fuse_clipboard);

g_debug ("[FUSE Clipboard] Stopping FUSE thread");
      fuse_session_exit (rdp_fuse_clipboard->fuse_handle);
      dismiss_all_requests (rdp_fuse_clipboard);
      SetEvent (rdp_fuse_clipboard->stop_event);

/**
       * FUSE does not immediately stop the session after fuse_session_exit() has
       * been called.
       * Instead, it waits on a new operation. Upon retrieving this new
       * operation, it checks the exit flag and then stops the session loop.
       * So, trigger a FUSE operation by poking at the FUSE root dir to
       * effectively stop the session.
       */
      stat (rdp_fuse_clipboard->mount_path, &attr);

g_debug ("[FUSE Clipboard] Waiting on FUSE thread");
      g_clear_pointer (&rdp_fuse_clipboard->fuse_thread, g_thread_join);
      g_debug ("[FUSE Clipboard] FUSE thread stopped");
      g_clear_pointer (&rdp_fuse_clipboard->stop_event, CloseHandle);
    }

g_clear_pointer (&rdp_fuse_clipboard->mount_path, g_free);

if (rdp_fuse_clipboard->request_table)
    {
      dismiss_all_requests (rdp_fuse_clipboard);
      g_clear_pointer (&rdp_fuse_clipboard->request_table, g_hash_table_unref);
    }
  g_clear_pointer (&rdp_fuse_clipboard->no_cdi_entry, g_free);
  g_clear_pointer (&rdp_fuse_clipboard->clip_data_table, g_hash_table_destroy);
  g_clear_pointer (&rdp_fuse_clipboard->inode_table, g_hash_table_destroy);
  g_clear_pointer (&rdp_fuse_clipboard->timeouts_to_reset, g_hash_table_destroy);

G_OBJECT_CLASS (grd_rdp_fuse_clipboard_parent_class)->dispose (object);
}

static void
clip_data_entry_free (gpointer data)
{
  ClipDataEntry *entry = data;

grd_clipboard_rdp_unlock_remote_clipboard_data (entry->clipboard_rdp,
                                                  entry->clip_data_id);

g_clear_handle_id (&entry->drop_context.drop_id, g_source_remove);

g_free (entry);
}

static FuseFile *
fuse_file_new_root (void)
{
  FuseFile *root_dir;

root_dir = g_malloc0 (sizeof (FuseFile));
  root_dir->filename_with_root = strdup ("/");
  root_dir->filename = root_dir->filename_with_root;
  root_dir->ino = FUSE_ROOT_ID;
  root_dir->is_directory = TRUE;
  root_dir->is_readonly = TRUE;

return root_dir;
}

static gboolean
maybe_reset_clip_data_entry_timeout (gpointer key,
                                     gpointer value,
                                     gpointer user_data)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = user_data;
  uint32_t clip_data_id = GPOINTER_TO_UINT (key);
  ClipDataEntry *entry;

if (!g_hash_table_lookup_extended (rdp_fuse_clipboard->clip_data_table,
                                     GUINT_TO_POINTER (clip_data_id),
                                     NULL, (gpointer *) &entry))
    return TRUE;

if (!entry->drop_context.drop_id)
    return TRUE;

g_debug ("[FUSE Clipboard] Resetting timeout for selection with clipDataId %u",
           clip_data_id);
  g_clear_handle_id (&entry->drop_context.drop_id, g_source_remove);
  entry->drop_context.drop_id = g_timeout_add (CLIP_DATA_ENTRY_DROP_TIMEOUT_MS,
                                               drop_clip_data_entry, entry);
  entry->drop_context.drop_id_timeout_set_us = g_get_monotonic_time ();

return TRUE;
}

static gboolean
reset_clip_data_entry_timeouts (gpointer user_data)
{
  GrdRdpFuseClipboard *rdp_fuse_clipboard = user_data;

g_mutex_lock (&rdp_fuse_clipboard->filesystem_mutex);
  g_hash_table_foreach_remove (rdp_fuse_clipboard->timeouts_to_reset,
                               maybe_reset_clip_data_entry_timeout,
                               rdp_fuse_clipboard);
  g_mutex_unlock (&rdp_fuse_clipboard->filesystem_mutex);

return G_SOURCE_CONTINUE;
}

static gboolean
timeout_reset_source_dispatch (GSource     *source,
                               GSourceFunc  callback,
                               gpointer     user_data)
{
  g_source_set_ready_time (source, -1);

return callback (user_data);
}

static GSourceFuncs timeout_reset_source_funcs =
{
  .dispatch = timeout_reset_source_dispatch,
};

static void
grd_rdp_fuse_clipboard_init (GrdRdpFuseClipboard *rdp_fuse_clipboard)
{
  GSource *timeout_reset_source;

rdp_fuse_clipboard->timeouts_to_reset = g_hash_table_new (NULL, NULL);
  rdp_fuse_clipboard->inode_table = g_hash_table_new (NULL, NULL);
  rdp_fuse_clipboard->clip_data_table = g_hash_table_new_full (NULL, NULL, NULL,
                                                               clip_data_entry_free);
  rdp_fuse_clipboard->request_table = g_hash_table_new (NULL, NULL);

rdp_fuse_clipboard->root_dir = fuse_file_new_root ();
  g_hash_table_insert (rdp_fuse_clipboard->inode_table,
                       GUINT_TO_POINTER (rdp_fuse_clipboard->root_dir->ino),
                       rdp_fuse_clipboard->root_dir);

g_mutex_init (&rdp_fuse_clipboard->filesystem_mutex);
  g_mutex_init (&rdp_fuse_clipboard->selection_mutex);

timeout_reset_source = g_source_new (&timeout_reset_source_funcs,
                                       sizeof (GSource));
  g_source_set_callback (timeout_reset_source, reset_clip_data_entry_timeouts,
                         rdp_fuse_clipboard, NULL);
  g_source_set_ready_time (timeout_reset_source, -1);
  g_source_attach (timeout_reset_source, g_main_context_get_thread_default ());
  rdp_fuse_clipboard->timeout_reset_source = timeout_reset_source;
}

static void
grd_rdp_fuse_clipboard_class_init (GrdRdpFuseClipboardClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->dispose = grd_rdp_fuse_clipboard_dispose;
}
07070100000026000081A40000000000000000000000016141EE1000000CD5000000000000000000000000000000000000003700000000gnome-remote-desktop-40.2/src/grd-rdp-fuse-clipboard.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_RDP_FUSE_CLIPBOARD_H
#define GRD_RDP_FUSE_CLIPBOARD_H

#include <glib-object.h>
#include <winpr2/winpr/shell.h>

#include "grd-types.h"

#define GRD_RDP_FUSE_CLIPBOARD_NO_CLIP_DATA_ID (UINT64_C (1) << 32)

#define GRD_TYPE_RDP_FUSE_CLIPBOARD (grd_rdp_fuse_clipboard_get_type ())
G_DECLARE_FINAL_TYPE (GrdRdpFuseClipboard, grd_rdp_fuse_clipboard,
                      GRD, RDP_FUSE_CLIPBOARD, GObject);

GrdRdpFuseClipboard *grd_rdp_fuse_clipboard_new (GrdClipboardRdp *clipboard_rdp,
                                                 const char      *mount_path);

uint32_t grd_rdp_fuse_clipboard_clip_data_id_new (GrdRdpFuseClipboard *rdp_fuse_clipboard);

void grd_rdp_fuse_clipboard_clip_data_id_free (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                                               uint32_t             clip_data_id);

void grd_rdp_fuse_clipboard_dismiss_all_no_cdi_requests (GrdRdpFuseClipboard *rdp_fuse_clipboard);

void grd_rdp_fuse_clipboard_clear_no_cdi_selection (GrdRdpFuseClipboard *rdp_fuse_clipboard);

void grd_rdp_fuse_clipboard_lazily_clear_all_cdi_selections (GrdRdpFuseClipboard *rdp_fuse_clipboard);

gboolean grd_rdp_fuse_clipboard_set_cdi_selection (GrdRdpFuseClipboard *rdp_fuse_clipboard,
#ifdef HAVE_FREERDP_2_3
                                                   FILEDESCRIPTORW     *files,
#else
                                                   FILEDESCRIPTOR      *files,
#endif /* HAVE_FREERDP_2_3 */
                                                   uint32_t             n_files,
                                                   uint32_t             clip_data_id);

gboolean grd_rdp_fuse_clipboard_set_no_cdi_selection (GrdRdpFuseClipboard *rdp_fuse_clipboard,
#ifdef HAVE_FREERDP_2_3
                                                      FILEDESCRIPTORW     *files,
#else
                                                      FILEDESCRIPTOR      *files,
#endif /* HAVE_FREERDP_2_3 */
                                                      uint32_t             n_files);

void grd_rdp_fuse_clipboard_submit_file_contents_response (GrdRdpFuseClipboard *rdp_fuse_clipboard,
                                                           uint32_t             stream_id,
                                                           gboolean             response_ok,
                                                           const uint8_t       *data,
                                                           uint32_t             size);

#endif /* GRD_RDP_FUSE_CLIPBOARD_H */
07070100000027000081A40000000000000000000000016141EE1000004729000000000000000000000000000000000000003800000000gnome-remote-desktop-40.2/src/grd-rdp-pipewire-stream.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-rdp-pipewire-stream.h"

#include <linux/dma-buf.h>
#include <pipewire/pipewire.h>
#include <spa/param/props.h>
#include <spa/param/format-utils.h>
#include <spa/param/video/format-utils.h>
#include <spa/utils/result.h>
#include <sys/mman.h>
#include <sys/syscall.h>

#include "grd-pipewire-utils.h"

enum
{
  CLOSED,

N_SIGNALS
};

static guint signals[N_SIGNALS];

typedef struct _GrdRdpFrame
{
  void *data;
  uint8_t *pointer_bitmap;
  uint16_t pointer_hotspot_x;
  uint16_t pointer_hotspot_y;
  uint16_t pointer_width;
  uint16_t pointer_height;
  gboolean pointer_is_hidden;
} GrdRdpFrame;

struct _GrdRdpPipeWireStream
{
  GObject parent;

GrdSessionRdp *session_rdp;

GSource *pipewire_source;
  struct pw_context *pipewire_context;
  struct pw_core *pipewire_core;

struct spa_hook pipewire_core_listener;

GMutex frame_mutex;
  GrdRdpFrame *pending_frame;

struct pw_stream *pipewire_stream;
  struct spa_hook pipewire_stream_listener;

uint32_t src_node_id;

struct spa_video_info_raw spa_format;
};

G_DEFINE_TYPE (GrdRdpPipeWireStream, grd_rdp_pipewire_stream,
               G_TYPE_OBJECT)

static gboolean
pipewire_loop_source_prepare (GSource *base,
                              int     *timeout)
{
  *timeout = -1;
  return FALSE;
}

static gboolean
pipewire_loop_source_dispatch (GSource     *source,
                               GSourceFunc  callback,
                               gpointer     user_data)
{
  GrdPipeWireSource *pipewire_source = (GrdPipeWireSource *) source;
  int result;

result = pw_loop_iterate (pipewire_source->pipewire_loop, 0);
  if (result < 0)
    g_warning ("pipewire_loop_iterate failed: %s", spa_strerror (result));

return TRUE;
}

static void
pipewire_loop_source_finalize (GSource *source)
{
  GrdPipeWireSource *pipewire_source = (GrdPipeWireSource *) source;

pw_loop_leave (pipewire_source->pipewire_loop);
  pw_loop_destroy (pipewire_source->pipewire_loop);
}

static GSourceFuncs pipewire_source_funcs =
{
  pipewire_loop_source_prepare,
  NULL,
  pipewire_loop_source_dispatch,
  pipewire_loop_source_finalize
};

static GrdPipeWireSource *
create_pipewire_source (void)
{
  GrdPipeWireSource *pipewire_source;

pipewire_source =
    (GrdPipeWireSource *) g_source_new (&pipewire_source_funcs,
                                        sizeof (GrdPipeWireSource));
  pipewire_source->pipewire_loop = pw_loop_new (NULL);
  if (!pipewire_source->pipewire_loop)
    {
      g_source_destroy ((GSource *) pipewire_source);
      return NULL;
    }

g_source_add_unix_fd (&pipewire_source->base,
                        pw_loop_get_fd (pipewire_source->pipewire_loop),
                        G_IO_IN | G_IO_ERR);

pw_loop_enter (pipewire_source->pipewire_loop);
  g_source_attach (&pipewire_source->base, NULL);

return pipewire_source;
}

static void
on_stream_state_changed (void                 *user_data,
                         enum pw_stream_state  old,
                         enum pw_stream_state  state,
                         const char           *error)
{
  g_debug ("PipeWire stream state changed from %s to %s",
           pw_stream_state_as_string (old),
           pw_stream_state_as_string (state));

switch (state)
    {
    case PW_STREAM_STATE_ERROR:
      g_warning ("PipeWire stream error: %s", error);
      break;
    case PW_STREAM_STATE_PAUSED:
    case PW_STREAM_STATE_STREAMING:
    case PW_STREAM_STATE_UNCONNECTED:
    case PW_STREAM_STATE_CONNECTING:
      break;
    }
}

static void
on_stream_param_changed (void                 *user_data,
                         uint32_t              id,
                         const struct spa_pod *format)
{
  GrdRdpPipeWireStream *stream = GRD_RDP_PIPEWIRE_STREAM (user_data);
  uint8_t params_buffer[1024];
  struct spa_pod_builder pod_builder;
  int width;
  int height;
  const struct spa_pod *params[3];

if (!format || id != SPA_PARAM_Format)
    return;

spa_format_video_raw_parse (format, &stream->spa_format);

pod_builder = SPA_POD_BUILDER_INIT (params_buffer, sizeof (params_buffer));

width = stream->spa_format.size.width;
  height = stream->spa_format.size.height;

grd_session_rdp_resize_framebuffer (stream->session_rdp, width, height);

params[0] = spa_pod_builder_add_object (
    &pod_builder,
    SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
    SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int (8, 1, 8),
    0);

params[1] = spa_pod_builder_add_object (
    &pod_builder,
    SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
    SPA_PARAM_META_type, SPA_POD_Id (SPA_META_Header),
    SPA_PARAM_META_size, SPA_POD_Int (sizeof (struct spa_meta_header)),
    0);

params[2] = spa_pod_builder_add_object (
    &pod_builder,
    SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
    SPA_PARAM_META_type, SPA_POD_Id (SPA_META_Cursor),
    SPA_PARAM_META_size, SPA_POD_CHOICE_RANGE_Int (CURSOR_META_SIZE (384, 384),
                                                   CURSOR_META_SIZE (1, 1),
                                                   CURSOR_META_SIZE (384, 384)),
    0);

pw_stream_update_params (stream->pipewire_stream,
                           params, G_N_ELEMENTS (params));
}

static int
do_render (struct spa_loop *loop,
           bool             async,
           uint32_t         seq,
           const void      *data,
           size_t           size,
           void            *user_data)
{
  GrdRdpPipeWireStream *stream = GRD_RDP_PIPEWIRE_STREAM (user_data);
  GrdRdpFrame *frame;

g_mutex_lock (&stream->frame_mutex);
  frame = g_steal_pointer (&stream->pending_frame);
  g_mutex_unlock (&stream->frame_mutex);

if (!frame)
    return 0;

if (frame->data)
    grd_session_rdp_take_buffer (stream->session_rdp, frame->data);

if (frame->pointer_bitmap)
    {
      grd_session_rdp_update_pointer (stream->session_rdp,
                                      frame->pointer_hotspot_x,
                                      frame->pointer_hotspot_y,
                                      frame->pointer_width,
                                      frame->pointer_height,
                                      frame->pointer_bitmap);
    }
  else if (frame->pointer_is_hidden)
    {
      grd_session_rdp_hide_pointer (stream->session_rdp);
    }

g_free (frame);

return 0;
}

static GrdRdpFrame *
process_buffer (GrdRdpPipeWireStream *stream,
                struct spa_buffer    *buffer)
{
  size_t size;
  uint8_t *map;
  void *src_data;
  struct spa_meta_cursor *spa_meta_cursor;
  g_autofree GrdRdpFrame *frame = NULL;

frame = g_new0 (GrdRdpFrame, 1);

if (buffer->datas[0].chunk->size == 0)
    {
      map = NULL;
      src_data = NULL;
    }
  else if (buffer->datas[0].type == SPA_DATA_MemFd)
    {
      size = buffer->datas[0].maxsize + buffer->datas[0].mapoffset;
      map = mmap (NULL, size, PROT_READ, MAP_PRIVATE, buffer->datas[0].fd, 0);
      if (map == MAP_FAILED)
        {
          g_warning ("Failed to mmap buffer: %s", g_strerror (errno));
          return NULL;
        }
      src_data = SPA_MEMBER (map, buffer->datas[0].mapoffset, uint8_t);
    }
  else if (buffer->datas[0].type == SPA_DATA_DmaBuf)
    {
      int fd;

fd = buffer->datas[0].fd;
      size = buffer->datas[0].maxsize + buffer->datas[0].mapoffset;

map = mmap (NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
      if (map == MAP_FAILED)
        {
          g_warning ("Failed to mmap DMA buffer: %s", g_strerror (errno));
          return NULL;
        }
      grd_sync_dma_buf (fd, DMA_BUF_SYNC_START);

src_data = SPA_MEMBER (map, buffer->datas[0].mapoffset, uint8_t);
    }
  else if (buffer->datas[0].type == SPA_DATA_MemPtr)
    {
      size = buffer->datas[0].maxsize + buffer->datas[0].mapoffset;
      map = NULL;
      src_data = buffer->datas[0].data;
    }
  else
    {
      return NULL;
    }

if (src_data)
    {
      int src_stride;
      int dst_stride;
      int height;
      int width;
      int y;

height = stream->spa_format.size.height;
      width = stream->spa_format.size.width;
      src_stride = buffer->datas[0].chunk->stride;
      dst_stride = grd_session_rdp_get_stride_for_width (stream->session_rdp,
                                                         width);

frame->data = g_malloc (height * dst_stride);
      for (y = 0; y < height; ++y)
        {
          memcpy (((uint8_t *) frame->data) + y * dst_stride,
                  ((uint8_t *) src_data) + y * src_stride,
                  width * 4);
        }
    }

if (map)
    {
      if (buffer->datas[0].type == SPA_DATA_DmaBuf)
        grd_sync_dma_buf (buffer->datas[0].fd, DMA_BUF_SYNC_END);
      munmap (map, size);
    }

spa_meta_cursor = spa_buffer_find_meta_data (buffer, SPA_META_Cursor,
                                               sizeof *spa_meta_cursor);
  if (spa_meta_cursor && spa_meta_cursor_is_valid (spa_meta_cursor))
    {
      struct spa_meta_bitmap *spa_meta_bitmap = NULL;
      GrdPixelFormat format;

if (spa_meta_cursor->bitmap_offset)
        {
          spa_meta_bitmap = SPA_MEMBER (spa_meta_cursor,
                                        spa_meta_cursor->bitmap_offset,
                                        struct spa_meta_bitmap);
        }

if (spa_meta_bitmap &&
          spa_meta_bitmap->size.width > 0 &&
          spa_meta_bitmap->size.height > 0 &&
          grd_spa_pixel_format_to_grd_pixel_format (spa_meta_bitmap->format,
                                                    &format))
        {
          uint8_t *buf;

buf = SPA_MEMBER (spa_meta_bitmap, spa_meta_bitmap->offset, uint8_t);
          frame->pointer_bitmap = g_memdup2 (buf, spa_meta_bitmap->size.height *
                                                  spa_meta_bitmap->stride);
          frame->pointer_hotspot_x = spa_meta_cursor->hotspot.x;
          frame->pointer_hotspot_y = spa_meta_cursor->hotspot.y;
          frame->pointer_width = spa_meta_bitmap->size.width;
          frame->pointer_height = spa_meta_bitmap->size.height;
        }
      else if (spa_meta_bitmap)
        {
          frame->pointer_is_hidden = TRUE;
        }
    }

return g_steal_pointer (&frame);
}

static void
on_stream_process (void *user_data)
{
  GrdRdpPipeWireStream *stream = GRD_RDP_PIPEWIRE_STREAM (user_data);
  GrdPipeWireSource *pipewire_source =
    (GrdPipeWireSource *) stream->pipewire_source;
  struct pw_buffer *next_buffer;
  struct pw_buffer *buffer = NULL;
  GrdRdpFrame *frame;

next_buffer = pw_stream_dequeue_buffer (stream->pipewire_stream);
  while (next_buffer)
    {
      buffer = next_buffer;
      next_buffer = pw_stream_dequeue_buffer (stream->pipewire_stream);

if (next_buffer)
        pw_stream_queue_buffer (stream->pipewire_stream, buffer);
    }
  if (!buffer)
    return;

frame = process_buffer (stream, buffer->buffer);

g_assert (frame);
  g_mutex_lock (&stream->frame_mutex);
  if (stream->pending_frame)
    {
      g_free (stream->pending_frame->data);
      g_free (stream->pending_frame->pointer_bitmap);
      g_clear_pointer (&stream->pending_frame, g_free);
    }
  stream->pending_frame = frame;
  g_mutex_unlock (&stream->frame_mutex);

pw_stream_queue_buffer (stream->pipewire_stream, buffer);

pw_loop_invoke (pipewire_source->pipewire_loop, do_render,
                  SPA_ID_INVALID, NULL, 0,
                  false, stream);
}

static const struct pw_stream_events stream_events = {
  PW_VERSION_STREAM_EVENTS,
  .state_changed = on_stream_state_changed,
  .param_changed = on_stream_param_changed,
  .process = on_stream_process,
};

static gboolean
connect_to_stream (GrdRdpPipeWireStream  *stream,
                   GError               **error)
{
  struct pw_stream *pipewire_stream;
  uint8_t params_buffer[1024];
  struct spa_pod_builder pod_builder;
  struct spa_rectangle min_rect;
  struct spa_rectangle max_rect;
  struct spa_fraction min_framerate;
  struct spa_fraction max_framerate;
  const struct spa_pod *params[2];
  int ret;

pipewire_stream = pw_stream_new (stream->pipewire_core,
                                   "grd-rdp-pipewire-stream",
                                   NULL);

min_rect = SPA_RECTANGLE (1, 1);
  max_rect = SPA_RECTANGLE (INT32_MAX, INT32_MAX);
  min_framerate = SPA_FRACTION (1, 1);
  max_framerate = SPA_FRACTION (30, 1);

pod_builder = SPA_POD_BUILDER_INIT (params_buffer, sizeof (params_buffer));
  params[0] = spa_pod_builder_add_object (
    &pod_builder,
    SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
    SPA_FORMAT_mediaType, SPA_POD_Id (SPA_MEDIA_TYPE_video),
    SPA_FORMAT_mediaSubtype, SPA_POD_Id (SPA_MEDIA_SUBTYPE_raw),
    SPA_FORMAT_VIDEO_format, SPA_POD_Id (SPA_VIDEO_FORMAT_BGRx),
    SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle (&min_rect,
                                                           &min_rect,
                                                           &max_rect),
    SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction (&SPA_FRACTION (0, 1)),
    SPA_FORMAT_VIDEO_maxFramerate, SPA_POD_CHOICE_RANGE_Fraction (&min_framerate,
                                                                  &min_framerate,
                                                                  &max_framerate),
    0);

stream->pipewire_stream = pipewire_stream;

pw_stream_add_listener (pipewire_stream,
                          &stream->pipewire_stream_listener,
                          &stream_events,
                          stream);

ret = pw_stream_connect (stream->pipewire_stream,
                           PW_DIRECTION_INPUT,
                           stream->src_node_id,
                           (PW_STREAM_FLAG_RT_PROCESS |
                            PW_STREAM_FLAG_AUTOCONNECT),
                           params, 1);
  if (ret < 0)
    {
      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (-ret),
                           strerror (-ret));
      return FALSE;
    }

return TRUE;
}

static void
on_core_error (void       *user_data,
               uint32_t    id,
               int         seq,
               int         res,
               const char *message)
{
  GrdRdpPipeWireStream *stream = GRD_RDP_PIPEWIRE_STREAM (user_data);

g_warning ("PipeWire core error: id:%u %s", id, message);

if (id == PW_ID_CORE && res == -EPIPE)
    g_signal_emit (stream, signals[CLOSED], 0);
}

static const struct pw_core_events core_events = {
  PW_VERSION_CORE_EVENTS,
  .error = on_core_error,
};

GrdRdpPipeWireStream *
grd_rdp_pipewire_stream_new (GrdSessionRdp  *session_rdp,
                             uint32_t        src_node_id,
                             GError        **error)
{
  g_autoptr (GrdRdpPipeWireStream) stream = NULL;
  GrdPipeWireSource *pipewire_source;

grd_maybe_initialize_pipewire ();

stream = g_object_new (GRD_TYPE_RDP_PIPEWIRE_STREAM, NULL);
  stream->session_rdp = session_rdp;
  stream->src_node_id = src_node_id;

pipewire_source = create_pipewire_source ();
  if (!pipewire_source)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                   "Failed to create PipeWire source");
      return NULL;
    }
  stream->pipewire_source = (GSource *) pipewire_source;

stream->pipewire_context = pw_context_new (pipewire_source->pipewire_loop,
                                             NULL, 0);
  if (!stream->pipewire_context)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                   "Failed to create PipeWire context");
      return NULL;
    }

stream->pipewire_core = pw_context_connect (stream->pipewire_context, NULL, 0);
  if (!stream->pipewire_core)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                   "Failed to connect PipeWire context");
      return NULL;
    }

pw_core_add_listener (stream->pipewire_core,
                        &stream->pipewire_core_listener,
                        &core_events,
                        stream);

if (!connect_to_stream (stream, error))
    return NULL;

return g_steal_pointer (&stream);
}

static void
grd_rdp_pipewire_stream_finalize (GObject *object)
{
  GrdRdpPipeWireStream *stream = GRD_RDP_PIPEWIRE_STREAM (object);

/*
   * We can't clear stream->pipewire_stream before destroying it, as the data
   * thread in PipeWire might access the variable during destruction.
   */
  if (stream->pipewire_stream)
    pw_stream_destroy (stream->pipewire_stream);

g_clear_pointer (&stream->pipewire_core, pw_core_disconnect);
  g_clear_pointer (&stream->pipewire_context, pw_context_destroy);
  if (stream->pipewire_source)
    {
      g_source_destroy (stream->pipewire_source);
      g_clear_pointer (&stream->pipewire_source, g_source_unref);
    }

G_OBJECT_CLASS (grd_rdp_pipewire_stream_parent_class)->finalize (object);
}

static void
grd_rdp_pipewire_stream_init (GrdRdpPipeWireStream *stream)
{
  g_mutex_init (&stream->frame_mutex);
}

static void
grd_rdp_pipewire_stream_class_init (GrdRdpPipeWireStreamClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->finalize = grd_rdp_pipewire_stream_finalize;

signals[CLOSED] = g_signal_new ("closed",
                                  G_TYPE_FROM_CLASS (klass),
                                  G_SIGNAL_RUN_LAST,
                                  0,
                                  NULL, NULL, NULL,
                                  G_TYPE_NONE, 0);
}
07070100000028000081A40000000000000000000000016141EE100000057E000000000000000000000000000000000000003800000000gnome-remote-desktop-40.2/src/grd-rdp-pipewire-stream.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_RDP_PIPEWIRE_STREAM_H
#define GRD_RDP_PIPEWIRE_STREAM_H

#include <glib-object.h>
#include <stdint.h>

#include "grd-session-rdp.h"

#define GRD_TYPE_RDP_PIPEWIRE_STREAM grd_rdp_pipewire_stream_get_type ()
G_DECLARE_FINAL_TYPE (GrdRdpPipeWireStream, grd_rdp_pipewire_stream,
                      GRD, RDP_PIPEWIRE_STREAM,
                      GObject)

GrdRdpPipeWireStream *grd_rdp_pipewire_stream_new (GrdSessionRdp  *session_rdp,
                                                   uint32_t        src_node_id,
                                                   GError        **error);

#endif /* GRD_RDP_PIPEWIRE_STREAM_H */
07070100000029000081A40000000000000000000000016141EE1000000B7B000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/src/grd-rdp-sam.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-rdp-sam.h"

#include <fcntl.h>
#include <gio/gio.h>
#include <glib/gstdio.h>
#include <stdint.h>
#include <sys/stat.h>
#include <winpr/ntlm.h>

static char *
create_sam_string (const char *username,
                   const char *password)
{
  uint32_t username_length;
  uint32_t password_length;
  uint32_t i;
  char *sam_string;
  uint8_t nt_hash[16];

username_length = strlen (username);
  password_length = strlen (password);

sam_string = g_malloc0 ((username_length + 3 + 32 + 3 + 1 + 1) * sizeof (char));

NTOWFv1A ((LPSTR) password, password_length, nt_hash);

sprintf (sam_string, "%s:::", username);
  for (i = 0; i < 16; ++i)
    sprintf (sam_string + strlen (sam_string), "%02" PRIx8 "", nt_hash[i]);
  sprintf (sam_string + strlen (sam_string), ":::\n");

return sam_string;
}

GrdRdpSAMFile *
grd_rdp_sam_create_sam_file (const char *username,
                             const char *password)
{
  const char *grd_path = "/gnome-remote-desktop";
  const char *template = "/rdp-sam-XXXXXX";
  const char *path;
  char *filename;
  char *sam_string;
  int fd_flags;
  GrdRdpSAMFile *rdp_sam_file;
  FILE *sam_file;

rdp_sam_file = g_malloc0 (sizeof (GrdRdpSAMFile));

path = getenv ("XDG_RUNTIME_DIR");
  filename = g_malloc0 (strlen (path) + strlen (grd_path) +
                        strlen (template) + 1);
  strcpy (filename, path);
  strcat (filename, grd_path);
  if (g_access (filename, F_OK))
    mkdir (filename, 0700);

strcat (filename, template);

rdp_sam_file->fd = mkstemp (filename);
  rdp_sam_file->filename = filename;

fd_flags = fcntl (rdp_sam_file->fd, F_GETFD);
  fcntl (rdp_sam_file->fd, F_SETFD, fd_flags | FD_CLOEXEC);

sam_string = create_sam_string (username, password);

sam_file = fdopen (rdp_sam_file->fd, "w+");
  fputs (sam_string, sam_file);
  fclose (sam_file);

g_free (sam_string);

return rdp_sam_file;
}

void
grd_rdp_sam_maybe_close_and_free_sam_file (GrdRdpSAMFile *rdp_sam_file)
{
  if (rdp_sam_file->fd >= 0)
    {
      unlink (rdp_sam_file->filename);
      close (rdp_sam_file->fd);
    }

g_free (rdp_sam_file->filename);
  g_free (rdp_sam_file);
}
0707010000002A000081A40000000000000000000000016141EE1000000469000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/src/grd-rdp-sam.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_RDP_SAM_H
#define GRD_RDP_SAM_H

#include "grd-types.h"

struct _GrdRdpSAMFile
{
  int fd;
  char *filename;
};

GrdRdpSAMFile *grd_rdp_sam_create_sam_file (const char *username,
                                            const char *password);

void grd_rdp_sam_maybe_close_and_free_sam_file (GrdRdpSAMFile *rdp_sam_file);

#endif /* GRD_RDP_SAM_H */
0707010000002B000081A40000000000000000000000016141EE10000019B4000000000000000000000000000000000000002F00000000gnome-remote-desktop-40.2/src/grd-rdp-server.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-rdp-server.h"

#include <freerdp/channels/channels.h>
#include <freerdp/freerdp.h>
#include <gio/gio.h>
#include <winpr/ssl.h>

#include "grd-context.h"
#include "grd-session-rdp.h"

enum
{
  PROP_0,

PROP_CONTEXT,
};

struct _GrdRdpServer
{
  GSocketService parent;

GList *sessions;

GList *stopped_sessions;
  guint idle_task;

GrdContext *context;
};

G_DEFINE_TYPE (GrdRdpServer, grd_rdp_server, G_TYPE_SOCKET_SERVICE);

GrdContext *
grd_rdp_server_get_context (GrdRdpServer *rdp_server)
{
  return rdp_server->context;
}

GrdRdpServer *
grd_rdp_server_new (GrdContext *context)
{
  GrdRdpServer *rdp_server;

rdp_server = g_object_new (GRD_TYPE_RDP_SERVER,
                             "context", context,
                             NULL);

return rdp_server;
}

static void
grd_rdp_server_cleanup_stopped_sessions (GrdRdpServer *rdp_server)
{
  g_list_free_full (rdp_server->stopped_sessions, g_object_unref);
  rdp_server->stopped_sessions = NULL;
}

static gboolean
cleanup_stopped_sessions_idle (GrdRdpServer *rdp_server)
{
  grd_rdp_server_cleanup_stopped_sessions (rdp_server);
  rdp_server->idle_task = 0;

return G_SOURCE_REMOVE;
}

static void
on_session_stopped (GrdSession   *session,
                    GrdRdpServer *rdp_server)
{
  g_debug ("RDP session stopped");

rdp_server->stopped_sessions = g_list_append (rdp_server->stopped_sessions,
                                                session);
  rdp_server->sessions = g_list_remove (rdp_server->sessions, session);
  if (!rdp_server->idle_task)
    {
      rdp_server->idle_task =
        g_idle_add ((GSourceFunc) cleanup_stopped_sessions_idle,
                    rdp_server);
    }
}

static gboolean
on_incoming (GSocketService    *service,
             GSocketConnection *connection)
{
  GrdRdpServer *rdp_server = GRD_RDP_SERVER (service);
  GrdSessionRdp *session_rdp;

g_debug ("New incoming RDP connection");

if (!(session_rdp = grd_session_rdp_new (rdp_server, connection)))
    return TRUE;

rdp_server->sessions = g_list_append (rdp_server->sessions, session_rdp);
  grd_context_add_session (rdp_server->context, GRD_SESSION (session_rdp));

g_signal_connect (session_rdp, "stopped",
                    G_CALLBACK (on_session_stopped),
                    rdp_server);

return TRUE;
}

gboolean
grd_rdp_server_start (GrdRdpServer  *rdp_server,
                      GError       **error)
{
  GrdSettings *settings = grd_context_get_settings (rdp_server->context);

if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (rdp_server),
                                        grd_settings_get_rdp_port (settings),
                                        NULL,
                                        error))
    return FALSE;

g_signal_connect (rdp_server, "incoming", G_CALLBACK (on_incoming), NULL);

return TRUE;
}

static void
stop_and_unref_session (GrdSession *session)
{
  grd_session_stop (session);
  g_object_unref (session);
}

static void
grd_rdp_server_set_property (GObject      *object,
                             guint         prop_id,
                             const GValue *value,
                             GParamSpec   *pspec)
{
  GrdRdpServer *rdp_server = GRD_RDP_SERVER (object);

switch (prop_id)
    {
    case PROP_CONTEXT:
      rdp_server->context = g_value_get_object (value);
      break;

default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
grd_rdp_server_get_property (GObject    *object,
                             guint       prop_id,
                             GValue     *value,
                             GParamSpec *pspec)
{
  GrdRdpServer *rdp_server = GRD_RDP_SERVER (object);

switch (prop_id)
    {
    case PROP_CONTEXT:
      g_value_set_object (value, rdp_server->context);

default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
grd_rdp_server_dispose (GObject *object)
{
  GrdRdpServer *rdp_server = GRD_RDP_SERVER (object);

if (rdp_server->idle_task)
    {
      g_source_remove (rdp_server->idle_task);
      rdp_server->idle_task = 0;
    }

if (rdp_server->stopped_sessions)
    {
      grd_rdp_server_cleanup_stopped_sessions (rdp_server);
    }
  if (rdp_server->sessions)
    {
      g_list_free_full (rdp_server->sessions,
                        (GDestroyNotify) stop_and_unref_session);
      rdp_server->sessions = NULL;
    }

G_OBJECT_CLASS (grd_rdp_server_parent_class)->dispose (object);
}

static void
grd_rdp_server_constructed (GObject *object)
{
  G_OBJECT_CLASS (grd_rdp_server_parent_class)->constructed (object);
}

static void
grd_rdp_server_init (GrdRdpServer *rdp_server)
{
  winpr_InitializeSSL (WINPR_SSL_INIT_DEFAULT);
  WTSRegisterWtsApiFunctionTable (FreeRDP_InitWtsApi ());
}

static void
grd_rdp_server_class_init (GrdRdpServerClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->set_property = grd_rdp_server_set_property;
  object_class->get_property = grd_rdp_server_get_property;
  object_class->dispose = grd_rdp_server_dispose;
  object_class->constructed = grd_rdp_server_constructed;

g_object_class_install_property (object_class,
                                   PROP_CONTEXT,
                                   g_param_spec_object ("context",
                                                        "GrdContext",
                                                        "The GrdContext instance",
                                                        GRD_TYPE_CONTEXT,
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT_ONLY |
                                                        G_PARAM_STATIC_STRINGS));
}
0707010000002C000081A40000000000000000000000016141EE1000000554000000000000000000000000000000000000002F00000000gnome-remote-desktop-40.2/src/grd-rdp-server.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_RDP_SERVER_H
#define GRD_RDP_SERVER_H

#include <gio/gio.h>
#include <glib-object.h>

#include "grd-types.h"

#define GRD_TYPE_RDP_SERVER (grd_rdp_server_get_type ())
G_DECLARE_FINAL_TYPE (GrdRdpServer,
                      grd_rdp_server,
                      GRD, RDP_SERVER,
                      GSocketService);

GrdContext *grd_rdp_server_get_context (GrdRdpServer *rdp_server);

gboolean grd_rdp_server_start (GrdRdpServer  *rdp_server,
                               GError       **error);

GrdRdpServer *grd_rdp_server_new (GrdContext *context);

#endif /* GRD_RDP_SERVER_H */
0707010000002D000081A40000000000000000000000016141EE100000F13E000000000000000000000000000000000000003000000000gnome-remote-desktop-40.2/src/grd-session-rdp.c/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "config.h"

#include "grd-session-rdp.h"

#include <freerdp/channels/wtsvc.h>
#include <freerdp/freerdp.h>
#include <freerdp/peer.h>
#include <gio/gio.h>
#include <linux/input-event-codes.h>
#include <xkbcommon/xkbcommon.h>

#include "grd-clipboard-rdp.h"
#include "grd-context.h"
#include "grd-damage-utils.h"
#include "grd-rdp-event-queue.h"
#include "grd-rdp-pipewire-stream.h"
#include "grd-rdp-sam.h"
#include "grd-rdp-server.h"
#include "grd-settings.h"
#include "grd-stream.h"

#define DISCRETE_SCROLL_STEP 10.0

typedef enum _RdpPeerFlag
{
  RDP_PEER_ACTIVATED      = 1 << 0,
  RDP_PEER_OUTPUT_ENABLED = 1 << 1,
} RdpPeerFlag;

typedef enum _PointerType
{
  POINTER_TYPE_DEFAULT = 0,
  POINTER_TYPE_HIDDEN  = 1 << 0,
  POINTER_TYPE_NORMAL  = 1 << 1,
} PointerType;

typedef enum _PauseKeyState
{
  PAUSE_KEY_STATE_NONE,
  PAUSE_KEY_STATE_CTRL_DOWN,
  PAUSE_KEY_STATE_NUMLOCK_DOWN,
  PAUSE_KEY_STATE_CTRL_UP,
} PauseKeyState;

typedef struct _Pointer
{
  uint8_t *bitmap;
  uint16_t hotspot_x;
  uint16_t hotspot_y;
  uint16_t width;
  uint16_t height;

uint16_t cache_index;
  int64_t last_used;
} Pointer;

struct _GrdSessionRdp
{
  GrdSession parent;

GSocketConnection *connection;
  freerdp_peer *peer;

GThread *socket_thread;
  HANDLE start_event;
  HANDLE stop_event;

uint8_t *last_frame;
  Pointer *last_pointer;
  GHashTable *pointer_cache;
  PointerType pointer_type;

GHashTable *pressed_keys;
  GHashTable *pressed_unicode_keys;
  PauseKeyState pause_key_state;

GrdRdpEventQueue *rdp_event_queue;

GThreadPool *thread_pool;
  GCond pending_jobs_cond;
  GMutex pending_jobs_mutex;

unsigned int close_session_idle_id;

GrdRdpPipeWireStream *pipewire_stream;
};

typedef struct _NSCThreadPoolContext
{
  uint32_t pending_job_count;
  GCond *pending_jobs_cond;
  GMutex *pending_jobs_mutex;

uint32_t src_stride;
  uint8_t *src_data;
  rdpSettings *rdp_settings;
} NSCThreadPoolContext;

typedef struct _NSCEncodeContext
{
  cairo_rectangle_int_t cairo_rect;
  wStream *stream;
} NSCEncodeContext;

typedef struct _RawThreadPoolContext
{
  uint32_t pending_job_count;
  GCond *pending_jobs_cond;
  GMutex *pending_jobs_mutex;

uint16_t planar_flags;
  uint32_t src_stride;
  uint8_t *src_data;
} RawThreadPoolContext;

typedef struct _RdpPeerContext
{
  rdpContext rdp_context;

GrdSessionRdp *session_rdp;
  GrdRdpSAMFile *sam_file;

GMutex flags_mutex;
  RdpPeerFlag flags;
  uint32_t frame_id;

RFX_CONTEXT *rfx_context;
  wStream *encode_stream;

NSCThreadPoolContext nsc_thread_pool_context;
  RawThreadPoolContext raw_thread_pool_context;

uint16_t planar_flags;

/* Virtual Channel Manager */
  HANDLE vcm;

GrdClipboardRdp *clipboard_rdp;
} RdpPeerContext;

G_DEFINE_TYPE (GrdSessionRdp, grd_session_rdp, GRD_TYPE_SESSION);

static gboolean
close_session_idle (gpointer user_data);

static void
rdp_peer_refresh_region (freerdp_peer   *peer,
                         cairo_region_t *region,
                         uint8_t        *data);

static gboolean
are_pointer_bitmaps_equal (gconstpointer a,
                           gconstpointer b);

static gboolean
is_rdp_peer_flag_set (RdpPeerContext *rdp_peer_context,
                      RdpPeerFlag     flag)
{
  gboolean state;

g_mutex_lock (&rdp_peer_context->flags_mutex);
  state = rdp_peer_context->flags & flag;
  g_mutex_unlock (&rdp_peer_context->flags_mutex);

return state;
}

static void
set_rdp_peer_flag (RdpPeerContext *rdp_peer_context,
                   RdpPeerFlag     flag)
{
  g_mutex_lock (&rdp_peer_context->flags_mutex);
  rdp_peer_context->flags |= flag;
  g_mutex_unlock (&rdp_peer_context->flags_mutex);
}

static void
unset_rdp_peer_flag (RdpPeerContext *rdp_peer_context,
                     RdpPeerFlag     flag)
{
  g_mutex_lock (&rdp_peer_context->flags_mutex);
  rdp_peer_context->flags &= ~flag;
  g_mutex_unlock (&rdp_peer_context->flags_mutex);
}

void
grd_session_rdp_resize_framebuffer (GrdSessionRdp *session_rdp,
                                    uint32_t       width,
                                    uint32_t       height)
{
  freerdp_peer *peer = session_rdp->peer;
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  rdpSettings *rdp_settings = peer->settings;

if (rdp_settings->DesktopWidth == width &&
      rdp_settings->DesktopHeight == height)
    return;

rdp_settings->DesktopWidth = width;
  rdp_settings->DesktopHeight = height;
  peer->update->DesktopResize (peer->context);

g_clear_pointer (&session_rdp->last_frame, g_free);

rfx_context_reset (rdp_peer_context->rfx_context,
                     rdp_settings->DesktopWidth,
                     rdp_settings->DesktopHeight);
}

static int
grd_session_rdp_get_framebuffer_stride (GrdSessionRdp *session_rdp)
{
  rdpSettings *rdp_settings = session_rdp->peer->settings;

return grd_session_rdp_get_stride_for_width (session_rdp,
                                               rdp_settings->DesktopWidth);
}

void
grd_session_rdp_take_buffer (GrdSessionRdp *session_rdp,
                             void          *data)
{
  freerdp_peer *peer = session_rdp->peer;
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  rdpSettings *rdp_settings = peer->settings;
  uint32_t stride = grd_session_rdp_get_framebuffer_stride (session_rdp);
  cairo_region_t *region;

if (is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_ACTIVATED) &&
      is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_OUTPUT_ENABLED))
    {
      region = grd_get_damage_region ((uint8_t *) data,
                                      session_rdp->last_frame,
                                      rdp_settings->DesktopWidth,
                                      rdp_settings->DesktopHeight,
                                      64, 64,
                                      stride, 4);
      if (!cairo_region_is_empty (region))
        rdp_peer_refresh_region (peer, region, (uint8_t *) data);

g_clear_pointer (&session_rdp->last_frame, g_free);
      session_rdp->last_frame = g_steal_pointer (&data);

cairo_region_destroy (region);
    }

g_free (data);
}

static gboolean
is_mouse_pointer_hidden (uint32_t  width,
                         uint32_t  height,
                         uint8_t  *data)
{
  uint8_t *src_data;
  uint32_t i;

for (i = 0, src_data = data; i < height * width; ++i, ++src_data)
    {
      src_data += 3;
      if (*src_data)
        return FALSE;
    }

return TRUE;
}

static gboolean
find_equal_pointer_bitmap (gpointer key,
                           gpointer value,
                           gpointer user_data)
{
  return are_pointer_bitmaps_equal (value, user_data);
}

void
grd_session_rdp_update_pointer (GrdSessionRdp *session_rdp,
                                uint16_t       hotspot_x,
                                uint16_t       hotspot_y,
                                uint16_t       width,
                                uint16_t       height,
                                uint8_t       *data)
{
  freerdp_peer *peer = session_rdp->peer;
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  rdpSettings *rdp_settings = peer->settings;
  rdpUpdate *rdp_update = peer->update;
  POINTER_SYSTEM_UPDATE pointer_system = {0};
  POINTER_NEW_UPDATE pointer_new = {0};
  POINTER_LARGE_UPDATE pointer_large = {0};
  POINTER_CACHED_UPDATE pointer_cached = {0};
  POINTER_COLOR_UPDATE *pointer_color;
  cairo_rectangle_int_t cairo_rect;
  Pointer *new_pointer;
  void *key, *value;
  uint32_t stride;
  uint32_t xor_mask_length;
  uint8_t *xor_mask;
  uint8_t *src_data, *dst_data;
  uint8_t r, g, b, a;
  uint32_t x, y;

if (!is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_ACTIVATED))
    {
      g_free (data);
      return;
    }

if (is_mouse_pointer_hidden (width, height, data))
    {
      if (session_rdp->pointer_type != POINTER_TYPE_HIDDEN)
        {
          session_rdp->last_pointer = NULL;
          session_rdp->pointer_type = POINTER_TYPE_HIDDEN;
          pointer_system.type = SYSPTR_NULL;

rdp_update->pointer->PointerSystem (peer->context, &pointer_system);
        }

g_free (data);
      return;
    }

/* RDP only handles pointer bitmaps up to 384x384 pixels */
  if (width > 384 || height > 384)
    {
      if (session_rdp->pointer_type != POINTER_TYPE_DEFAULT)
        {
          session_rdp->last_pointer = NULL;
          session_rdp->pointer_type = POINTER_TYPE_DEFAULT;
          pointer_system.type = SYSPTR_DEFAULT;

rdp_update->pointer->PointerSystem (peer->context, &pointer_system);
        }

g_free (data);
      return;
    }

session_rdp->pointer_type = POINTER_TYPE_NORMAL;

stride = width * 4;
  if (session_rdp->last_pointer &&
      session_rdp->last_pointer->hotspot_x == hotspot_x &&
      session_rdp->last_pointer->hotspot_y == hotspot_y &&
      session_rdp->last_pointer->width == width &&
      session_rdp->last_pointer->height == height)
    {
      cairo_rect.x = cairo_rect.y = 0;
      cairo_rect.width = width;
      cairo_rect.height = height;

if (!grd_is_tile_dirty (&cairo_rect,
                              data,
                              session_rdp->last_pointer->bitmap,
                              stride, 4))
        {
          session_rdp->last_pointer->last_used = g_get_monotonic_time ();
          g_free (data);
          return;
        }
    }

new_pointer = g_malloc0 (sizeof (Pointer));
  new_pointer->bitmap = data;
  new_pointer->hotspot_x = hotspot_x;
  new_pointer->hotspot_y = hotspot_y;
  new_pointer->width = width;
  new_pointer->height = height;
  if ((value = g_hash_table_find (session_rdp->pointer_cache,
                                  find_equal_pointer_bitmap,
                                  new_pointer)))
    {
      session_rdp->last_pointer = (Pointer *) value;
      session_rdp->last_pointer->last_used = g_get_monotonic_time ();
      pointer_cached.cacheIndex = session_rdp->last_pointer->cache_index;

rdp_update->pointer->PointerCached (peer->context, &pointer_cached);

g_free (new_pointer);
      g_free (data);

return;
    }

xor_mask_length = height * stride * sizeof (uint8_t);
  xor_mask = g_malloc0 (xor_mask_length);

for (y = 0; y < height; ++y)
    {
      src_data = &data[stride * (height - 1 - y)];
      dst_data = &xor_mask[stride * y];

for (x = 0; x < width; ++x)
        {
          r = *src_data++;
          g = *src_data++;
          b = *src_data++;
          a = *src_data++;

*dst_data++ = b;
          *dst_data++ = g;
          *dst_data++ = r;
          *dst_data++ = a;
        }
    }

new_pointer->cache_index = g_hash_table_size (session_rdp->pointer_cache);
  if (g_hash_table_size (session_rdp->pointer_cache) >= rdp_settings->PointerCacheSize)
    {
      /* Least recently used pointer */
      Pointer *lru_pointer = NULL;
      GHashTableIter iter;

g_hash_table_iter_init (&iter, session_rdp->pointer_cache);
      while (g_hash_table_iter_next (&iter, &key, &value))
        {
          if (!lru_pointer || lru_pointer->last_used > ((Pointer *) key)->last_used)
            lru_pointer = (Pointer *) key;
        }

g_hash_table_steal (session_rdp->pointer_cache, lru_pointer);
      new_pointer->cache_index = lru_pointer->cache_index;

g_free (lru_pointer->bitmap);
      g_free (lru_pointer);
    }

new_pointer->last_used = g_get_monotonic_time ();

if (width <= 96 && height <= 96)
    {
      pointer_new.xorBpp = 32;
      pointer_color = &pointer_new.colorPtrAttr;
      pointer_color->cacheIndex = new_pointer->cache_index;
      /* xPos and yPos actually represent the hotspot coordinates of the pointer
       * instead of the actual pointer position.
       * FreeRDP just uses a confusing naming convention here.
       * See also 2.2.9.1.1.4.4 Color Pointer Update (TS_COLORPOINTERATTRIBUTE)
       * for reference
       */
      pointer_color->xPos = hotspot_x;
      pointer_color->yPos = hotspot_y;
      pointer_color->width = width;
      pointer_color->height = height;
      pointer_color->lengthAndMask = 0;
      pointer_color->lengthXorMask = xor_mask_length;
      pointer_color->andMaskData = NULL;
      pointer_color->xorMaskData = xor_mask;
      pointer_cached.cacheIndex = pointer_color->cacheIndex;

rdp_update->pointer->PointerNew (peer->context, &pointer_new);
    }
  else
    {
      pointer_large.xorBpp = 32;
      pointer_large.cacheIndex = new_pointer->cache_index;
      pointer_large.hotSpotX = hotspot_x;
      pointer_large.hotSpotY = hotspot_y;
      pointer_large.width = width;
      pointer_large.height = height;
      pointer_large.lengthAndMask = 0;
      pointer_large.lengthXorMask = xor_mask_length;
      pointer_large.andMaskData = NULL;
      pointer_large.xorMaskData = xor_mask;
      pointer_cached.cacheIndex = pointer_large.cacheIndex;

rdp_update->pointer->PointerLarge (peer->context, &pointer_large);
    }

rdp_update->pointer->PointerCached (peer->context, &pointer_cached);

g_hash_table_add (session_rdp->pointer_cache, new_pointer);
  session_rdp->last_pointer = new_pointer;

g_free (xor_mask);
}

void
grd_session_rdp_hide_pointer (GrdSessionRdp *session_rdp)
{
  freerdp_peer *peer = session_rdp->peer;
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  rdpUpdate *rdp_update = peer->update;
  POINTER_SYSTEM_UPDATE pointer_system = {0};

if (!is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_ACTIVATED))
    return;

if (session_rdp->pointer_type == POINTER_TYPE_HIDDEN)
    return;

session_rdp->last_pointer = NULL;
  session_rdp->pointer_type = POINTER_TYPE_HIDDEN;
  pointer_system.type = SYSPTR_NULL;

rdp_update->pointer->PointerSystem (peer->context, &pointer_system);
}

static void
maybe_queue_close_session_idle (GrdSessionRdp *session_rdp)
{
  if (session_rdp->close_session_idle_id)
    return;

session_rdp->close_session_idle_id =
    g_idle_add (close_session_idle, session_rdp);

SetEvent (session_rdp->stop_event);
}

static void
handle_client_gone (GrdSessionRdp *session_rdp)
{
  freerdp_peer *peer = session_rdp->peer;
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;

g_debug ("RDP client gone");

unset_rdp_peer_flag (rdp_peer_context, RDP_PEER_ACTIVATED);
  maybe_queue_close_session_idle (session_rdp);
}

static gboolean
is_view_only (GrdSessionRdp *session_rdp)
{
  GrdContext *context = grd_session_get_context (GRD_SESSION (session_rdp));
  GrdSettings *settings = grd_context_get_settings (context);

return grd_settings_get_rdp_view_only (settings);
}

static void
rdp_peer_refresh_rfx (freerdp_peer   *peer,
                      cairo_region_t *region,
                      uint8_t        *data)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  rdpSettings *rdp_settings = peer->settings;
  rdpUpdate *rdp_update = peer->update;
  uint32_t desktop_width = rdp_settings->DesktopWidth;
  uint32_t desktop_height = rdp_settings->DesktopHeight;
  uint32_t src_stride = grd_session_rdp_get_framebuffer_stride (session_rdp);
  SURFACE_BITS_COMMAND cmd = {0};
  cairo_rectangle_int_t cairo_rect;
  RFX_RECT *rfx_rects, *rfx_rect;
  int n_rects;
  RFX_MESSAGE *rfx_messages;
#ifdef HAVE_FREERDP_2_3
  size_t n_messages;
  BOOL first, last;
  size_t i;
#else
  int n_messages;
  BOOL first, last;
  int i;
#endif /* HAVE_FREERDP_2_3 */

n_rects = cairo_region_num_rectangles (region);
  rfx_rects = g_malloc0 (n_rects * sizeof (RFX_RECT));
  for (i = 0; i < n_rects; ++i)
    {
      cairo_region_get_rectangle (region, i, &cairo_rect);

rfx_rect = &rfx_rects[i];
      rfx_rect->x = cairo_rect.x;
      rfx_rect->y = cairo_rect.y;
      rfx_rect->width = cairo_rect.width;
      rfx_rect->height = cairo_rect.height;
    }

#ifdef HAVE_FREERDP_2_3
  rfx_messages = rfx_encode_messages_ex (rdp_peer_context->rfx_context,
                                         rfx_rects,
                                         n_rects,
                                         data,
                                         desktop_width,
                                         desktop_height,
                                         src_stride,
                                         &n_messages,
                                         rdp_settings->MultifragMaxRequestSize);
#else
  rfx_messages = rfx_encode_messages (rdp_peer_context->rfx_context,
                                      rfx_rects,
                                      n_rects,
                                      data,
                                      desktop_width,
                                      desktop_height,
                                      src_stride,
                                      &n_messages,
                                      rdp_settings->MultifragMaxRequestSize);
#endif /* HAVE_FREERDP_2_3 */

cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS;
  cmd.bmp.codecID = rdp_settings->RemoteFxCodecId;
  cmd.destLeft = 0;
  cmd.destTop = 0;
  cmd.destRight = cmd.destLeft + desktop_width;
  cmd.destBottom = cmd.destTop + desktop_height;
  cmd.bmp.bpp = 32;
  cmd.bmp.flags = 0;
  cmd.bmp.width = desktop_width;
  cmd.bmp.height = desktop_height;

for (i = 0; i < n_messages; ++i)
    {
      Stream_SetPosition (rdp_peer_context->encode_stream, 0);

if (!rfx_write_message (rdp_peer_context->rfx_context,
                              rdp_peer_context->encode_stream,
                              &rfx_messages[i]))
        {
          g_warning ("rfx_write_message failed");

for (; i < n_messages; ++i)
            rfx_message_free (rdp_peer_context->rfx_context, &rfx_messages[i]);

break;
        }

rfx_message_free (rdp_peer_context->rfx_context, &rfx_messages[i]);
      cmd.bmp.bitmapDataLength = Stream_GetPosition (rdp_peer_context->encode_stream);
      cmd.bmp.bitmapData = Stream_Buffer (rdp_peer_context->encode_stream);
      first = i == 0 ? TRUE : FALSE;
      last = i + 1 == n_messages ? TRUE : FALSE;

if (!rdp_settings->SurfaceFrameMarkerEnabled)
        rdp_update->SurfaceBits (rdp_update->context, &cmd);
      else
        rdp_update->SurfaceFrameBits (rdp_update->context, &cmd, first, last,
                                      rdp_peer_context->frame_id);
    }

g_free (rfx_messages);
  g_free (rfx_rects);
}

static void
rdp_peer_encode_nsc_rect (gpointer data,
                          gpointer user_data)
{
  NSCThreadPoolContext *thread_pool_context = (NSCThreadPoolContext *) user_data;
  NSCEncodeContext *encode_context = (NSCEncodeContext *) data;
  cairo_rectangle_int_t *cairo_rect = &encode_context->cairo_rect;
  uint32_t src_stride = thread_pool_context->src_stride;
  uint8_t *src_data = thread_pool_context->src_data;
  rdpSettings *rdp_settings = thread_pool_context->rdp_settings;
  NSC_CONTEXT *nsc_context;
  uint8_t *src_data_at_pos;

nsc_context = nsc_context_new ();
  nsc_context_set_parameters (nsc_context,
                              NSC_COLOR_LOSS_LEVEL,
                              rdp_settings->NSCodecColorLossLevel);
  nsc_context_set_parameters (nsc_context,
                              NSC_ALLOW_SUBSAMPLING,
                              rdp_settings->NSCodecAllowSubsampling);
  nsc_context_set_parameters (nsc_context,
                              NSC_DYNAMIC_COLOR_FIDELITY,
                              rdp_settings->NSCodecAllowDynamicColorFidelity);
  nsc_context_set_parameters (nsc_context,
                              NSC_COLOR_FORMAT,
                              PIXEL_FORMAT_BGRX32);
  nsc_context_reset (nsc_context,
                     cairo_rect->width,
                     cairo_rect->height);

encode_context->stream = Stream_New (NULL, 64 * 64 * 4);

src_data_at_pos = &src_data[cairo_rect->y * src_stride + cairo_rect->x * 4];
  Stream_SetPosition (encode_context->stream, 0);
  nsc_compose_message (nsc_context,
                       encode_context->stream,
                       src_data_at_pos,
                       cairo_rect->width,
                       cairo_rect->height,
                       src_stride);

nsc_context_free (nsc_context);

g_mutex_lock (thread_pool_context->pending_jobs_mutex);
  --thread_pool_context->pending_job_count;
  g_cond_signal (thread_pool_context->pending_jobs_cond);
  g_mutex_unlock (thread_pool_context->pending_jobs_mutex);
}

static void
rdp_peer_refresh_nsc (freerdp_peer   *peer,
                      cairo_region_t *region,
                      uint8_t        *data)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  rdpSettings *rdp_settings = peer->settings;
  rdpUpdate *rdp_update = peer->update;
  uint32_t src_stride = grd_session_rdp_get_framebuffer_stride (session_rdp);
  NSCThreadPoolContext *thread_pool_context =
    &rdp_peer_context->nsc_thread_pool_context;
  g_autoptr (GError) error = NULL;
  cairo_rectangle_int_t *cairo_rect;
  int n_rects;
  NSCEncodeContext *encode_contexts;
  NSCEncodeContext *encode_context;
  SURFACE_BITS_COMMAND cmd = {0};
  BOOL first, last;
  int i;

n_rects = cairo_region_num_rectangles (region);
  encode_contexts = g_malloc0 (n_rects * sizeof (NSCEncodeContext));

thread_pool_context->pending_job_count = 0;
  thread_pool_context->pending_jobs_cond = &session_rdp->pending_jobs_cond;
  thread_pool_context->pending_jobs_mutex = &session_rdp->pending_jobs_mutex;
  thread_pool_context->src_stride = src_stride;
  thread_pool_context->src_data = data;
  thread_pool_context->rdp_settings = rdp_settings;

if (!session_rdp->thread_pool)
    session_rdp->thread_pool = g_thread_pool_new (rdp_peer_encode_nsc_rect,
                                                  thread_pool_context,
                                                  g_get_num_processors (),
                                                  TRUE,
                                                  &error);
  if (!session_rdp->thread_pool)
    {
      g_free (encode_contexts);
      g_error ("Couldn't create thread pool: %s", error->message);
    }

g_mutex_lock (&session_rdp->pending_jobs_mutex);
  for (i = 0; i < n_rects; ++i)
    {
      encode_context = &encode_contexts[i];
      cairo_region_get_rectangle (region, i, &encode_context->cairo_rect);

++thread_pool_context->pending_job_count;
      g_thread_pool_push (session_rdp->thread_pool, encode_context, NULL);
    }

while (thread_pool_context->pending_job_count)
    {
      g_cond_wait (&session_rdp->pending_jobs_cond,
                   &session_rdp->pending_jobs_mutex);
    }
  g_mutex_unlock (&session_rdp->pending_jobs_mutex);

cmd.cmdType = CMDTYPE_SET_SURFACE_BITS;
  cmd.bmp.bpp = 32;
  cmd.bmp.codecID = rdp_settings->NSCodecId;

for (i = 0; i < n_rects; ++i)
    {
      encode_context = &encode_contexts[i];
      cairo_rect = &encode_context->cairo_rect;

cmd.destLeft = cairo_rect->x;
      cmd.destTop = cairo_rect->y;
      cmd.destRight = cmd.destLeft + cairo_rect->width;
      cmd.destBottom = cmd.destTop + cairo_rect->height;
      cmd.bmp.width = cairo_rect->width;
      cmd.bmp.height = cairo_rect->height;
      cmd.bmp.bitmapDataLength = Stream_GetPosition (encode_context->stream);
      cmd.bmp.bitmapData = Stream_Buffer (encode_context->stream);
      first = i == 0 ? TRUE : FALSE;
      last = i + 1 == n_rects ? TRUE : FALSE;

Stream_Free (encode_context->stream, TRUE);
    }

g_free (encode_contexts);
}

static void
rdp_peer_compress_raw_tile (gpointer data,
                            gpointer user_data)
{
  RawThreadPoolContext *thread_pool_context = (RawThreadPoolContext *) user_data;
  BITMAP_DATA *dst_bitmap = (BITMAP_DATA *) data;
  uint16_t planar_flags = thread_pool_context->planar_flags;
  uint32_t dst_bpp = dst_bitmap->bitsPerPixel;
  uint32_t dst_Bpp = (dst_bpp + 7) / 8;
  BITMAP_PLANAR_CONTEXT *planar_context;
  BITMAP_INTERLEAVED_CONTEXT *interleaved_context;
  uint32_t src_stride;
  uint32_t src_data_pos;
  uint8_t *src_data;
  uint8_t *src_data_at_pos;

dst_bitmap->bitmapLength = 64 * 64 * 4 * sizeof (uint8_t);
  dst_bitmap->bitmapDataStream = g_malloc0 (dst_bitmap->bitmapLength);

src_stride = thread_pool_context->src_stride;
  src_data_pos = dst_bitmap->destTop * src_stride + dst_bitmap->destLeft * dst_Bpp;
  src_data = thread_pool_context->src_data;
  src_data_at_pos = &src_data[src_data_pos];

switch (dst_bpp)
    {
    case 32:
      planar_context = freerdp_bitmap_planar_context_new (planar_flags, 64, 64);
      freerdp_bitmap_planar_context_reset (planar_context, 64, 64);

dst_bitmap->bitmapDataStream =
        freerdp_bitmap_compress_planar (planar_context,
                                        src_data_at_pos,
                                        PIXEL_FORMAT_BGRX32,
                                        dst_bitmap->width,
                                        dst_bitmap->height,
                                        src_stride,
                                        dst_bitmap->bitmapDataStream,
                                        &dst_bitmap->bitmapLength);

freerdp_bitmap_planar_context_free (planar_context);
      break;
    case 24:
    case 16:
    case 15:
      interleaved_context = bitmap_interleaved_context_new (TRUE);
      bitmap_interleaved_context_reset (interleaved_context);

interleaved_compress (interleaved_context,
                            dst_bitmap->bitmapDataStream,
                            &dst_bitmap->bitmapLength,
                            dst_bitmap->width,
                            dst_bitmap->height,
                            src_data,
                            PIXEL_FORMAT_BGRX32,
                            src_stride,
                            dst_bitmap->destLeft,
                            dst_bitmap->destTop,
                            NULL,
                            dst_bpp);

bitmap_interleaved_context_free (interleaved_context);
      break;
    }

dst_bitmap->cbScanWidth = dst_bitmap->width * dst_Bpp;
  dst_bitmap->cbUncompressedSize = dst_bitmap->width * dst_bitmap->height * dst_Bpp;
  dst_bitmap->cbCompFirstRowSize = 0;
  dst_bitmap->cbCompMainBodySize = dst_bitmap->bitmapLength;
  dst_bitmap->compressed = TRUE;
  dst_bitmap->flags = 0;

static void
rdp_peer_refresh_raw_rect (freerdp_peer          *peer,
                           GThreadPool           *thread_pool,
                           uint32_t              *pending_job_count,
                           BITMAP_DATA           *bitmap_data,
                           uint32_t              *n_bitmaps,
                           cairo_rectangle_int_t *cairo_rect,
                           uint8_t               *data)
{
  rdpSettings *rdp_settings = peer->settings;
  uint32_t dst_bits_per_pixel = rdp_settings->ColorDepth;
  uint32_t cols, rows;
  uint32_t x, y;
  BITMAP_DATA *bitmap;

cols = cairo_rect->width / 64 + (cairo_rect->width % 64 ? 1 : 0);
  rows = cairo_rect->height / 64 + (cairo_rect->height % 64 ? 1 : 0);

/* Both x- and y-position of each bitmap need to be a multiple of 4 */
  if (cairo_rect->x % 4)
    {
      cairo_rect->width += cairo_rect->x % 4;
      cairo_rect->x -= cairo_rect->x % 4;
    }
  if (cairo_rect->y % 4)
    {
      cairo_rect->height += cairo_rect->y % 4;
      cairo_rect->y -= cairo_rect->y % 4;
    }

/* Both width and height of each bitmap need to be a multiple of 4 */
  if (cairo_rect->width % 4)
    cairo_rect->width += 4 - cairo_rect->width % 4;
  if (cairo_rect->height % 4)
    cairo_rect->height += 4 - cairo_rect->height % 4;

for (y = 0; y < rows; ++y)
    {
      for (x = 0; x < cols; ++x)
        {
          bitmap = &bitmap_data[(*n_bitmaps)++];
          bitmap->width = 64;
          bitmap->height = 64;
          bitmap->destLeft = cairo_rect->x + x * 64;
          bitmap->destTop = cairo_rect->y + y * 64;

if (bitmap->destLeft + bitmap->width > cairo_rect->x + cairo_rect->width)
            bitmap->width = cairo_rect->x + cairo_rect->width - bitmap->destLeft;
          if (bitmap->destTop + bitmap->height > cairo_rect->y + cairo_rect->height)
            bitmap->height = cairo_rect->y + cairo_rect->height - bitmap->destTop;

bitmap->destRight = bitmap->destLeft + bitmap->width - 1;
          bitmap->destBottom = bitmap->destTop + bitmap->height - 1;
          bitmap->bitsPerPixel = dst_bits_per_pixel;

/* Both width and height of each bitmap need to be a multiple of 4 */
          if (bitmap->width < 4 || bitmap->height < 4)
            continue;

++*pending_job_count;
          g_thread_pool_push (thread_pool, bitmap, NULL);
        }
    }
}

static void
rdp_peer_refresh_raw (freerdp_peer   *peer,
                      cairo_region_t *region,
                      uint8_t        *data)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  rdpSettings *rdp_settings = peer->settings;
  rdpUpdate *rdp_update = peer->update;
  uint32_t src_stride = grd_session_rdp_get_framebuffer_stride (session_rdp);
  RawThreadPoolContext *thread_pool_context =
    &rdp_peer_context->raw_thread_pool_context;
  g_autoptr (GError) error = NULL;
  uint32_t bitmap_data_count = 0;
  uint32_t n_bitmaps = 0;
  uint32_t update_size = 0;
  cairo_rectangle_int_t cairo_rect;
  int n_rects;
  BITMAP_DATA *bitmap_data;
  uint32_t cols, rows;
  SURFACE_FRAME_MARKER marker;
  BITMAP_UPDATE bitmap_update = {0};
  uint32_t max_update_size;
  uint32_t next_size;
  int i;

n_rects = cairo_region_num_rectangles (region);
  for (i = 0; i < n_rects; ++i)
    {
      cairo_region_get_rectangle (region, i, &cairo_rect);
      cols = cairo_rect.width / 64 + (cairo_rect.width % 64 ? 1 : 0);
      rows = cairo_rect.height / 64 + (cairo_rect.height % 64 ? 1 : 0);
      bitmap_data_count += cols * rows;
    }

bitmap_data = g_malloc0 (bitmap_data_count * sizeof (BITMAP_DATA));

thread_pool_context->pending_job_count = 0;
  thread_pool_context->pending_jobs_cond = &session_rdp->pending_jobs_cond;
  thread_pool_context->pending_jobs_mutex = &session_rdp->pending_jobs_mutex;
  thread_pool_context->planar_flags = rdp_peer_context->planar_flags;
  thread_pool_context->src_stride = src_stride;
  thread_pool_context->src_data = data;

if (!session_rdp->thread_pool)
    session_rdp->thread_pool = g_thread_pool_new (rdp_peer_compress_raw_tile,
                                                  thread_pool_context,
                                                  g_get_num_processors (),
                                                  TRUE,
                                                  &error);
  if (!session_rdp->thread_pool)
    {
      g_free (bitmap_data);
      g_error ("Couldn't create thread pool: %s", error->message);
    }

g_mutex_lock (&session_rdp->pending_jobs_mutex);
  for (i = 0; i < n_rects; ++i)
    {
      cairo_region_get_rectangle (region, i, &cairo_rect);
      rdp_peer_refresh_raw_rect (peer,
                                 session_rdp->thread_pool,
                                 &thread_pool_context->pending_job_count,
                                 bitmap_data,
                                 &n_bitmaps,
                                 &cairo_rect,
                                 data);
    }

/* We send 2 additional Bytes for the update header
   * (See also update_write_bitmap_update () in FreeRDP)
   */
  max_update_size = rdp_settings->MultifragMaxRequestSize - 2;

bitmap_update.count = bitmap_update.number = 0;
  bitmap_update.rectangles = bitmap_data;
  bitmap_update.skipCompression = FALSE;

marker.frameId = rdp_peer_context->frame_id;
  marker.frameAction = SURFACECMD_FRAMEACTION_BEGIN;
  if (rdp_settings->SurfaceFrameMarkerEnabled)
    rdp_update->SurfaceFrameMarker (peer->context, &marker);

for (i = 0; i < n_bitmaps; ++i)
    {
      /* We send 26 additional Bytes for each bitmap
       * (See also update_write_bitmap_data () in FreeRDP)
       */
      update_size += bitmap_data[i].bitmapLength + 26;

++bitmap_update.count;
      ++bitmap_update.number;

next_size = i + 1 < n_bitmaps ? bitmap_data[i + 1].bitmapLength + 26
                                    : 0;
      if (!next_size || update_size + next_size > max_update_size)
        {
          rdp_update->BitmapUpdate (peer->context, &bitmap_update);

bitmap_update.rectangles += bitmap_update.count;
          bitmap_update.count = bitmap_update.number = 0;
          update_size = 0;
        }
    }

marker.frameAction = SURFACECMD_FRAMEACTION_END;
  if (rdp_settings->SurfaceFrameMarkerEnabled)
    rdp_update->SurfaceFrameMarker (peer->context, &marker);

for (i = 0; i < n_bitmaps; ++i)
    g_free (bitmap_data[i].bitmapDataStream);

g_free (bitmap_data);
}

static void
rdp_peer_refresh_region (freerdp_peer   *peer,
                         cairo_region_t *region,
                         uint8_t        *data)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  rdpSettings *rdp_settings = peer->settings;

if (rdp_settings->RemoteFxCodec)
    rdp_peer_refresh_rfx (peer, region, data);
  else if (rdp_settings->NSCodec)
    rdp_peer_refresh_nsc (peer, region, data);
  else
    rdp_peer_refresh_raw (peer, region, data);

++rdp_peer_context->frame_id;
}

static gboolean
notify_keycode_released (gpointer key,
                         gpointer value,
                         gpointer user_data)
{
  GrdSessionRdp *session_rdp = user_data;
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;
  uint32_t keycode = GPOINTER_TO_UINT (key);

grd_rdp_event_queue_add_input_event_keyboard_keycode (rdp_event_queue,
                                                        keycode,
                                                        GRD_KEY_STATE_RELEASED);

return TRUE;
}

static gboolean
notify_keysym_released (gpointer key,
                        gpointer value,
                        gpointer user_data)
{
  GrdSessionRdp *session_rdp = user_data;
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;
  xkb_keysym_t keysym = GPOINTER_TO_UINT (key);

grd_rdp_event_queue_add_input_event_keyboard_keysym (rdp_event_queue,
                                                       keysym,
                                                       GRD_KEY_STATE_RELEASED);

return TRUE;
}

static BOOL
rdp_input_synchronize_event (rdpInput *rdp_input,
                             uint32_t  flags)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) rdp_input->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;

if (!is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_ACTIVATED) ||
      is_view_only (session_rdp))
    return TRUE;

g_hash_table_foreach_remove (session_rdp->pressed_keys,
                               notify_keycode_released,
                               session_rdp);

g_hash_table_foreach_remove (session_rdp->pressed_unicode_keys,
                               notify_keysym_released,
                               session_rdp);

grd_rdp_event_queue_add_synchronization_event (rdp_event_queue,
                                                 !!(flags & KBD_SYNC_CAPS_LOCK),
                                                 !!(flags & KBD_SYNC_NUM_LOCK));

return TRUE;
}

static BOOL
rdp_input_mouse_event (rdpInput *rdp_input,
                       uint16_t  flags,
                       uint16_t  x,
                       uint16_t  y)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) rdp_input->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;
  GrdButtonState button_state;
  int32_t button = 0;
  uint16_t axis_value;
  double axis_step;

if (!is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_ACTIVATED) ||
      is_view_only (session_rdp))
    return TRUE;

if (flags & PTR_FLAGS_MOVE)
    {
      grd_rdp_event_queue_add_input_event_pointer_motion_abs (rdp_event_queue,
                                                              x, y);
    }

button_state = flags & PTR_FLAGS_DOWN ? GRD_BUTTON_STATE_PRESSED
                                        : GRD_BUTTON_STATE_RELEASED;

if (flags & PTR_FLAGS_BUTTON1)
    button = BTN_LEFT;
  else if (flags & PTR_FLAGS_BUTTON2)
    button = BTN_RIGHT;
  else if (flags & PTR_FLAGS_BUTTON3)
    button = BTN_MIDDLE;

if (button)
    {
      grd_rdp_event_queue_add_input_event_pointer_button (rdp_event_queue,
                                                          button, button_state);
    }

if (!(flags & PTR_FLAGS_WHEEL) && !(flags & PTR_FLAGS_HWHEEL))
    return TRUE;

axis_value = flags & WheelRotationMask;
  if (axis_value & PTR_FLAGS_WHEEL_NEGATIVE)
    {
      axis_value = ~axis_value & WheelRotationMask;
      ++axis_value;
    }

axis_step = -axis_value / 120.0;
  if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
    axis_step = -axis_step;

if (flags & PTR_FLAGS_WHEEL)
    {
      grd_rdp_event_queue_add_input_event_pointer_axis (
        rdp_event_queue, 0, axis_step * DISCRETE_SCROLL_STEP,
        GRD_POINTER_AXIS_FLAGS_SOURCE_WHEEL);
    }
  if (flags & PTR_FLAGS_HWHEEL)
    {
      grd_rdp_event_queue_add_input_event_pointer_axis (
        rdp_event_queue, -axis_step * DISCRETE_SCROLL_STEP, 0,
        GRD_POINTER_AXIS_FLAGS_SOURCE_WHEEL);
    }

return TRUE;
}

static BOOL
rdp_input_extended_mouse_event (rdpInput *rdp_input,
                                uint16_t  flags,
                                uint16_t  x,
                                uint16_t  y)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) rdp_input->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;
  GrdButtonState button_state;
  int32_t button = 0;

if (!is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_ACTIVATED) ||
      is_view_only (session_rdp))
    return TRUE;

if (flags & PTR_FLAGS_MOVE)
    rdp_input_mouse_event (rdp_input, PTR_FLAGS_MOVE, x, y);

button_state = flags & PTR_XFLAGS_DOWN ? GRD_BUTTON_STATE_PRESSED
                                         : GRD_BUTTON_STATE_RELEASED;

if (flags & PTR_XFLAGS_BUTTON1)
    button = BTN_SIDE;
  else if (flags & PTR_XFLAGS_BUTTON2)
    button = BTN_EXTRA;

if (button)
    {
      grd_rdp_event_queue_add_input_event_pointer_button (rdp_event_queue,
                                                          button, button_state);
    }

return TRUE;
}

static gboolean
is_pause_key_sequence (GrdSessionRdp *session_rdp,
                       uint16_t       vkcode,
                       uint16_t       flags)
{
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;

switch (session_rdp->pause_key_state)
    {
    case PAUSE_KEY_STATE_NONE:
      if (vkcode == VK_LCONTROL &&
          flags & KBD_FLAGS_DOWN &&
          flags & KBD_FLAGS_EXTENDED1)
        {
          session_rdp->pause_key_state = PAUSE_KEY_STATE_CTRL_DOWN;
          return TRUE;
        }
      return FALSE;
    case PAUSE_KEY_STATE_CTRL_DOWN:
      if (vkcode == VK_NUMLOCK &&
          flags & KBD_FLAGS_DOWN)
        {
          session_rdp->pause_key_state = PAUSE_KEY_STATE_NUMLOCK_DOWN;
          return TRUE;
        }
      break;
    case PAUSE_KEY_STATE_NUMLOCK_DOWN:
      if (vkcode == VK_LCONTROL &&
          !(flags & KBD_FLAGS_DOWN) &&
          flags & KBD_FLAGS_EXTENDED1)
        {
          session_rdp->pause_key_state = PAUSE_KEY_STATE_CTRL_UP;
          return TRUE;
        }
      break;
    case PAUSE_KEY_STATE_CTRL_UP:
      if (vkcode == VK_NUMLOCK &&
          !(flags & KBD_FLAGS_DOWN))
        {
          session_rdp->pause_key_state = PAUSE_KEY_STATE_NONE;
          grd_rdp_event_queue_add_input_event_keyboard_keysym (
            rdp_event_queue, XKB_KEY_Pause, GRD_KEY_STATE_PRESSED);
          grd_rdp_event_queue_add_input_event_keyboard_keysym (
            rdp_event_queue, XKB_KEY_Pause, GRD_KEY_STATE_RELEASED);

return TRUE;
        }
      break;
    }

g_warning ("Received invalid pause key sequence");
  session_rdp->pause_key_state = PAUSE_KEY_STATE_NONE;

return FALSE;
}

static BOOL
rdp_input_keyboard_event (rdpInput *rdp_input,
                          uint16_t  flags,
                          uint16_t  code)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) rdp_input->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;
  GrdKeyState key_state;
  uint16_t fullcode;
  uint16_t vkcode;
  uint16_t keycode;

if (!is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_ACTIVATED) ||
      is_view_only (session_rdp))
    return TRUE;

fullcode = flags & KBD_FLAGS_EXTENDED ? code | KBDEXT : code;
  vkcode = GetVirtualKeyCodeFromVirtualScanCode (fullcode, 4);
  vkcode = flags & KBD_FLAGS_EXTENDED ? vkcode | KBDEXT : vkcode;
  /**
   * Although the type is declared as an evdev keycode, FreeRDP actually returns
   * a XKB keycode
   */
  keycode = GetKeycodeFromVirtualKeyCode (vkcode, KEYCODE_TYPE_EVDEV) - 8;

key_state = flags & KBD_FLAGS_DOWN ? GRD_KEY_STATE_PRESSED
                                     : GRD_KEY_STATE_RELEASED;

if (is_pause_key_sequence (session_rdp, vkcode, flags))
    return TRUE;

if (flags & KBD_FLAGS_DOWN)
    {
      if (!g_hash_table_add (session_rdp->pressed_keys,
                             GUINT_TO_POINTER (keycode)))
        return TRUE;
    }
  else
    {
      if (!g_hash_table_remove (session_rdp->pressed_keys,
                                GUINT_TO_POINTER (keycode)))
        return TRUE;
    }

grd_rdp_event_queue_add_input_event_keyboard_keycode (rdp_event_queue,
                                                        keycode, key_state);

return TRUE;
}

static BOOL
rdp_input_unicode_keyboard_event (rdpInput *rdp_input,
                                  uint16_t  flags,
                                  uint16_t  code_utf16)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) rdp_input->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;
  uint32_t *code_utf32;
  xkb_keysym_t keysym;
  GrdKeyState key_state;

if (!is_rdp_peer_flag_set (rdp_peer_context, RDP_PEER_ACTIVATED) ||
      is_view_only (session_rdp))
    return TRUE;

code_utf32 = g_utf16_to_ucs4 (&code_utf16, 1, NULL, NULL, NULL);
  if (!code_utf32)
    return TRUE;

keysym = xkb_utf32_to_keysym (*code_utf32);
  g_free (code_utf32);

key_state = flags & KBD_FLAGS_DOWN ? GRD_KEY_STATE_PRESSED
                                     : GRD_KEY_STATE_RELEASED;

if (flags & KBD_FLAGS_DOWN)
    {
      if (!g_hash_table_add (session_rdp->pressed_unicode_keys,
                             GUINT_TO_POINTER (keysym)))
        return TRUE;
    }
  else
    {
      if (!g_hash_table_remove (session_rdp->pressed_unicode_keys,
                                GUINT_TO_POINTER (keysym)))
        return TRUE;
    }

grd_rdp_event_queue_add_input_event_keyboard_keysym (rdp_event_queue,
                                                       keysym, key_state);

return TRUE;
}

static BOOL
rdp_suppress_output (rdpContext         *rdp_context,
                     uint8_t             allow,
                     const RECTANGLE_16 *area)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) rdp_context;

if (allow)
    set_rdp_peer_flag (rdp_peer_context, RDP_PEER_OUTPUT_ENABLED);
  else
    unset_rdp_peer_flag (rdp_peer_context, RDP_PEER_OUTPUT_ENABLED);

return TRUE;
}

static BOOL
rdp_peer_capabilities (freerdp_peer *peer)
{
  rdpSettings *rdp_settings = peer->settings;

switch (rdp_settings->ColorDepth)
    {
    case 32:
      break;
    case 24:
      /* Using the interleaved codec with a colour depth of 24
       * leads to bitmaps with artifacts.
       */
      g_message ("Downgrading colour depth from 24 to 16 due to issues with "
                 "the interleaved codec");
      rdp_settings->ColorDepth = 16;
    case 16:
    case 15:
      break;
    default:
      g_warning ("Invalid colour depth, closing connection");
      return FALSE;
    }

if (!rdp_settings->DesktopResize)
    {
      g_warning ("Client doesn't support resizing, closing connection");
      return FALSE;
    }

if (rdp_settings->PointerCacheSize <= 0)
    {
      g_warning ("Client doesn't have a pointer cache, closing connection");
      return FALSE;
    }

return TRUE;
}

static BOOL
rdp_peer_post_connect (freerdp_peer *peer)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  GrdSessionRdp *session_rdp = rdp_peer_context->session_rdp;
  rdpSettings *rdp_settings = peer->settings;
  GrdRdpSAMFile *sam_file;

g_debug ("New RDP client");

if (rdp_settings->MultifragMaxRequestSize < 0x3F0000)
    {
      g_message ("Disabling NSCodec since it does not support fragmentation");
      rdp_settings->NSCodec = FALSE;
    }

rdp_settings->PointerCacheSize = MIN (rdp_settings->PointerCacheSize, 100);

grd_session_start (GRD_SESSION (session_rdp));

sam_file = g_steal_pointer (&rdp_peer_context->sam_file);
  grd_rdp_sam_maybe_close_and_free_sam_file (sam_file);

set_rdp_peer_flag (rdp_peer_context, RDP_PEER_ACTIVATED);

return TRUE;
}

static BOOL
rdp_peer_activate (freerdp_peer *peer)
{
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;
  rdpSettings *rdp_settings = peer->settings;

rfx_context_reset (rdp_peer_context->rfx_context,
                     rdp_settings->DesktopWidth,
                     rdp_settings->DesktopHeight);

return TRUE;
}

static BOOL
rdp_peer_context_new (freerdp_peer   *peer,
                      RdpPeerContext *rdp_peer_context)
{
  rdpSettings *rdp_settings = peer->settings;

rdp_peer_context->frame_id = 0;

rdp_peer_context->rfx_context = rfx_context_new (TRUE);
  rdp_peer_context->rfx_context->mode = RLGR3;
  rfx_context_set_pixel_format (rdp_peer_context->rfx_context,
                                PIXEL_FORMAT_BGRX32);

rdp_peer_context->encode_stream = Stream_New (NULL, 64 * 64 * 4);

rdp_peer_context->planar_flags = 0;
  if (rdp_settings->DrawAllowSkipAlpha)
    rdp_peer_context->planar_flags |= PLANAR_FORMAT_HEADER_NA;
  rdp_peer_context->planar_flags |= PLANAR_FORMAT_HEADER_RLE;

rdp_peer_context->vcm = WTSOpenServerA ((LPSTR) peer->context);

g_mutex_init (&rdp_peer_context->flags_mutex);
  rdp_peer_context->flags = RDP_PEER_OUTPUT_ENABLED;

return TRUE;
}

static void
rdp_peer_context_free (freerdp_peer   *peer,
                       RdpPeerContext *rdp_peer_context)
{
  if (!rdp_peer_context)
    return;

g_clear_pointer (&rdp_peer_context->vcm, WTSCloseServer);

if (rdp_peer_context->encode_stream)
    Stream_Free (rdp_peer_context->encode_stream, TRUE);

if (rdp_peer_context->rfx_context)
    rfx_context_free (rdp_peer_context->rfx_context);
}

int
grd_session_rdp_get_stride_for_width (GrdSessionRdp *session_rdp,
                                      int            width)
{
  return width * 4;
}

static void
init_rdp_session (GrdSessionRdp *session_rdp,
                  const char    *username,
                  const char    *password)
{
  GrdContext *context = grd_session_get_context (GRD_SESSION (session_rdp));
  GrdSettings *settings = grd_context_get_settings (context);
  GSocket *socket = g_socket_connection_get_socket (session_rdp->connection);
  freerdp_peer *peer;
  rdpInput *rdp_input;
  RdpPeerContext *rdp_peer_context;
  rdpSettings *rdp_settings;

g_debug ("Initialize RDP session");

peer = freerdp_peer_new (g_socket_get_fd (socket));

peer->ContextSize = sizeof (RdpPeerContext);
  peer->ContextNew = (psPeerContextNew) rdp_peer_context_new;
  peer->ContextFree = (psPeerContextFree) rdp_peer_context_free;
  freerdp_peer_context_new (peer);

rdp_peer_context = (RdpPeerContext *) peer->context;
  rdp_peer_context->session_rdp = session_rdp;

rdp_peer_context->sam_file = grd_rdp_sam_create_sam_file (username, password);

rdp_settings = peer->settings;
  freerdp_settings_set_string (rdp_settings,
                               FreeRDP_NtlmSamFile,
                               rdp_peer_context->sam_file->filename);
  rdp_settings->CertificateFile = strdup (grd_settings_get_rdp_server_cert (settings));
  rdp_settings->PrivateKeyFile = strdup (grd_settings_get_rdp_server_key (settings));
  rdp_settings->RdpSecurity = FALSE;
  rdp_settings->TlsSecurity = FALSE;
  rdp_settings->NlaSecurity = TRUE;

rdp_settings->OsMajorType = OSMAJORTYPE_UNIX;
  rdp_settings->OsMajorType = OSMINORTYPE_PSEUDO_XSERVER;
  rdp_settings->ColorDepth = 32;
  rdp_settings->HasExtendedMouseEvent = TRUE;
  rdp_settings->HasHorizontalWheel = TRUE;
  rdp_settings->RefreshRect = TRUE;
  rdp_settings->RemoteFxCodec = TRUE;
  rdp_settings->NSCodec = TRUE;
  rdp_settings->FrameMarkerCommandEnabled = TRUE;
  rdp_settings->SurfaceFrameMarkerEnabled = TRUE;
  rdp_settings->UnicodeInput = TRUE;

peer->Capabilities = rdp_peer_capabilities;
  peer->PostConnect = rdp_peer_post_connect;
  peer->Activate = rdp_peer_activate;

peer->update->SuppressOutput = rdp_suppress_output;

rdp_input = peer->input;
  rdp_input->SynchronizeEvent = rdp_input_synchronize_event;
  rdp_input->MouseEvent = rdp_input_mouse_event;
  rdp_input->ExtendedMouseEvent = rdp_input_extended_mouse_event;
  rdp_input->KeyboardEvent = rdp_input_keyboard_event;
  rdp_input->UnicodeKeyboardEvent = rdp_input_unicode_keyboard_event;

peer->Initialize (peer);

session_rdp->peer = peer;
  session_rdp->last_frame = NULL;
  session_rdp->last_pointer = NULL;
  session_rdp->thread_pool = NULL;

SetEvent (session_rdp->start_event);
}

gpointer
socket_thread_func (gpointer data)
{
  GrdSessionRdp *session_rdp = data;
  freerdp_peer *peer;
  RdpPeerContext *rdp_peer_context;
  HANDLE channel_event;
  HANDLE events[32];
  uint32_t n_events;
  uint32_t n_freerdp_handles;

WaitForSingleObject (session_rdp->start_event, INFINITE);

peer = session_rdp->peer;
  rdp_peer_context = (RdpPeerContext *) peer->context;
  channel_event = WTSVirtualChannelManagerGetEventHandle (rdp_peer_context->vcm);

while (TRUE)
    {
      n_events = 0;

events[n_events++] = session_rdp->stop_event;

n_freerdp_handles = peer->GetEventHandles (peer, &events[n_events],
                                                 32 - n_events);
      if (!n_freerdp_handles)
        {
          g_warning ("Failed to get FreeRDP transport event handles");
          handle_client_gone (session_rdp);
          break;
        }
      n_events += n_freerdp_handles;

events[n_events++] = channel_event;

WaitForMultipleObjects (n_events, events, FALSE, INFINITE);

if (WaitForSingleObject (session_rdp->stop_event, 0) == WAIT_OBJECT_0)
        break;

if (!peer->CheckFileDescriptor (peer))
        {
          g_message ("Unable to check file descriptor, closing connection");
          handle_client_gone (session_rdp);
          break;
        }

if (WaitForSingleObject (channel_event, 0) == WAIT_OBJECT_0 &&
          !WTSVirtualChannelManagerCheckFileDescriptor (rdp_peer_context->vcm))
        {
          g_message ("Unable to check VCM file descriptor, closing connection");
          handle_client_gone (session_rdp);
          break;
        }
    }

return NULL;
}

GrdSessionRdp *
grd_session_rdp_new (GrdRdpServer      *rdp_server,
                     GSocketConnection *connection)
{
  GrdSessionRdp *session_rdp;
  GrdContext *context;
  GrdSettings *settings;
  char *username;
  char *password;
  g_autoptr (GError) error = NULL;

context = grd_rdp_server_get_context (rdp_server);
  settings = grd_context_get_settings (context);
  username = grd_settings_get_rdp_username (settings, &error);
  if (!username)
    {
      g_warning ("Couldn't retrieve RDP username: %s", error->message);
      return NULL;
    }
  password = grd_settings_get_rdp_password (settings, &error);
  if (!password)
    {
      g_warning ("Couldn't retrieve RDP password: %s", error->message);
      g_free (username);
      return NULL;
    }

session_rdp = g_object_new (GRD_TYPE_SESSION_RDP,
                              "context", context,
                              NULL);

session_rdp->connection = g_object_ref (connection);
  session_rdp->start_event = CreateEvent (NULL, TRUE, FALSE, NULL);
  session_rdp->stop_event = CreateEvent (NULL, TRUE, FALSE, NULL);

session_rdp->socket_thread = g_thread_new ("RDP socket thread",
                                             socket_thread_func,
                                             session_rdp);
  if (!session_rdp->socket_thread)
    {
      g_warning ("Failed to create socket thread");

g_clear_pointer (&session_rdp->stop_event, CloseHandle);
      g_clear_pointer (&session_rdp->start_event, CloseHandle);
      g_object_unref (connection);
      g_free (password);
      g_free (username);

return NULL;
    }

init_rdp_session (session_rdp, username, password);

g_free (password);
  g_free (username);

return session_rdp;
}

static gboolean
clear_pointer_bitmap (gpointer key,
                      gpointer value,
                      gpointer user_data)
{
  Pointer *pointer = (Pointer *) key;

g_free (pointer->bitmap);
  g_free (pointer);

return TRUE;
}

static void
grd_session_rdp_stop (GrdSession *session)
{
  GrdSessionRdp *session_rdp = GRD_SESSION_RDP (session);
  freerdp_peer *peer = session_rdp->peer;
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;

g_debug ("Stopping RDP session");

if (WaitForSingleObject (session_rdp->stop_event, 0) == WAIT_TIMEOUT)
    {
      freerdp_set_error_info (peer->context->rdp,
                              ERRINFO_RPC_INITIATED_DISCONNECT);

SetEvent (session_rdp->stop_event);
    }

g_clear_object (&session_rdp->pipewire_stream);

g_clear_object (&rdp_peer_context->clipboard_rdp);

peer->Close (peer);
  g_clear_pointer (&session_rdp->socket_thread, g_thread_join);
  g_clear_object (&session_rdp->connection);

if (rdp_peer_context->sam_file)
    grd_rdp_sam_maybe_close_and_free_sam_file (rdp_peer_context->sam_file);

if (session_rdp->thread_pool)
    g_thread_pool_free (session_rdp->thread_pool, FALSE, TRUE);

peer->Disconnect (peer);
  freerdp_peer_context_free (peer);
  freerdp_peer_free (peer);

g_hash_table_foreach_remove (session_rdp->pressed_keys,
                               notify_keycode_released,
                               session_rdp);
  g_hash_table_foreach_remove (session_rdp->pressed_unicode_keys,
                               notify_keysym_released,
                               session_rdp);
  g_clear_object (&session_rdp->rdp_event_queue);

g_clear_pointer (&session_rdp->last_frame, g_free);
  g_hash_table_foreach_remove (session_rdp->pointer_cache,
                               clear_pointer_bitmap,
                               NULL);

g_clear_pointer (&session_rdp->stop_event, CloseHandle);
  g_clear_pointer (&session_rdp->start_event, CloseHandle);

g_clear_handle_id (&session_rdp->close_session_idle_id, g_source_remove);
}

static gboolean
close_session_idle (gpointer user_data)
{
  GrdSessionRdp *session_rdp = GRD_SESSION_RDP (user_data);

grd_session_stop (GRD_SESSION (session_rdp));

session_rdp->close_session_idle_id = 0;

return G_SOURCE_REMOVE;
}

static void
on_pipewire_stream_closed (GrdRdpPipeWireStream *stream,
                           GrdSessionRdp        *session_rdp)
{
  g_warning ("PipeWire stream closed, closing client");

maybe_queue_close_session_idle (session_rdp);
}

static void
grd_session_rdp_remote_desktop_session_ready (GrdSession *session)
{
  GrdSessionRdp *session_rdp = GRD_SESSION_RDP (session);
  freerdp_peer *peer = session_rdp->peer;
  RdpPeerContext *rdp_peer_context = (RdpPeerContext *) peer->context;

rdp_peer_context->clipboard_rdp = grd_clipboard_rdp_new (session_rdp,
                                                           rdp_peer_context->vcm,
                                                           session_rdp->stop_event);
}

static void
grd_session_rdp_stream_ready (GrdSession *session,
                              GrdStream  *stream)
{
  GrdSessionRdp *session_rdp = GRD_SESSION_RDP (session);
  uint32_t pipewire_node_id;
  g_autoptr (GError) error = NULL;

pipewire_node_id = grd_stream_get_pipewire_node_id (stream);
  session_rdp->pipewire_stream = grd_rdp_pipewire_stream_new (session_rdp,
                                                              pipewire_node_id,
                                                              &error);
  if (!session_rdp->pipewire_stream)
    {
      g_warning ("Failed to establish PipeWire stream: %s", error->message);
      return;
    }

g_signal_connect (session_rdp->pipewire_stream, "closed",
                    G_CALLBACK (on_pipewire_stream_closed),
                    session_rdp);
}

static void
grd_session_rdp_on_caps_lock_state_changed (GrdSession *session,
                                            gboolean    state)
{
  GrdSessionRdp *session_rdp = GRD_SESSION_RDP (session);
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;

grd_rdp_event_queue_update_caps_lock_state (rdp_event_queue, state);
}

static void
grd_session_rdp_on_num_lock_state_changed (GrdSession *session,
                                           gboolean    state)
{
  GrdSessionRdp *session_rdp = GRD_SESSION_RDP (session);
  GrdRdpEventQueue *rdp_event_queue = session_rdp->rdp_event_queue;

grd_rdp_event_queue_update_num_lock_state (rdp_event_queue, state);
}

static void
grd_session_rdp_dispose (GObject *object)
{
  GrdSessionRdp *session_rdp = GRD_SESSION_RDP (object);

g_clear_pointer (&session_rdp->pressed_unicode_keys, g_hash_table_unref);
  g_clear_pointer (&session_rdp->pressed_keys, g_hash_table_unref);
  g_clear_pointer (&session_rdp->pointer_cache, g_hash_table_unref);

G_OBJECT_CLASS (grd_session_rdp_parent_class)->dispose (object);
}

static gboolean
are_pointer_bitmaps_equal (gconstpointer a,
                           gconstpointer b)
{
  Pointer *first = (Pointer *) a;
  Pointer *second = (Pointer *) b;
  cairo_rectangle_int_t cairo_rect;

if (first->hotspot_x != second->hotspot_x ||
      first->hotspot_y != second->hotspot_y ||
      first->width != second->width ||
      first->height != second->height)
    return FALSE;

cairo_rect.x = cairo_rect.y = 0;
  cairo_rect.width = first->width;
  cairo_rect.height = first->height;
  if (grd_is_tile_dirty (&cairo_rect,
                         first->bitmap,
                         second->bitmap,
                         first->width * 4, 4))
    return FALSE;

return TRUE;
}

static void
grd_session_rdp_init (GrdSessionRdp *session_rdp)
{
  session_rdp->pointer_cache = g_hash_table_new (NULL, are_pointer_bitmaps_equal);
  session_rdp->pressed_keys = g_hash_table_new (NULL, NULL);
  session_rdp->pressed_unicode_keys = g_hash_table_new (NULL, NULL);

g_cond_init (&session_rdp->pending_jobs_cond);
  g_mutex_init (&session_rdp->pending_jobs_mutex);

session_rdp->rdp_event_queue = grd_rdp_event_queue_new (session_rdp);
}

static void
grd_session_rdp_class_init (GrdSessionRdpClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GrdSessionClass *session_class = GRD_SESSION_CLASS (klass);

object_class->dispose = grd_session_rdp_dispose;

session_class->remote_desktop_session_ready =
    grd_session_rdp_remote_desktop_session_ready;
  session_class->stop = grd_session_rdp_stop;
  session_class->stream_ready = grd_session_rdp_stream_ready;
  session_class->on_caps_lock_state_changed =
    grd_session_rdp_on_caps_lock_state_changed;
  session_class->on_num_lock_state_changed =
    grd_session_rdp_on_num_lock_state_changed;
}
0707010000002E000081A40000000000000000000000016141EE1000000883000000000000000000000000000000000000003000000000gnome-remote-desktop-40.2/src/grd-session-rdp.h/*
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef GRD_SESSION_RDP_H
#define GRD_SESSION_RDP_H

#include <gio/gio.h>
#include <glib-object.h>

#include "grd-session.h"
#include "grd-types.h"

#define GRD_TYPE_SESSION_RDP (grd_session_rdp_get_type ())
G_DECLARE_FINAL_TYPE (GrdSessionRdp,
                      grd_session_rdp,
                      GRD, SESSION_RDP,
                      GrdSession);

GrdSessionRdp *grd_session_rdp_new (GrdRdpServer      *rdp_server,
                                    GSocketConnection *connection);

int grd_session_rdp_get_stride_for_width (GrdSessionRdp *session_rdp,
                                          int            width);

void grd_session_rdp_resize_framebuffer (GrdSessionRdp *session_rdp,
                                         uint32_t       width,
                                         uint32_t       height);

void grd_session_rdp_take_buffer (GrdSessionRdp *session_rdp,
                                  void          *data);

void grd_session_rdp_update_pointer (GrdSessionRdp *session_rdp,
                                     uint16_t       hotspot_x,
                                     uint16_t       hotspot_y,
                                     uint16_t       width,
                                     uint16_t       height,
                                     uint8_t       *data);

void grd_session_rdp_hide_pointer (GrdSessionRdp *session_rdp);

#endif /* GRD_SESSION_RDP_H */
0707010000002F000081A40000000000000000000000016141EE100000556B000000000000000000000000000000000000003000000000gnome-remote-desktop-40.2/src/grd-session-vnc.c/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#include "config.h"

#include "grd-session-vnc.h"

#include <gio/gio.h>
#include <linux/input.h>
#include <rfb/rfb.h>

#include "grd-clipboard-vnc.h"
#include "grd-context.h"
#include "grd-prompt.h"
#include "grd-settings.h"
#include "grd-stream.h"
#include "grd-vnc-server.h"
#include "grd-vnc-pipewire-stream.h"

/* BGRx */
#define BGRX_BITS_PER_SAMPLE 8
#define BGRX_SAMPLES_PER_PIXEL 3
#define BGRX_BYTES_PER_PIXEL 4

struct _GrdSessionVnc
{
  GrdSession parent;

GSocketConnection *connection;
  GSource *source;
  rfbScreenInfoPtr rfb_screen;
  rfbClientPtr rfb_client;

gboolean pending_framebuffer_resize;
  int pending_framebuffer_width;
  int pending_framebuffer_height;

guint close_session_idle_id;

GrdVncAuthMethod auth_method;

GrdPrompt *prompt;
  GCancellable *prompt_cancellable;

GrdVncPipeWireStream *pipewire_stream;

int prev_x;
  int prev_y;
  int prev_button_mask;
  GHashTable *pressed_keys;

GrdClipboardVnc *clipboard_vnc;
};

G_DEFINE_TYPE (GrdSessionVnc, grd_session_vnc, GRD_TYPE_SESSION);

static void
grd_session_vnc_detach_source (GrdSessionVnc *session_vnc);

static gboolean
close_session_idle (gpointer user_data);

static rfbBool
check_rfb_password (rfbClientPtr  rfb_client,
                    const char   *response_encrypted,
                    int           len);

static void
swap_uint8 (uint8_t *a,
            uint8_t *b)
{
  uint8_t tmp;

tmp = *a;
  *a = *b;
  *b = tmp;
}

static void
update_server_format (GrdSessionVnc *session_vnc)
{
  rfbScreenInfoPtr rfb_screen = session_vnc->rfb_screen;

/*
   * Our format is hard coded to BGRX but LibVNCServer assumes it's RGBX;
   * lets override that.
   */
  swap_uint8 (&rfb_screen->serverFormat.redShift,
              &rfb_screen->serverFormat.blueShift);
}

static void
resize_vnc_framebuffer (GrdSessionVnc *session_vnc,
                        int            width,
                        int            height)
{
  rfbScreenInfoPtr rfb_screen = session_vnc->rfb_screen;
  uint8_t *framebuffer;

if (!session_vnc->rfb_client->useNewFBSize)
    g_warning ("Client does not support NewFBSize");

g_free (rfb_screen->frameBuffer);
  framebuffer = g_malloc0 (width * height * BGRX_BYTES_PER_PIXEL);
  rfbNewFramebuffer (rfb_screen,
                     (char *) framebuffer,
                     width, height,
                     BGRX_BITS_PER_SAMPLE,
                     BGRX_SAMPLES_PER_PIXEL,
                     BGRX_BYTES_PER_PIXEL);

update_server_format (session_vnc);
  rfb_screen->setTranslateFunction (session_vnc->rfb_client);
}

void
grd_session_vnc_queue_resize_framebuffer (GrdSessionVnc *session_vnc,
                                          int            width,
                                          int            height)
{
  rfbScreenInfoPtr rfb_screen = session_vnc->rfb_screen;

if (rfb_screen->width == width && rfb_screen->height == height)
    return;

if (session_vnc->rfb_client->preferredEncoding == -1)
    {
      session_vnc->pending_framebuffer_resize = TRUE;
      session_vnc->pending_framebuffer_width = width;
      session_vnc->pending_framebuffer_height = height;
      return;
    }

resize_vnc_framebuffer (session_vnc, width, height);
}

void
grd_session_vnc_take_buffer (GrdSessionVnc *session_vnc,
                             void          *data)
{
  if (session_vnc->pending_framebuffer_resize)
    {
      free (data);
      return;
    }

free (session_vnc->rfb_screen->frameBuffer);
  session_vnc->rfb_screen->frameBuffer = data;

rfbMarkRectAsModified (session_vnc->rfb_screen, 0, 0,
                         session_vnc->rfb_screen->width,
                         session_vnc->rfb_screen->height);
  rfbProcessEvents (session_vnc->rfb_screen, 0);
}

void
grd_session_vnc_flush (GrdSessionVnc *session_vnc)
{
  rfbProcessEvents (session_vnc->rfb_screen, 0);
}

void
grd_session_vnc_set_cursor (GrdSessionVnc *session_vnc,
                            rfbCursorPtr   rfb_cursor)
{
  rfbSetCursor (session_vnc->rfb_screen, rfb_cursor);
}

void
grd_session_vnc_move_cursor (GrdSessionVnc *session_vnc,
                             int            x,
                             int            y)
{
  if (session_vnc->rfb_screen->cursorX == x ||
      session_vnc->rfb_screen->cursorY == y)
    return;

LOCK (session_vnc->rfb_screen->cursorMutex);
  session_vnc->rfb_screen->cursorX = x;
  session_vnc->rfb_screen->cursorY = y;
  UNLOCK (session_vnc->rfb_screen->cursorMutex);

session_vnc->rfb_client->cursorWasMoved = TRUE;
}

void
grd_session_vnc_set_client_clipboard_text (GrdSessionVnc *session_vnc,
                                           char          *text,
                                           int            text_length)
{
  rfbSendServerCutText(session_vnc->rfb_screen, text, text_length);
}

static void
maybe_queue_close_session_idle (GrdSessionVnc *session_vnc)
{
  if (session_vnc->close_session_idle_id)
    return;

session_vnc->close_session_idle_id =
    g_idle_add (close_session_idle, session_vnc);
}

gboolean
grd_session_vnc_is_client_gone (GrdSessionVnc *session_vnc)
{
  return !session_vnc->rfb_client;
}

static void
handle_client_gone (rfbClientPtr rfb_client)
{
  GrdSessionVnc *session_vnc = rfb_client->screen->screenData;

g_debug ("VNC client gone");

grd_session_vnc_detach_source (session_vnc);
  maybe_queue_close_session_idle (session_vnc);
  session_vnc->rfb_client = NULL;
}

static void
prompt_response_callback (GObject      *source_object,
                          GAsyncResult *async_result,
                          gpointer      user_data)
{
  GrdSessionVnc *session_vnc = GRD_SESSION_VNC (user_data);
  g_autoptr(GError) error = NULL;
  GrdPromptResponse response;

if (!grd_prompt_query_finish (session_vnc->prompt,
                                async_result,
                                &response,
                                &error))
    {
      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        {
          g_warning ("Failed to query user about session: %s", error->message);
          rfbRefuseOnHoldClient (session_vnc->rfb_client);
          return;
        }
      else
        {
          return;
        }
    }

switch (response)
    {
    case GRD_PROMPT_RESPONSE_ACCEPT:
      grd_session_start (GRD_SESSION (session_vnc));
      rfbStartOnHoldClient (session_vnc->rfb_client);
      return;
    case GRD_PROMPT_RESPONSE_REFUSE:
      rfbRefuseOnHoldClient (session_vnc->rfb_client);
      return;
    }

g_assert_not_reached ();
}

static enum rfbNewClientAction
handle_new_client (rfbClientPtr rfb_client)
{
  GrdSessionVnc *session_vnc = GRD_SESSION_VNC (rfb_client->screen->screenData);
  GrdContext *context = grd_session_get_context (GRD_SESSION (session_vnc));
  GrdSettings *settings = grd_context_get_settings (context);

g_debug ("New VNC client");

session_vnc->auth_method = grd_settings_get_vnc_auth_method (settings);

session_vnc->rfb_client = rfb_client;
  rfb_client->clientGoneHook = handle_client_gone;

switch (session_vnc->auth_method)
    {
    case GRD_VNC_AUTH_METHOD_PROMPT:
      session_vnc->prompt = g_object_new (GRD_TYPE_PROMPT, NULL);
      session_vnc->prompt_cancellable = g_cancellable_new ();
      grd_prompt_query_async (session_vnc->prompt,
                              rfb_client->host,
                              session_vnc->prompt_cancellable,
                              prompt_response_callback,
                              session_vnc);
      grd_session_vnc_detach_source (session_vnc);
      return RFB_CLIENT_ON_HOLD;
    case GRD_VNC_AUTH_METHOD_PASSWORD:
      session_vnc->rfb_screen->passwordCheck = check_rfb_password;
      /*
       * authPasswdData needs to be non NULL in libvncserver to trigger
       * password authentication.
       */
      session_vnc->rfb_screen->authPasswdData = (gpointer) 1;

return RFB_CLIENT_ACCEPT;
    }

g_assert_not_reached ();
}

static gboolean
is_view_only (GrdSessionVnc *session_vnc)
{
  GrdContext *context = grd_session_get_context (GRD_SESSION (session_vnc));
  GrdSettings *settings = grd_context_get_settings (context);

return grd_settings_get_vnc_view_only (settings);
}

static void
handle_key_event (rfbBool      down,
                  rfbKeySym    keysym,
                  rfbClientPtr rfb_client)
{
  GrdSessionVnc *session_vnc = GRD_SESSION_VNC (rfb_client->screen->screenData);
  GrdSession *session = GRD_SESSION (session_vnc);

if (is_view_only (session_vnc))
    return;

if (down)
    {
      if (g_hash_table_add (session_vnc->pressed_keys,
                            GUINT_TO_POINTER (keysym)))
        {
          grd_session_notify_keyboard_keysym (session, keysym,
                                              GRD_KEY_STATE_PRESSED);
        }
    }
  else
    {
      if (g_hash_table_remove (session_vnc->pressed_keys,
                               GUINT_TO_POINTER (keysym)))
        {
          grd_session_notify_keyboard_keysym (session, keysym,
                                              GRD_KEY_STATE_RELEASED);
        }
    }
}

static gboolean
notify_keyboard_key_released (gpointer key,
                              gpointer value,
                              gpointer user_data)
{
  GrdSession *session = user_data;
  uint32_t keysym = GPOINTER_TO_UINT (key);

grd_session_notify_keyboard_keysym (session, keysym,
                                      GRD_KEY_STATE_RELEASED);

return TRUE;
}

static void
handle_release_all_keys (rfbClientPtr rfb_client)
{
  GrdSessionVnc *session_vnc = rfb_client->screen->screenData;

g_hash_table_foreach_remove (session_vnc->pressed_keys,
                               notify_keyboard_key_released,
                               session_vnc);
}

static void
handle_set_clipboard_text (char         *text,
                           int           text_length,
                           rfbClientPtr  rfb_client)
{
  GrdSessionVnc *session_vnc = rfb_client->screen->screenData;
  GrdClipboardVnc *clipboard_vnc = session_vnc->clipboard_vnc;

grd_clipboard_vnc_set_clipboard_text (clipboard_vnc, text, text_length);
}

static void
grd_session_vnc_notify_axis (GrdSessionVnc *session_vnc,
                             int            button_mask_bit_index)
{
  GrdSession *session = GRD_SESSION (session_vnc);
  GrdPointerAxis axis;
  int steps;

switch (button_mask_bit_index)
    {
    case 3:
      axis = GRD_POINTER_AXIS_VERTICAL;
      steps = -1;
      break;

case 4:
      axis = GRD_POINTER_AXIS_VERTICAL;
      steps = 1;
      break;

case 5:
      axis = GRD_POINTER_AXIS_HORIZONTAL;
      steps = -1;
      break;

case 6:
      axis = GRD_POINTER_AXIS_HORIZONTAL;
      steps = 1;
      break;

default:
      return;
    }

grd_session_notify_pointer_axis_discrete (session, axis, steps);
}

static void
handle_pointer_event (int          button_mask,
                      int          x,
                      int          y,
                      rfbClientPtr rfb_client)
{
  GrdSessionVnc *session_vnc = rfb_client->screen->screenData;
  GrdSession *session = GRD_SESSION (session_vnc);

if (is_view_only (session_vnc))
    return;

if (x != session_vnc->prev_x || y != session_vnc->prev_y)
    {
      grd_session_notify_pointer_motion_absolute (session, x, y);

session_vnc->prev_x = x;
      session_vnc->prev_y = y;
    }

if (button_mask != session_vnc->prev_button_mask)
    {
      unsigned int i;
      int buttons[] = {
        BTN_LEFT,   /* 0 */
        BTN_MIDDLE, /* 1 */
        BTN_RIGHT,  /* 2 */
        0,          /* 3 - vertical scroll: up */
        0,          /* 4 - vertical scroll: down */
        0,          /* 5 - horizontal scroll: left */
        0,          /* 6 - horizontal scroll: right */
        BTN_SIDE,   /* 7 */
        BTN_EXTRA,  /* 8 */
      };

for (i = 0; i < G_N_ELEMENTS (buttons); i++)
        {
          int button = buttons[i];
          int prev_button_state = (session_vnc->prev_button_mask >> i) & 0x01;
          int cur_button_state = (button_mask >> i) & 0x01;

if (prev_button_state != cur_button_state)
            {
              if (button)
                {
                  grd_session_notify_pointer_button (session,
                                                     button,
                                                     cur_button_state);
                }
              else
                {
                  grd_session_vnc_notify_axis (session_vnc, i);
                }
            }
        }

session_vnc->prev_button_mask = button_mask;
    }

rfbDefaultPtrAddEvent (button_mask, x, y, rfb_client);
}

static rfbBool
check_rfb_password (rfbClientPtr  rfb_client,
                    const char   *response_encrypted,
                    int           len)
{
  GrdSessionVnc *session_vnc = rfb_client->screen->screenData;
  GrdContext *context = grd_session_get_context (GRD_SESSION (session_vnc));
  GrdSettings *settings = grd_context_get_settings (context);
  g_autofree char *password = NULL;
  g_autoptr(GError) error = NULL;
  uint8_t challenge_encrypted[CHALLENGESIZE];

switch (session_vnc->auth_method)
    {
    case GRD_VNC_AUTH_METHOD_PROMPT:
      return TRUE;
    case GRD_VNC_AUTH_METHOD_PASSWORD:
      break;
    }

password = grd_settings_get_vnc_password (settings, &error);
  if (!password)
    {
      g_warning ("Couldn't retrieve VNC password: %s", error->message);
      return FALSE;
    }

if (strlen (password) == 0)
    {
      g_warning ("VNC password was empty, denying");
      return FALSE;
    }

memcpy(challenge_encrypted, rfb_client->authChallenge, CHALLENGESIZE);
  rfbEncryptBytes(challenge_encrypted, password);

if (memcmp (challenge_encrypted, response_encrypted, len) == 0)
    {
      grd_session_start (GRD_SESSION (session_vnc));
      grd_session_vnc_detach_source (session_vnc);
      return TRUE;
    }
  else
    {
      return FALSE;
    }
}

int
grd_session_vnc_get_stride_for_width (GrdSessionVnc *session_vnc,
                                      int            width)
{
  return width * BGRX_BYTES_PER_PIXEL;
}

static void
init_vnc_session (GrdSessionVnc *session_vnc)
{
  GSocket *socket;
  int screen_width;
  int screen_height;
  rfbScreenInfoPtr rfb_screen;

/* Arbitrary framebuffer size, will get the proper size from the stream. */
  screen_width = 800;
  screen_height = 600;
  rfb_screen = rfbGetScreen (0, NULL,
                             screen_width, screen_height,
                             8, 3, 4);
  session_vnc->rfb_screen = rfb_screen;

update_server_format (session_vnc);

session_vnc->clipboard_vnc = grd_clipboard_vnc_new (session_vnc);

socket = g_socket_connection_get_socket (session_vnc->connection);
  rfb_screen->inetdSock = g_socket_get_fd (socket);
  rfb_screen->desktopName = "GNOME";
  rfb_screen->versionString = "GNOME Remote Desktop (VNC)";
  rfb_screen->neverShared = TRUE;
  rfb_screen->newClientHook = handle_new_client;
  rfb_screen->screenData = session_vnc;

/* Amount of milliseconds to wait before sending an update */
  rfb_screen->deferUpdateTime = 0;

rfb_screen->kbdAddEvent = handle_key_event;
  rfb_screen->kbdReleaseAllKeys = handle_release_all_keys;
  rfb_screen->setXCutText = handle_set_clipboard_text;
  rfb_screen->ptrAddEvent = handle_pointer_event;

rfb_screen->frameBuffer = g_malloc0 (screen_width * screen_height * 4);
  memset (rfb_screen->frameBuffer, 0x1f, screen_width * screen_height * 4);

rfbInitServer (rfb_screen);
  rfbProcessEvents (rfb_screen, 0);
}

static gboolean
handle_socket_data (GSocket *socket,
                    GIOCondition condition,
                    gpointer user_data)
{
  GrdSessionVnc *session_vnc = user_data;

if (condition & G_IO_IN)
    {
      if (rfbIsActive (session_vnc->rfb_screen))
        {
          rfbProcessEvents (session_vnc->rfb_screen, 0);

if (session_vnc->pending_framebuffer_resize &&
              session_vnc->rfb_client->preferredEncoding != -1)
            {
              resize_vnc_framebuffer (session_vnc,
                                      session_vnc->pending_framebuffer_width,
                                      session_vnc->pending_framebuffer_height);
              session_vnc->pending_framebuffer_resize = FALSE;

/**
               * This is a workaround. libvncserver is unable to handle clipboard
               * changes early and either disconnects the client or crashes g-r-d
               * if it receives rfbSendServerCutText too early altough the
               * authentification process is already done.
               * Doing this after resizing the framebuffer, seems to work fine,
               * so enable the clipboard here and not when the remote desktop
               * session proxy is acquired.
               */
              grd_clipboard_vnc_maybe_enable_clipboard (session_vnc->clipboard_vnc);
            }
        }
    }
  else
    {
      g_debug ("Unhandled socket condition %d\n", condition);
      return G_SOURCE_REMOVE;
    }

return G_SOURCE_CONTINUE;
}

static void
grd_session_vnc_attach_source (GrdSessionVnc *session_vnc)
{
  GSocket *socket;

socket = g_socket_connection_get_socket (session_vnc->connection);
  session_vnc->source = g_socket_create_source (socket,
                                                G_IO_IN | G_IO_PRI,
                                                NULL);
  g_source_set_callback (session_vnc->source,
                         (GSourceFunc) handle_socket_data,
                         session_vnc, NULL);
  g_source_attach (session_vnc->source, NULL);
}

static void
grd_session_vnc_detach_source (GrdSessionVnc *session_vnc)
{
  g_clear_pointer (&session_vnc->source, g_source_destroy);
}

GrdSessionVnc *
grd_session_vnc_new (GrdVncServer      *vnc_server,
                     GSocketConnection *connection)
{
  GrdSessionVnc *session_vnc;
  GrdContext *context;

context = grd_vnc_server_get_context (vnc_server);
  session_vnc = g_object_new (GRD_TYPE_SESSION_VNC,
                              "context", context,
                              NULL);

session_vnc->connection = g_object_ref (connection);

grd_session_vnc_attach_source (session_vnc);

init_vnc_session (session_vnc);

return session_vnc;
}

static void
grd_session_vnc_dispose (GObject *object)
{
  GrdSessionVnc *session_vnc = GRD_SESSION_VNC (object);

g_assert (!session_vnc->rfb_screen);

g_clear_pointer (&session_vnc->pressed_keys, g_hash_table_unref);

G_OBJECT_CLASS (grd_session_vnc_parent_class)->dispose (object);
}

static void
grd_session_vnc_stop (GrdSession *session)
{
  GrdSessionVnc *session_vnc = GRD_SESSION_VNC (session);

g_debug ("Stopping VNC session");

g_clear_object (&session_vnc->pipewire_stream);

grd_session_vnc_detach_source (session_vnc);

g_clear_object (&session_vnc->connection);
  g_clear_object (&session_vnc->clipboard_vnc);
  g_clear_pointer (&session_vnc->rfb_screen->frameBuffer, g_free);
  g_clear_pointer (&session_vnc->rfb_screen, rfbScreenCleanup);

g_clear_handle_id (&session_vnc->close_session_idle_id, g_source_remove);
}

static gboolean
close_session_idle (gpointer user_data)
{
  GrdSessionVnc *session_vnc = GRD_SESSION_VNC (user_data);

grd_session_stop (GRD_SESSION (session_vnc));

session_vnc->close_session_idle_id = 0;

return G_SOURCE_REMOVE;
}

static void
on_pipewire_stream_closed (GrdVncPipeWireStream *stream,
                           GrdSessionVnc        *session_vnc)
{
  g_warning ("PipeWire stream closed, closing client");

maybe_queue_close_session_idle (session_vnc);
}

static void
grd_session_vnc_stream_ready (GrdSession *session,
                              GrdStream  *stream)
{
  GrdSessionVnc *session_vnc = GRD_SESSION_VNC (session);
  uint32_t pipewire_node_id;
  g_autoptr (GError) error = NULL;

pipewire_node_id = grd_stream_get_pipewire_node_id (stream);
  session_vnc->pipewire_stream = grd_vnc_pipewire_stream_new (session_vnc,
                                                              pipewire_node_id,
                                                              &error);
  if (!session_vnc->pipewire_stream)
    {
      g_warning ("Failed to establish PipeWire stream: %s", error->message);
      return;
    }

g_signal_connect (session_vnc->pipewire_stream, "closed",
                    G_CALLBACK (on_pipewire_stream_closed),
                    session_vnc);

if (!session_vnc->source)
    grd_session_vnc_attach_source (session_vnc);
}

static void
grd_session_vnc_init (GrdSessionVnc *session_vnc)
{
  session_vnc->pressed_keys = g_hash_table_new (NULL, NULL);
}

static void
grd_session_vnc_class_init (GrdSessionVncClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GrdSessionClass *session_class = GRD_SESSION_CLASS (klass);

object_class->dispose = grd_session_vnc_dispose;

session_class->stop = grd_session_vnc_stop;
  session_class->stream_ready = grd_session_vnc_stream_ready;
}
07070100000030000081A40000000000000000000000016141EE10000009B2000000000000000000000000000000000000003000000000gnome-remote-desktop-40.2/src/grd-session-vnc.h/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#ifndef GRD_SESSION_VNC_H
#define GRD_SESSION_VNC_H

#include <gio/gio.h>
#include <glib-object.h>
#include <rfb/rfb.h>

#include "grd-session.h"
#include "grd-types.h"

#define GRD_TYPE_SESSION_VNC (grd_session_vnc_get_type ())
G_DECLARE_FINAL_TYPE (GrdSessionVnc,
                      grd_session_vnc,
                      GRD, SESSION_VNC,
                      GrdSession);

GrdSessionVnc *grd_session_vnc_new (GrdVncServer      *vnc_server,
                                    GSocketConnection *connection);

void grd_session_vnc_queue_resize_framebuffer (GrdSessionVnc *session_vnc,
                                               int            width,
                                               int            height);

void grd_session_vnc_take_buffer (GrdSessionVnc *session_vnc,
                                  void          *data);

void grd_session_vnc_flush (GrdSessionVnc *session_vnc);

void grd_session_vnc_set_cursor (GrdSessionVnc *session_vnc,
                                 rfbCursorPtr   rfb_cursor);

void grd_session_vnc_move_cursor (GrdSessionVnc *session_vnc,
                                  int            x,
                                  int            y);

void grd_session_vnc_set_client_clipboard_text (GrdSessionVnc *session_vnc,
                                                char          *text,
                                                int            text_length);

int grd_session_vnc_get_stride_for_width (GrdSessionVnc *session_vnc,
                                          int            width);

gboolean grd_session_vnc_is_client_gone (GrdSessionVnc *session_vnc);

#endif /* GRD_SESSION_VNC_H */
07070100000031000081A40000000000000000000000016141EE1000007AB3000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/src/grd-session.c/*
 * Copyright (C) 2015 Red Hat Inc.
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#include "config.h"

#include "grd-session.h"

#include <gio/gunixfdlist.h>
#include <glib-object.h>
#include <glib-unix.h>
#include <sys/mman.h>

#include "grd-clipboard.h"
#include "grd-dbus-remote-desktop.h"
#include "grd-context.h"
#include "grd-private.h"
#include "grd-stream.h"

enum
{
  PROP_0,

PROP_CONTEXT,
};

enum
{
  STOPPED,

LAST_SIGNAL
};

static guint signals[LAST_SIGNAL];

typedef enum _GrdScreenCastCursorMode
{
  GRD_SCREEN_CAST_CURSOR_MODE_HIDDEN = 0,
  GRD_SCREEN_CAST_CURSOR_MODE_EMBEDDED = 1,
  GRD_SCREEN_CAST_CURSOR_MODE_METADATA = 2,
} GrdScreenCastCursorMode;

typedef struct _GrdSessionPrivate
{
  GrdContext *context;

GrdDBusRemoteDesktopSession *remote_desktop_session;
  GrdDBusScreenCastSession *screen_cast_session;

GrdStream *stream;

GrdClipboard *clipboard;

GCancellable *cancellable;

gboolean started;
} GrdSessionPrivate;

G_DEFINE_TYPE_WITH_PRIVATE (GrdSession, grd_session, G_TYPE_OBJECT);

GrdContext *
grd_session_get_context (GrdSession *session)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);

return priv->context;
}

void
grd_session_stop (GrdSession *session)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);

GRD_SESSION_GET_CLASS (session)->stop (session);

if (priv->remote_desktop_session && priv->started)
    {
      GrdDBusRemoteDesktopSession *proxy = priv->remote_desktop_session;
      GError *error = NULL;

if (!grd_dbus_remote_desktop_session_call_stop_sync (proxy, NULL, &error))
        {
          g_warning ("Failed to stop: %s\n", error->message);
          g_error_free (error);
        }
    }

g_clear_object (&priv->remote_desktop_session);
  g_clear_object (&priv->screen_cast_session);

g_signal_emit (session, signals[STOPPED], 0);
}

void
grd_session_notify_keyboard_keycode (GrdSession  *session,
                                     uint32_t     keycode,
                                     GrdKeyState  state)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktopSession *session_proxy = priv->remote_desktop_session;

grd_dbus_remote_desktop_session_call_notify_keyboard_keycode (session_proxy,
                                                                keycode,
                                                                state,
                                                                NULL,
                                                                NULL,
                                                                NULL);
}

void
grd_session_notify_keyboard_keysym (GrdSession *session,
                                    uint32_t    keysym,
                                    GrdKeyState state)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktopSession *session_proxy = priv->remote_desktop_session;

grd_dbus_remote_desktop_session_call_notify_keyboard_keysym (session_proxy,
                                                               keysym,
                                                               state,
                                                               NULL,
                                                               NULL,
                                                               NULL);
}

void
grd_session_notify_pointer_button (GrdSession *session,
                                   int32_t        button,
                                   GrdButtonState state)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktopSession *session_proxy = priv->remote_desktop_session;

grd_dbus_remote_desktop_session_call_notify_pointer_button (session_proxy,
                                                              button,
                                                              state,
                                                              NULL,
                                                              NULL,
                                                              NULL);
}

void
grd_session_notify_pointer_axis (GrdSession          *session,
                                 double               dx,
                                 double               dy,
                                 GrdPointerAxisFlags  flags)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktopSession *session_proxy = priv->remote_desktop_session;

grd_dbus_remote_desktop_session_call_notify_pointer_axis (
    session_proxy, dx, dy, flags, NULL, NULL, NULL);
}

void
grd_session_notify_pointer_axis_discrete (GrdSession    *session,
                                          GrdPointerAxis axis,
                                          int            steps)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktopSession *session_proxy = priv->remote_desktop_session;

grd_dbus_remote_desktop_session_call_notify_pointer_axis_discrete (
    session_proxy, axis, steps, NULL, NULL, NULL);
}

void
grd_session_notify_pointer_motion_absolute (GrdSession *session,
                                            double      x,
                                            double      y)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  const char *stream_path;

if (!priv->stream)
    return;

stream_path = grd_stream_get_object_path (priv->stream);

grd_dbus_remote_desktop_session_call_notify_pointer_motion_absolute (
    priv->remote_desktop_session, stream_path, x, y, NULL, NULL, NULL);
}

static GVariant *
serialize_mime_type_tables (GList *mime_type_tables)
{
  GVariantBuilder builder;
  GList *l;

g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
  for (l = mime_type_tables; l; l = l->next)
    {
      GrdMimeTypeTable *mime_type_table = l->data;
      GrdMimeType mime_type;
      const char *mime_type_string;
      
      mime_type = mime_type_table->mime_type;
      mime_type_string = grd_mime_type_to_string (mime_type);
      g_variant_builder_add (&builder, "s", mime_type_string);
    }

return g_variant_builder_end (&builder);
}

static GVariant *
serialize_clipboard_options (GList *mime_type_tables)
{
  GVariantBuilder builder;

g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  if (mime_type_tables)
    {
      g_variant_builder_add (&builder, "{sv}", "mime-types",
                             serialize_mime_type_tables (mime_type_tables));
    }

return g_variant_builder_end (&builder);
}

gboolean
grd_session_enable_clipboard (GrdSession   *session,
                              GrdClipboard *clipboard,
                              GList        *mime_type_tables)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GVariant *options_variant;
  g_autoptr (GError) error = NULL;

if (!priv->remote_desktop_session)
    return FALSE;

priv->clipboard = clipboard;

options_variant = serialize_clipboard_options (mime_type_tables);
  if (!grd_dbus_remote_desktop_session_call_enable_clipboard_sync (
         priv->remote_desktop_session, options_variant, NULL, &error))
    {
      g_warning ("Failed to enable clipboard: %s", error->message);
      return FALSE;
    }

return TRUE;
}

void
grd_session_disable_clipboard (GrdSession *session)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);

if (!priv->remote_desktop_session)
    return;

grd_dbus_remote_desktop_session_call_disable_clipboard (
    priv->remote_desktop_session, NULL, NULL, NULL);
}

void
grd_session_set_selection (GrdSession *session,
                           GList      *mime_type_tables)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GVariant *options_variant;
  g_autoptr (GError) error = NULL;
  
  options_variant = serialize_clipboard_options (mime_type_tables);

if (!grd_dbus_remote_desktop_session_call_set_selection_sync (
         priv->remote_desktop_session, options_variant, NULL, &error))
    g_warning ("Failed to set selection: %s", error->message);
}

static int
acquire_fd_from_list (GUnixFDList  *fd_list,
                      int           fd_idx,
                      GError      **error)
{
  int fd;
  int fd_flags;

fd = g_unix_fd_list_get (fd_list, fd_idx, error);
  if (fd == -1)
    {
      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
                   "fcntl: %s", g_strerror (errno));
      return -1;
    }

fd_flags = fcntl (fd, F_GETFD);
  if (fd_flags == -1)
    {
      close (fd);
      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
                   "fcntl: %s", g_strerror (errno));
      return -1;
    }

if (fcntl (fd, F_SETFD, fd_flags | FD_CLOEXEC) == -1)
    {
      close (fd);
      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
                   "fcntl: %s", g_strerror (errno));
      return -1;
    }

return fd;
}

uint8_t *
grd_session_selection_read (GrdSession  *session,
                            GrdMimeType  mime_type,
                            uint32_t    *size)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  g_autoptr (GError) error = NULL;
  g_autoptr (GVariant) fd_variant = NULL;
  g_autoptr (GUnixFDList) fd_list = NULL;
  int fd_idx;
  int fd;
  const char *mime_type_string;
  GArray *data;

mime_type_string = grd_mime_type_to_string (mime_type);
  if (!grd_dbus_remote_desktop_session_call_selection_read_sync (
         priv->remote_desktop_session, mime_type_string, NULL, &fd_variant,
         &fd_list, NULL, &error))
    {
      g_warning ("Failed to read selection: %s", error->message);
      return NULL;
    }

g_variant_get (fd_variant, "h", &fd_idx);
  fd = acquire_fd_from_list (fd_list, fd_idx, &error);
  if (fd == -1)
    {
      g_warning ("Failed to acquire file descriptor: %s", error->message);
      return NULL;
    }

data = g_array_new (FALSE, TRUE, sizeof (uint8_t));
  while (TRUE)
    {
      int len;
      uint8_t buffer[1024];

len = read (fd, buffer, G_N_ELEMENTS (buffer));
      if (len < 0)
        {
          if (errno == EAGAIN)
            continue;

g_warning ("read() failed: %s", g_strerror (errno));
          break;
        }
      else if (len == 0)
        {
          break;
        }
      else
        {
          g_array_append_vals (data, buffer, len);
        }
    }

if (data->len >= 0)
    *size = data->len;

close (fd);

return (uint8_t *) g_array_free (data, FALSE);
}

static void
on_stream_ready (GrdStream  *stream,
                 GrdSession *session)
{
  GRD_SESSION_GET_CLASS (session)->stream_ready (session, stream);
}

static void
on_stream_closed (GrdStream  *stream,
                  GrdSession *session)
{
  grd_session_stop (session);
}

static void
on_session_start_finished (GObject      *object,
                           GAsyncResult *result,
                           gpointer      user_data)
{
  GrdSession *session = user_data;
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktopSession *proxy = priv->remote_desktop_session;
  GError *error = NULL;

if (!grd_dbus_remote_desktop_session_call_start_finish (proxy,
                                                          result,
                                                          &error))
    {
      g_warning ("Failed to start session: %s", error->message);
      g_error_free (error);

grd_session_stop (session);

return;
    }

priv->started = TRUE;
}

static void
start_session (GrdSession *session)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktopSession *proxy = priv->remote_desktop_session;

grd_dbus_remote_desktop_session_call_start (proxy,
                                              priv->cancellable,
                                              on_session_start_finished,
                                              session);
}

static void
on_screen_cast_stream_proxy_acquired (GObject      *object,
                                      GAsyncResult *result,
                                      gpointer      user_data)
{
  GrdSession *session = user_data;
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusScreenCastStream *stream_proxy;
  GError *error = NULL;
  GrdStream *stream;

stream_proxy = grd_dbus_screen_cast_stream_proxy_new_finish (result, &error);
  if (!stream_proxy)
    {
      g_warning ("Failed to acquire stream proxy: %s", error->message);
      g_error_free (error);

grd_session_stop (session);

return;
    }

stream = grd_stream_new (priv->context, stream_proxy);
  g_signal_connect (stream, "ready", G_CALLBACK (on_stream_ready),
                    session);
  g_signal_connect (stream, "closed", G_CALLBACK (on_stream_closed),
                    session);
  priv->stream = stream;

start_session (session);
}

static void
on_record_monitor_finished (GObject      *object,
                            GAsyncResult *result,
                            gpointer      user_data)
{
  GrdSession *session = user_data;
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusScreenCastSession *proxy = priv->screen_cast_session;
  g_autofree char *stream_path = NULL;
  GError *error = NULL;
  GDBusConnection *connection;

if (!grd_dbus_screen_cast_session_call_record_monitor_finish (proxy,
                                                                &stream_path,
                                                                result,
                                                                &error))
    {
      g_warning ("Failed to record monitor: %s", error->message);
      g_error_free (error);

grd_session_stop (session);

return;
    }

connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (proxy));
  grd_dbus_screen_cast_stream_proxy_new (connection,
                                         G_DBUS_PROXY_FLAGS_NONE,
                                         MUTTER_SCREEN_CAST_BUS_NAME,
                                         stream_path,
                                         priv->cancellable,
                                         on_screen_cast_stream_proxy_acquired,
                                         session);
}

static void
on_screen_cast_session_proxy_acquired (GObject      *object,
                                       GAsyncResult *result,
                                       gpointer      user_data)
{
  GrdSession *session = user_data;
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusScreenCastSession *session_proxy;
  GVariantBuilder properties_builder;
  GError *error = NULL;

session_proxy =
    grd_dbus_screen_cast_session_proxy_new_finish (result, &error);
  if (!session_proxy)
    {
      g_warning ("Failed to acquire screen cast session proxy: %s\n",
                 error->message);
      g_error_free (error);

grd_session_stop (session);

return;
    }

priv->screen_cast_session = session_proxy;

g_variant_builder_init (&properties_builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_add (&properties_builder, "{sv}",
                         "cursor-mode",
                         g_variant_new_uint32 (GRD_SCREEN_CAST_CURSOR_MODE_METADATA));

/* TODO: Support something other than primary monitor */
  grd_dbus_screen_cast_session_call_record_monitor (session_proxy,
                                                    "",
                                                    g_variant_builder_end (&properties_builder),
                                                    priv->cancellable,
                                                    on_record_monitor_finished,
                                                    session);
}

static void
on_screen_cast_session_created (GObject      *source_object,
                                GAsyncResult *res,
                                gpointer      user_data)
{
  GrdSession *session = user_data;
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusScreenCast *screen_cast_proxy;
  g_autofree char *session_path = NULL;
  GError *error = NULL;
  GDBusConnection *connection;

screen_cast_proxy = grd_context_get_screen_cast_proxy (priv->context);
  if (!grd_dbus_screen_cast_call_create_session_finish (screen_cast_proxy,
                                                        &session_path,
                                                        res,
                                                        &error))
    {
      g_warning ("Failed to start screen cast session: %s\n", error->message);
      g_error_free (error);

grd_session_stop (session);

return;
    }

connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (screen_cast_proxy));
  grd_dbus_screen_cast_session_proxy_new (connection,
                                          G_DBUS_PROXY_FLAGS_NONE,
                                          MUTTER_SCREEN_CAST_BUS_NAME,
                                          session_path,
                                          priv->cancellable,
                                          on_screen_cast_session_proxy_acquired,
                                          session);
}

static void
on_remote_desktop_session_closed (GrdDBusRemoteDesktopSession *session_proxy,
                                  GrdSession                  *session)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);

g_clear_object (&priv->remote_desktop_session);
  g_clear_object (&priv->screen_cast_session);

grd_session_stop (session);
}

static void
on_remote_desktop_session_selection_owner_changed (GrdDBusRemoteDesktopSession *session_proxy,
                                                   GVariant                    *options_variant,
                                                   GrdSession                  *session)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GVariant *is_owner_variant, *mime_types_variant;
  GVariantIter iter;
  const char *mime_string;
  GrdMimeType mime_type;
  GList *mime_type_list = NULL;

is_owner_variant = g_variant_lookup_value (options_variant, "session-is-owner",
                                             G_VARIANT_TYPE ("b"));
  if (is_owner_variant && g_variant_get_boolean (is_owner_variant))
    return;

mime_types_variant = g_variant_lookup_value (options_variant, "mime-types",
                                               G_VARIANT_TYPE ("(as)"));
  if (!mime_types_variant)
    return;

g_variant_iter_init (&iter, g_variant_get_child_value (mime_types_variant, 0));
  while (g_variant_iter_loop (&iter, "s", &mime_string))
    {
      mime_type = grd_mime_type_from_string (mime_string);
      if (mime_type != GRD_MIME_TYPE_NONE)
        {
          mime_type_list = g_list_append (mime_type_list,
                                          GUINT_TO_POINTER (mime_type));
          g_debug ("Clipboard[SelectionOwnerChanged]: Server advertises mime "
                   "type %s", mime_string);
        }
      else
        {
          g_debug ("Clipboard[SelectionOwnerChanged]: Server advertised unknown "
                   "mime type: %s", mime_string);
        }
    }

if (mime_type_list)
    grd_clipboard_update_client_mime_type_list (priv->clipboard, mime_type_list);
}

static void
on_remote_desktop_session_selection_transfer (GrdDBusRemoteDesktopSession *session_proxy,
                                              char                        *mime_type_string,
                                              unsigned int                 serial,
                                              GrdSession                  *session)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  uint8_t *data;
  uint32_t size;
  g_autoptr (GError) error = NULL;
  g_autoptr (GVariant) fd_variant = NULL;
  g_autoptr (GUnixFDList) fd_list = NULL;
  int fd_idx;
  int fd;
  GrdMimeType mime_type;

mime_type = grd_mime_type_from_string (mime_type_string);
  if (mime_type == GRD_MIME_TYPE_NONE)
    {
      grd_dbus_remote_desktop_session_call_selection_write_done (
        priv->remote_desktop_session, serial, FALSE, NULL, NULL, NULL);
      return;
    }

if (!grd_dbus_remote_desktop_session_call_selection_write_sync (
         priv->remote_desktop_session, serial, NULL, &fd_variant, &fd_list,
         NULL, &error))
    {
      g_warning ("Failed to write selection: %s", error->message);
      return;
    }

data = grd_clipboard_request_client_content_for_mime_type (priv->clipboard,
                                                             mime_type, &size);
  if (!size || write (fd, data, size) < 0)
    {
      grd_dbus_remote_desktop_session_call_selection_write_done (
        priv->remote_desktop_session, serial, FALSE, NULL, NULL, NULL);

close (fd);
      g_free (data);
      return;
    }

grd_dbus_remote_desktop_session_call_selection_write_done (
    priv->remote_desktop_session, serial, TRUE, NULL, NULL, NULL);

close (fd);
  g_free (data);
}

static void
on_caps_lock_state_changed (GrdDBusRemoteDesktopSession *session_proxy,
                            GParamSpec                  *param_spec,
                            GrdSession                  *session)
{
  GrdSessionClass *klass = GRD_SESSION_GET_CLASS (session);
  gboolean state;

state = grd_dbus_remote_desktop_session_get_caps_lock_state (session_proxy);
  g_debug ("Caps lock state: %s", state ? "locked" : "unlocked");

if (klass->on_caps_lock_state_changed)
    klass->on_caps_lock_state_changed (session, state);
}

static void
on_num_lock_state_changed (GrdDBusRemoteDesktopSession *session_proxy,
                           GParamSpec                  *param_spec,
                           GrdSession                  *session)
{
  GrdSessionClass *klass = GRD_SESSION_GET_CLASS (session);
  gboolean state;

state = grd_dbus_remote_desktop_session_get_num_lock_state (session_proxy);
  g_debug ("Num lock state: %s", state ? "locked" : "unlocked");

if (klass->on_num_lock_state_changed)
    klass->on_num_lock_state_changed (session, state);
}

static void
on_remote_desktop_session_proxy_acquired (GObject      *object,
                                          GAsyncResult *result,
                                          gpointer      user_data)
{
  GrdSession *session = user_data;
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdSessionClass *klass = GRD_SESSION_GET_CLASS (session);
  GrdDBusRemoteDesktopSession *session_proxy;
  GError *error = NULL;
  const char *remote_desktop_session_id;
  GrdDBusScreenCast *screen_cast_proxy;
  GVariantBuilder properties_builder;
  GVariant *properties_variant;

session_proxy =
    grd_dbus_remote_desktop_session_proxy_new_finish (result, &error);
  if (!session_proxy)
    {
      g_warning ("Failed to acquire remote desktop session proxy: %s\n",
                 error->message);
      g_error_free (error);

grd_session_stop (session);

return;
    }

g_signal_connect (session_proxy, "closed",
                    G_CALLBACK (on_remote_desktop_session_closed),
                    session);
  g_signal_connect (session_proxy, "selection-owner-changed",
                    G_CALLBACK (on_remote_desktop_session_selection_owner_changed),
                    session);
  g_signal_connect (session_proxy, "selection-transfer",
                    G_CALLBACK (on_remote_desktop_session_selection_transfer),
                    session);

priv->remote_desktop_session = session_proxy;

remote_desktop_session_id =
    grd_dbus_remote_desktop_session_get_session_id (session_proxy);

g_variant_builder_init (&properties_builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_add (&properties_builder, "{sv}",
                         "remote-desktop-session-id",
                         g_variant_new_string (remote_desktop_session_id));
  g_variant_builder_add (&properties_builder, "{sv}",
                         "disable-animations",
                         g_variant_new_boolean (TRUE));
  properties_variant = g_variant_builder_end (&properties_builder);

screen_cast_proxy = grd_context_get_screen_cast_proxy (priv->context);
  grd_dbus_screen_cast_call_create_session (screen_cast_proxy,
                                            properties_variant,
                                            priv->cancellable,
                                            on_screen_cast_session_created,
                                            session);

g_signal_connect (session_proxy, "notify::caps-lock-state",
                    G_CALLBACK (on_caps_lock_state_changed),
                    session);
  g_signal_connect (session_proxy, "notify::num-lock-state",
                    G_CALLBACK (on_num_lock_state_changed),
                    session);

if (klass->remote_desktop_session_ready)
    klass->remote_desktop_session_ready (session);

on_caps_lock_state_changed (session_proxy, NULL, session);
  on_num_lock_state_changed (session_proxy, NULL, session);
}

static void
on_remote_desktop_session_created (GObject      *source_object,
                                   GAsyncResult *res,
                                   gpointer      user_data)
{
  GrdSession *session = user_data;
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktop *remote_desktop_proxy;
  g_autofree char *session_path = NULL;
  GDBusConnection *connection;
  GError *error = NULL;

remote_desktop_proxy = grd_context_get_remote_desktop_proxy (priv->context);
  if (!grd_dbus_remote_desktop_call_create_session_finish (remote_desktop_proxy,
                                                           &session_path,
                                                           res,
                                                           &error))
    {
      g_warning ("Failed to start remote desktop session: %s\n", error->message);
      g_error_free (error);

grd_session_stop (session);

return;
    }

connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (remote_desktop_proxy));
  grd_dbus_remote_desktop_session_proxy_new (connection,
                                             G_DBUS_PROXY_FLAGS_NONE,
                                             MUTTER_REMOTE_DESKTOP_BUS_NAME,
                                             session_path,
                                             priv->cancellable,
                                             on_remote_desktop_session_proxy_acquired,
                                             session);
}

void
grd_session_start (GrdSession *session)
{
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);
  GrdDBusRemoteDesktop *remote_desktop_proxy;

priv->cancellable = g_cancellable_new ();

remote_desktop_proxy = grd_context_get_remote_desktop_proxy (priv->context);
  grd_dbus_remote_desktop_call_create_session (remote_desktop_proxy,
                                               priv->cancellable,
                                               on_remote_desktop_session_created,
                                               session);
}

static void
grd_session_dispose (GObject *object)
{
  GrdSession *session = GRD_SESSION (object);
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);

g_clear_object (&priv->stream);

G_OBJECT_CLASS (grd_session_parent_class)->dispose (object);
}

static void
grd_session_finalize (GObject *object)
{
  GrdSession *session = GRD_SESSION (object);
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);

g_assert (!priv->remote_desktop_session);

if (priv->cancellable)
    g_cancellable_cancel (priv->cancellable);
  g_clear_object (&priv->cancellable);

G_OBJECT_CLASS (grd_session_parent_class)->finalize (object);
}

static void
grd_session_set_property (GObject      *object,
                          guint         prop_id,
                          const GValue *value,
                          GParamSpec   *pspec)
{
  GrdSession *session = GRD_SESSION (object);
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);

switch (prop_id)
    {
    case PROP_CONTEXT:
      priv->context = g_value_get_object (value);
      break;

default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
grd_session_get_property (GObject    *object,
                          guint       prop_id,
                          GValue     *value,
                          GParamSpec *pspec)
{
  GrdSession *session = GRD_SESSION (object);
  GrdSessionPrivate *priv = grd_session_get_instance_private (session);

switch (prop_id)
    {
    case PROP_CONTEXT:
      g_value_set_object (value, priv->context);

default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
grd_session_init (GrdSession *session)
{
}

static void
grd_session_class_init (GrdSessionClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->dispose = grd_session_dispose;
  object_class->finalize = grd_session_finalize;
  object_class->set_property = grd_session_set_property;
  object_class->get_property = grd_session_get_property;

signals[STOPPED] = g_signal_new ("stopped",
                                   G_TYPE_FROM_CLASS (klass),
                                   G_SIGNAL_RUN_LAST,
                                   0,
                                   NULL, NULL, NULL,
                                   G_TYPE_NONE, 0);
}
07070100000032000081A40000000000000000000000016141EE1000001037000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/src/grd-session.h/*
 * Copyright (C) 2015 Red Hat Inc.
 * Copyright (C) 2020 Pascal Nowack
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#ifndef GRD_SESSION_H
#define GRD_SESSION_H

#include <glib-object.h>
#include <stdint.h>

#include "grd-mime-type.h"
#include "grd-types.h"

#define GRD_TYPE_SESSION (grd_session_get_type ())
G_DECLARE_DERIVABLE_TYPE (GrdSession, grd_session, GRD, SESSION, GObject);

typedef enum _GrdKeyState
{
  GRD_KEY_STATE_RELEASED,
  GRD_KEY_STATE_PRESSED
} GrdKeyState;

typedef enum _GrdButtonState
{
  GRD_BUTTON_STATE_RELEASED,
  GRD_BUTTON_STATE_PRESSED
} GrdButtonState;

typedef enum _GrdPointerAxisFlags
{
  GRD_POINTER_AXIS_FLAGS_FINISH = 1 << 0,
  GRD_POINTER_AXIS_FLAGS_SOURCE_WHEEL = 1 << 1,
  GRD_POINTER_AXIS_FLAGS_SOURCE_FINGER = 1 << 2,
  GRD_POINTER_AXIS_FLAGS_SOURCE_CONTINUOUS = 1 << 3,
} GrdPointerAxisFlags;

typedef enum _GrdPointerAxis
{
  GRD_POINTER_AXIS_VERTICAL,
  GRD_POINTER_AXIS_HORIZONTAL
} GrdPointerAxis;

struct _GrdSessionClass
{
  GObjectClass parent_class;

void (*remote_desktop_session_ready) (GrdSession *session);
  void (*stream_ready) (GrdSession *session,
                        GrdStream  *stream);
  void (*stop) (GrdSession *session);

void (*on_caps_lock_state_changed) (GrdSession *session,
                                      gboolean    state);
  void (*on_num_lock_state_changed) (GrdSession *session,
                                     gboolean    state);
};

GrdContext *grd_session_get_context (GrdSession *session);

void grd_session_notify_keyboard_keycode (GrdSession  *session,
                                          uint32_t     keycode,
                                          GrdKeyState  state);

void grd_session_notify_keyboard_keysym (GrdSession  *session,
                                         uint32_t     keysym,
                                         GrdKeyState  state);

void grd_session_notify_pointer_button (GrdSession     *session,
                                        int32_t         button,
                                        GrdButtonState  state);

void grd_session_notify_pointer_axis (GrdSession          *session,
                                      double               dx,
                                      double               dy,
                                      GrdPointerAxisFlags  flags);

void grd_session_notify_pointer_axis_discrete (GrdSession     *session,
                                               GrdPointerAxis  axis,
                                               int             steps);

void grd_session_notify_pointer_motion_absolute (GrdSession *session,
                                                 double      x,
                                                 double      y);

gboolean grd_session_enable_clipboard (GrdSession   *session,
                                       GrdClipboard *clipboard,
                                       GList        *mime_type_tables);

void grd_session_disable_clipboard (GrdSession *session);

void grd_session_set_selection (GrdSession *session,
                                GList      *mime_type_tables);

uint8_t *grd_session_selection_read (GrdSession  *session,
                                     GrdMimeType  mime_type,
                                     uint32_t    *size);

void grd_session_start (GrdSession *session);

void grd_session_stop (GrdSession *session);

#endif /* GRD_SESSION_H */
07070100000033000081A40000000000000000000000016141EE1000002951000000000000000000000000000000000000002D00000000gnome-remote-desktop-40.2/src/grd-settings.c/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#include "config.h"

#include "grd-settings.h"

#include <gio/gio.h>
#include <string.h>

#define GRD_RDP_SCHEMA_ID "org.gnome.desktop.remote-desktop.rdp"
#define GRD_VNC_SCHEMA_ID "org.gnome.desktop.remote-desktop.vnc"
#define GRD_RDP_SERVER_PORT 3389
#define GRD_VNC_SERVER_PORT 5900

enum
{
  RDP_SERVER_CERT_CHANGED,
  RDP_SERVER_KEY_CHANGED,
  RDP_VIEW_ONLY_CHANGED,
  VNC_VIEW_ONLY_CHANGED,
  VNC_AUTH_METHOD_CHANGED,
  VNC_ENCRYPTION_CHANGED,

N_SIGNALS
};

static guint signals[N_SIGNALS];

struct _GrdSettings
{
  GObject parent;

struct {
    GSettings *settings;
    char *server_cert;
    char *server_key;
    gboolean view_only;
    int port;
  } rdp;
  struct {
    GSettings *settings;
    gboolean view_only;
    GrdVncAuthMethod auth_method;
    int port;
  } vnc;
};

G_DEFINE_TYPE (GrdSettings, grd_settings, G_TYPE_OBJECT)

const SecretSchema *
grd_rdp_credentials_get_schema (void)
{
  static const SecretSchema grd_rdp_credentials_schema = {
    .name = "org.gnome.RemoteDesktop.RdpCredentials",
    .flags = SECRET_SCHEMA_NONE,
    .attributes = {
      { "credentials", SECRET_SCHEMA_ATTRIBUTE_STRING },
      { "NULL", 0 },
    },
  };

return &grd_rdp_credentials_schema;
}

const SecretSchema *
grd_vnc_password_get_schema (void)
{
  static const SecretSchema grd_vnc_password_schema = {
    .name = "org.gnome.RemoteDesktop.VncPassword",
    .flags = SECRET_SCHEMA_NONE,
    .attributes = {
      { "password", SECRET_SCHEMA_ATTRIBUTE_STRING },
      { "NULL", 0 },
    },
  };

return &grd_vnc_password_schema;
}

int
grd_settings_get_rdp_port (GrdSettings *settings)
{
  return settings->rdp.port;
}

int
grd_settings_get_vnc_port (GrdSettings *settings)
{
  return settings->vnc.port;
}

void
grd_settings_override_rdp_port (GrdSettings *settings,
                                int          port)
{
  settings->rdp.port = port;
}

void
grd_settings_override_vnc_port (GrdSettings *settings,
                                int          port)
{
  settings->vnc.port = port;
}

char *
grd_settings_get_rdp_server_cert (GrdSettings *settings)
{
  return settings->rdp.server_cert;
}

char *
grd_settings_get_rdp_server_key (GrdSettings *settings)
{
  return settings->rdp.server_key;
}

char *
grd_settings_get_rdp_username (GrdSettings  *settings,
                               GError      **error)
{
  const char *test_password_override;
  GVariant *credentials;
  char *credentials_string;
  char *username = NULL;

test_password_override = g_getenv ("GNOME_REMOTE_DESKTOP_TEST_RDP_PASSWORD");
  if (test_password_override)
    return g_strdup ("TEST");

credentials_string = secret_password_lookup_sync (GRD_RDP_CREDENTIALS_SCHEMA,
                                                    NULL, error,
                                                    NULL);
  if (!credentials_string)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
                   "Credentials not set");
      return NULL;
    }

credentials = g_variant_parse (NULL, credentials_string, NULL, NULL, NULL);
  g_variant_lookup (credentials, "username", "s", &username);

g_variant_unref (credentials);
  g_free (credentials_string);

return username;
}

char *
grd_settings_get_rdp_password (GrdSettings  *settings,
                               GError      **error)
{
  const char *test_password_override;
  GVariant *credentials;
  char *credentials_string;
  char *password = NULL;

test_password_override = g_getenv ("GNOME_REMOTE_DESKTOP_TEST_RDP_PASSWORD");
  if (test_password_override)
    return g_strdup (test_password_override);

credentials = g_variant_parse (NULL, credentials_string, NULL, NULL, NULL);
  g_variant_lookup (credentials, "password", "s", &password);

g_variant_unref (credentials);
  g_free (credentials_string);

return password;
}

char *
grd_settings_get_vnc_password (GrdSettings  *settings,
                               GError      **error)
{
  const char *test_password_override;
  char *password;

test_password_override = g_getenv ("GNOME_REMOTE_DESKTOP_TEST_VNC_PASSWORD");
  if (test_password_override)
    return g_strdup (test_password_override);

password = secret_password_lookup_sync (GRD_VNC_PASSWORD_SCHEMA,
                                          NULL, error,
                                          NULL);
  if (!password)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
                   "Password not set");
      return NULL;
    }

return password;
}

gboolean
grd_settings_get_rdp_view_only (GrdSettings *settings)
{
  return settings->rdp.view_only;
}

gboolean
grd_settings_get_vnc_view_only (GrdSettings *settings)
{
  return settings->vnc.view_only;
}

GrdVncAuthMethod
grd_settings_get_vnc_auth_method (GrdSettings *settings)
{
  if (g_getenv ("GNOME_REMOTE_DESKTOP_TEST_VNC_PASSWORD"))
    return GRD_VNC_AUTH_METHOD_PASSWORD;
  else
    return settings->vnc.auth_method;
}

static void
update_rdp_tls_cert (GrdSettings *settings)
{
  settings->rdp.server_cert = g_settings_get_string (settings->rdp.settings,
                                                     "tls-cert");
}

static void
update_rdp_tls_key (GrdSettings *settings)
{
  settings->rdp.server_key = g_settings_get_string (settings->rdp.settings,
                                                    "tls-key");
}

static void
update_rdp_view_only (GrdSettings *settings)
{
  settings->rdp.view_only = g_settings_get_boolean (settings->rdp.settings,
                                                    "view-only");
}

static void
update_vnc_view_only (GrdSettings *settings)
{
  settings->vnc.view_only = g_settings_get_boolean (settings->vnc.settings,
                                                    "view-only");
}

static void
update_vnc_auth_method (GrdSettings *settings)
{
  settings->vnc.auth_method = g_settings_get_enum (settings->vnc.settings,
                                                   "auth-method");
}

static void
on_rdp_settings_changed (GSettings   *rdp_settings,
                         const char  *key,
                         GrdSettings *settings)
{
  if (strcmp (key, "tls-cert") == 0)
    {
      update_rdp_tls_cert (settings);
      g_signal_emit (settings, signals[RDP_SERVER_CERT_CHANGED], 0);
    }
  else if (strcmp (key, "tls-key") == 0)
    {
      update_rdp_tls_key (settings);
      g_signal_emit (settings, signals[RDP_SERVER_KEY_CHANGED], 0);
    }
  else if (strcmp (key, "view-only") == 0)
    {
      update_rdp_view_only (settings);
      g_signal_emit (settings, signals[RDP_VIEW_ONLY_CHANGED], 0);
    }
}

static void
on_vnc_settings_changed (GSettings   *vnc_settings,
                         const char  *key,
                         GrdSettings *settings)
{
  if (strcmp (key, "view-only") == 0)
    {
      update_vnc_view_only (settings);
      g_signal_emit (settings, signals[VNC_VIEW_ONLY_CHANGED], 0);
    }
  else if (strcmp (key, "auth-method") == 0)
    {
      update_vnc_auth_method (settings);
      g_signal_emit (settings, signals[VNC_AUTH_METHOD_CHANGED], 0);
    }
}

static void
grd_settings_finalize (GObject *object)
{
  GrdSettings *settings = GRD_SETTINGS (object);

g_clear_object (&settings->rdp.settings);
  g_clear_object (&settings->vnc.settings);

G_OBJECT_CLASS (grd_settings_parent_class)->finalize (object);
}

static void
grd_settings_init (GrdSettings *settings)
{
  settings->rdp.settings = g_settings_new (GRD_RDP_SCHEMA_ID);
  settings->vnc.settings = g_settings_new (GRD_VNC_SCHEMA_ID);
  g_signal_connect (settings->rdp.settings, "changed",
                    G_CALLBACK (on_rdp_settings_changed), settings);
  g_signal_connect (settings->vnc.settings, "changed",
                    G_CALLBACK (on_vnc_settings_changed), settings);

update_rdp_tls_cert (settings);
  update_rdp_tls_key (settings);
  update_rdp_view_only (settings);
  update_vnc_view_only (settings);
  update_vnc_auth_method (settings);

settings->rdp.port = GRD_RDP_SERVER_PORT;
  settings->vnc.port = GRD_VNC_SERVER_PORT;
}

static void
grd_settings_class_init (GrdSettingsClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->finalize = grd_settings_finalize;

signals[RDP_SERVER_CERT_CHANGED] =
    g_signal_new ("rdp-tls-cert-changed",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 0);
  signals[RDP_SERVER_KEY_CHANGED] =
    g_signal_new ("rdp-tls-key-changed",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 0);
  signals[RDP_VIEW_ONLY_CHANGED] =
    g_signal_new ("rdp-view-only-changed",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 0);
  signals[VNC_VIEW_ONLY_CHANGED] =
    g_signal_new ("vnc-view-only-changed",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 0);
  signals[VNC_AUTH_METHOD_CHANGED] =
    g_signal_new ("vnc-auth-method-changed",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 0);
}
07070100000034000081A40000000000000000000000016141EE100000094E000000000000000000000000000000000000002D00000000gnome-remote-desktop-40.2/src/grd-settings.h/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#ifndef GRD_SETTINGS_H
#define GRD_SETTINGS_H

#include <glib-object.h>
#include <libsecret/secret.h>

#include "grd-enums.h"

#define GRD_TYPE_SETTINGS (grd_settings_get_type ())
G_DECLARE_FINAL_TYPE (GrdSettings, grd_settings,
                      GRD, SETTINGS, GObject)

const SecretSchema * cc_grd_rdp_credentials_get_schema (void);
const SecretSchema * cc_grd_vnc_password_get_schema (void);
#define GRD_RDP_CREDENTIALS_SCHEMA grd_rdp_credentials_get_schema ()
#define GRD_VNC_PASSWORD_SCHEMA grd_vnc_password_get_schema ()

int grd_settings_get_rdp_port (GrdSettings *settings);

int grd_settings_get_vnc_port (GrdSettings *settings);

void grd_settings_override_rdp_port (GrdSettings *settings,
                                     int          port);

void grd_settings_override_vnc_port (GrdSettings *settings,
                                     int          port);

char * grd_settings_get_rdp_server_cert (GrdSettings *settings);

char * grd_settings_get_rdp_server_key (GrdSettings *settings);

char * grd_settings_get_rdp_password (GrdSettings  *settings,
                                      GError      **error);

char * grd_settings_get_vnc_password (GrdSettings  *settings,
                                      GError      **error);

char * grd_settings_get_rdp_username (GrdSettings  *settings,
                                      GError      **error);

gboolean grd_settings_get_rdp_view_only (GrdSettings *settings);

gboolean grd_settings_get_vnc_view_only (GrdSettings *settings);

GrdVncAuthMethod grd_settings_get_vnc_auth_method (GrdSettings *settings);

#endif /* GRD_SETTINGS_H */
07070100000035000081A40000000000000000000000016141EE1000000D49000000000000000000000000000000000000002B00000000gnome-remote-desktop-40.2/src/grd-stream.c/*
 * Copyright (C) 2017 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#include "config.h"

#include "grd-stream.h"

#include "grd-context.h"

enum
{
  READY,
  CLOSED,

N_SIGNALS
};

static guint signals[N_SIGNALS];

typedef struct _GrdStreamPrivate
{
  GrdContext *context;

uint32_t pipewire_node_id;

GrdDBusScreenCastStream *proxy;
} GrdStreamPrivate;

G_DEFINE_TYPE_WITH_PRIVATE (GrdStream, grd_stream, G_TYPE_OBJECT)

uint32_t
grd_stream_get_pipewire_node_id (GrdStream *stream)
{
  GrdStreamPrivate *priv = grd_stream_get_instance_private (stream);

return priv->pipewire_node_id;
}

const char *
grd_stream_get_object_path (GrdStream *stream)
{
  GrdStreamPrivate *priv = grd_stream_get_instance_private (stream);

return g_dbus_proxy_get_object_path (G_DBUS_PROXY (priv->proxy));
}

static void
on_pipewire_stream_added (GrdDBusScreenCastStream *proxy,
                          unsigned int             node_id,
                          GrdStream               *stream)
{
  GrdStreamPrivate *priv = grd_stream_get_instance_private (stream);

priv->pipewire_node_id = (uint32_t) node_id;

g_signal_emit (stream, signals[READY], 0);
}

GrdStream *
grd_stream_new (GrdContext              *context,
                GrdDBusScreenCastStream *proxy)
{
  GrdStream *stream;
  GrdStreamPrivate *priv;

stream = g_object_new (GRD_TYPE_STREAM, NULL);
  priv = grd_stream_get_instance_private (stream);

priv->context = context;
  priv->proxy = proxy;
  g_signal_connect (proxy, "pipewire-stream-added",
                    G_CALLBACK (on_pipewire_stream_added),
                    stream);

return stream;
}

static void
grd_stream_finalize (GObject *object)
{
  GrdStream *stream = GRD_STREAM (object);
  GrdStreamPrivate *priv = grd_stream_get_instance_private (stream);

g_clear_object (&priv->proxy);

G_OBJECT_CLASS (grd_stream_parent_class)->finalize (object);
}

static void
grd_stream_init (GrdStream *stream)
{
}

static void
grd_stream_class_init (GrdStreamClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->finalize = grd_stream_finalize;

signals[READY] = g_signal_new ("ready",
                                 G_TYPE_FROM_CLASS (klass),
                                 G_SIGNAL_RUN_LAST,
                                 0,
                                 NULL, NULL, NULL,
                                 G_TYPE_NONE, 0);
  signals[CLOSED] = g_signal_new ("closed",
                                  G_TYPE_FROM_CLASS (klass),
                                  G_SIGNAL_RUN_LAST,
                                  0,
                                  NULL, NULL, NULL,
                                  G_TYPE_NONE, 0);
}
07070100000036000081A40000000000000000000000016141EE1000000557000000000000000000000000000000000000002B00000000gnome-remote-desktop-40.2/src/grd-stream.h/*
 * Copyright (C) 2017 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#ifndef GRD_STREAM_H
#define GRD_STREAM_H

#include <glib-object.h>
#include <stdint.h>

#include "grd-dbus-screen-cast.h"
#include "grd-types.h"

#define GRD_TYPE_STREAM (grd_stream_get_type ())
G_DECLARE_DERIVABLE_TYPE (GrdStream, grd_stream, GRD, STREAM, GObject)

struct _GrdStreamClass
{
  GObjectClass parent_class;
};

uint32_t grd_stream_get_pipewire_node_id (GrdStream *stream);

const char * grd_stream_get_object_path (GrdStream *stream);

GrdStream * grd_stream_new (GrdContext              *context,
                            GrdDBusScreenCastStream *proxy);

#endif /* GRD_STREAM_H */
07070100000037000081A40000000000000000000000016141EE100000064E000000000000000000000000000000000000002A00000000gnome-remote-desktop-40.2/src/grd-types.h/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#ifndef GRD_TYPES_H
#define GRD_TYPES_H

typedef struct _GrdContext GrdContext;
typedef struct _GrdClipboard GrdClipboard;
typedef struct _GrdClipboardRdp GrdClipboardRdp;
typedef struct _GrdClipboardVnc GrdClipboardVnc;
typedef struct _GrdRdpEventQueue GrdRdpEventQueue;
typedef struct _GrdRdpSAMFile GrdRdpSAMFile;
typedef struct _GrdRdpServer GrdRdpServer;
typedef struct _GrdSession GrdSession;
typedef struct _GrdSessionRdp GrdSessionRdp;
typedef struct _GrdSessionVnc GrdSessionVnc;
typedef struct _GrdStream GrdStream;
typedef struct _GrdPipeWireStream GrdPipeWireStream;
typedef struct _GrdPipeWireStreamMonitor GrdPipeWireStreamMonitor;
typedef struct _GrdVncServer GrdVncServer;

typedef enum _GrdPixelFormat
{
  GRD_PIXEL_FORMAT_RGBA8888,
} GrdPixelFormat;

#endif /* GRD_TYPES_H */
07070100000038000081A40000000000000000000000016141EE1000000C6C000000000000000000000000000000000000002F00000000gnome-remote-desktop-40.2/src/grd-vnc-cursor.c/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#include "config.h"

#include "grd-vnc-cursor.h"

#include <glib.h>
#include <stdint.h>

static void
get_pixel_components (uint32_t        pixel,
                      GrdPixelFormat  format,
                      uint8_t        *a,
                      uint8_t        *r,
                      uint8_t        *g,
                      uint8_t        *b)
{
  g_assert (format == GRD_PIXEL_FORMAT_RGBA8888);

*a = (pixel & 0xff000000) >> 24;
  *b = (pixel & 0xff0000) >> 16;
  *g = (pixel & 0xff00) >> 8;
  *r = pixel & 0xff;
}

static gboolean
is_practically_black (uint8_t r,
                      uint8_t g,
                      uint8_t b)
{
  if (r <= 0x62 &&
      g <= 0x62 &&
      b <= 0x62)
    return TRUE;
  else
    return FALSE;
}

static gboolean
is_practically_opaque (uint8_t a)
{
  return a > 0xe0;
}

rfbCursorPtr
grd_vnc_create_cursor (int             width,
                       int             height,
                       int             stride,
                       GrdPixelFormat  format,
                       uint8_t        *buf)
{
  g_autofree char *cursor = NULL;
  g_autofree char *mask = NULL;
  int y;

g_return_val_if_fail (format == GRD_PIXEL_FORMAT_RGBA8888, NULL);

cursor = g_new0 (char, width * height);
  mask = g_new0 (char, width * height);

for (y = 0; y < height; y++)
    {
      uint32_t *pixel_row;
      int x;

pixel_row = (uint32_t *) &buf[y * stride];

for (x = 0; x < width; x++)
        {
          uint32_t pixel = pixel_row[x];
          uint8_t a, r, g, b;

get_pixel_components (pixel,
                                format,
                                &a, &r, &g, &b);

if (is_practically_opaque (a))
            {
              if (is_practically_black (r, g, b))
                cursor[y * width + x] = ' ';
              else
                cursor[y * width + x] = 'x';

mask[y * width + x] = 'x';
            }
          else
            {
              cursor[y * width + x] = ' ';
              mask[y * width + x] = ' ';
            }
        }
    }

return rfbMakeXCursor (width, height, cursor, mask);
}

rfbCursorPtr
grd_vnc_create_empty_cursor (int width,
                             int height)
{
  g_autofree char *cursor = NULL;
  cursor = g_new0 (char, width * height);

memset (cursor, ' ', width * height);

return rfbMakeXCursor (width, height, cursor, cursor);
}
07070100000039000081A40000000000000000000000016141EE1000000514000000000000000000000000000000000000002F00000000gnome-remote-desktop-40.2/src/grd-vnc-cursor.h/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#ifndef GRD_VNC_CURSOR_H
#define GRD_VNC_CURSOR_H

#include <rfb/rfb.h>

#include "grd-types.h"

rfbCursorPtr grd_vnc_create_cursor (int             width,
                                    int             height,
                                    int             stride,
                                    GrdPixelFormat  format,
                                    uint8_t        *buf);

rfbCursorPtr grd_vnc_create_empty_cursor (int width,
                                          int height);

#endif /* GRD_VNC_CURSOR_H */
0707010000003A000081A40000000000000000000000016141EE1000004806000000000000000000000000000000000000003800000000gnome-remote-desktop-40.2/src/grd-vnc-pipewire-stream.c/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#include "config.h"

#include "grd-vnc-pipewire-stream.h"

#include "grd-pipewire-utils.h"
#include "grd-vnc-cursor.h"

enum
{
  CLOSED,

N_SIGNALS
};

static guint signals[N_SIGNALS];

typedef struct _GrdVncFrame
{
  void *data;
  rfbCursorPtr rfb_cursor;
  gboolean cursor_moved;
  int cursor_x;
  int cursor_y;
} GrdVncFrame;

struct _GrdVncPipeWireStream
{
  GObject parent;

GrdSessionVnc *session;

GSource *pipewire_source;
  struct pw_context *pipewire_context;
  struct pw_core *pipewire_core;

struct spa_hook pipewire_core_listener;

GMutex frame_mutex;
  GrdVncFrame *pending_frame;

struct pw_stream *pipewire_stream;
  struct spa_hook pipewire_stream_listener;

uint32_t src_node_id;

struct spa_video_info_raw spa_format;
};

G_DEFINE_TYPE (GrdVncPipeWireStream, grd_vnc_pipewire_stream,
               G_TYPE_OBJECT)

static gboolean
pipewire_loop_source_prepare (GSource *base,
                              int     *timeout)
{
  *timeout = -1;
  return FALSE;
}

result = pw_loop_iterate (pipewire_source->pipewire_loop, 0);
  if (result < 0)
    g_warning ("pipewire_loop_iterate failed: %s", spa_strerror (result));

return TRUE;
}

static void
pipewire_loop_source_finalize (GSource *source)
{
  GrdPipeWireSource *pipewire_source = (GrdPipeWireSource *) source;

pw_loop_leave (pipewire_source->pipewire_loop);
  pw_loop_destroy (pipewire_source->pipewire_loop);
}

static GSourceFuncs pipewire_source_funcs =
{
  pipewire_loop_source_prepare,
  NULL,
  pipewire_loop_source_dispatch,
  pipewire_loop_source_finalize
};

static GrdPipeWireSource *
create_pipewire_source (void)
{
  GrdPipeWireSource *pipewire_source;

g_source_add_unix_fd (&pipewire_source->base,
                        pw_loop_get_fd (pipewire_source->pipewire_loop),
                        G_IO_IN | G_IO_ERR);

pw_loop_enter (pipewire_source->pipewire_loop);
  g_source_attach (&pipewire_source->base, NULL);

return pipewire_source;
}

static void
on_stream_state_changed (void                 *user_data,
                         enum pw_stream_state  old,
                         enum pw_stream_state  state,
                         const char           *error)
{
  g_debug ("Pipewire stream state changed from %s to %s",
           pw_stream_state_as_string (old),
           pw_stream_state_as_string (state));

static void
on_stream_param_changed (void                 *user_data,
                         uint32_t              id,
                         const struct spa_pod *format)
{
  GrdVncPipeWireStream *stream = GRD_VNC_PIPEWIRE_STREAM (user_data);
  uint8_t params_buffer[1024];
  struct spa_pod_builder pod_builder;
  int width;
  int height;
  const struct spa_pod *params[3];

if (!format || id != SPA_PARAM_Format)
    return;

spa_format_video_raw_parse (format, &stream->spa_format);

pod_builder = SPA_POD_BUILDER_INIT (params_buffer, sizeof (params_buffer));

width = stream->spa_format.size.width;
  height = stream->spa_format.size.height;

grd_session_vnc_queue_resize_framebuffer (stream->session, width, height);

params[0] = spa_pod_builder_add_object (
    &pod_builder,
    SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
    SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int (8, 1, 8),
    0);

params[2] = spa_pod_builder_add_object(
    &pod_builder,
    SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
    SPA_PARAM_META_type, SPA_POD_Id (SPA_META_Cursor),
    SPA_PARAM_META_size, SPA_POD_CHOICE_RANGE_Int (CURSOR_META_SIZE (384, 384),
                                                   CURSOR_META_SIZE (1,1),
                                                   CURSOR_META_SIZE (384, 384)),
    0);

pw_stream_update_params (stream->pipewire_stream,
                           params, G_N_ELEMENTS (params));
}

static int
do_render (struct spa_loop *loop,
           bool             async,
           uint32_t         seq,
           const void      *data,
           size_t           size,
           void            *user_data)
{
  GrdVncPipeWireStream *stream = GRD_VNC_PIPEWIRE_STREAM (user_data);
  GrdVncFrame *frame;

g_mutex_lock (&stream->frame_mutex);
  frame = g_steal_pointer (&stream->pending_frame);
  g_mutex_unlock (&stream->frame_mutex);

if (!frame)
    return 0;

if (grd_session_vnc_is_client_gone (stream->session))
    {
      g_free (frame->data);
      g_clear_pointer (&frame->rfb_cursor, rfbFreeCursor);
      g_free (frame);
      return 0;
    }

if (frame->rfb_cursor)
    grd_session_vnc_set_cursor (stream->session, frame->rfb_cursor);

if (frame->cursor_moved)
    {
      grd_session_vnc_move_cursor (stream->session,
                                   frame->cursor_x,
                                   frame->cursor_y);
    }

if (frame->data)
    grd_session_vnc_take_buffer (stream->session, frame->data);
  else
    grd_session_vnc_flush (stream->session);

g_free (frame);

return 0;
}

static GrdVncFrame *
process_buffer (GrdVncPipeWireStream *stream,
                struct spa_buffer    *buffer)
{
  size_t size;
  uint8_t *map;
  void *src_data;
  struct spa_meta_cursor *spa_meta_cursor;
  g_autofree GrdVncFrame *frame = NULL;

frame = g_new0 (GrdVncFrame, 1);

fd = buffer->datas[0].fd;
      size = buffer->datas[0].maxsize + buffer->datas[0].mapoffset;

if (src_data)
    {
      int src_stride;
      int dst_stride;
      int width;
      int height;
      int y;

height = stream->spa_format.size.height;
      width = stream->spa_format.size.width;
      src_stride = buffer->datas[0].chunk->stride;
      dst_stride = grd_session_vnc_get_stride_for_width (stream->session,
                                                         width);

frame->data = g_malloc (height * dst_stride);
      for (y = 0; y < height; y++)
        {
          memcpy (((uint8_t *) frame->data) + y * dst_stride,
                  ((uint8_t *) src_data) + y * src_stride,
                  width * 4);
        }
    }

if (map)
    {
      if (buffer->datas[0].type == SPA_DATA_DmaBuf)
        grd_sync_dma_buf (buffer->datas[0].fd, DMA_BUF_SYNC_END);
      munmap (map, size);
    }

if (spa_meta_cursor->bitmap_offset)
        {
          spa_meta_bitmap = SPA_MEMBER (spa_meta_cursor,
                                        spa_meta_cursor->bitmap_offset,
                                        struct spa_meta_bitmap);
        }
      else
        {
          spa_meta_bitmap = NULL;
        }

buf = SPA_MEMBER (spa_meta_bitmap, spa_meta_bitmap->offset, uint8_t);
          rfb_cursor = grd_vnc_create_cursor (spa_meta_bitmap->size.width,
                                              spa_meta_bitmap->size.height,
                                              spa_meta_bitmap->stride,
                                              format,
                                              buf);
          rfb_cursor->xhot = spa_meta_cursor->hotspot.x;
          rfb_cursor->yhot = spa_meta_cursor->hotspot.y;

frame->rfb_cursor = rfb_cursor;
        }
      else if (spa_meta_bitmap)
        {
          frame->rfb_cursor = grd_vnc_create_empty_cursor (1, 1);
        }

frame->cursor_moved = TRUE;
      frame->cursor_x = spa_meta_cursor->position.x;
      frame->cursor_y = spa_meta_cursor->position.y;
    }

return g_steal_pointer (&frame);
}

static void
on_stream_process (void *user_data)
{
  GrdVncPipeWireStream *stream = GRD_VNC_PIPEWIRE_STREAM (user_data);
  GrdPipeWireSource *pipewire_source =
    (GrdPipeWireSource *) stream->pipewire_source;
  struct pw_buffer *next_buffer;
  struct pw_buffer *buffer = NULL;
  GrdVncFrame *frame;

next_buffer = pw_stream_dequeue_buffer (stream->pipewire_stream);
  while (next_buffer)
    {
      buffer = next_buffer;
      next_buffer = pw_stream_dequeue_buffer (stream->pipewire_stream);

if (next_buffer)
        pw_stream_queue_buffer (stream->pipewire_stream, buffer);
    }
  if (!buffer)
    return;

frame = process_buffer (stream, buffer->buffer);

g_assert (frame);
  g_mutex_lock (&stream->frame_mutex);
  if (stream->pending_frame)
    {
      g_free (stream->pending_frame->data);
      g_clear_pointer (&stream->pending_frame, g_free);
    }
  stream->pending_frame = frame;
  g_mutex_unlock (&stream->frame_mutex);

pw_stream_queue_buffer (stream->pipewire_stream, buffer);

pw_loop_invoke (pipewire_source->pipewire_loop, do_render,
                  SPA_ID_INVALID, NULL, 0,
                  false, stream);
}

static gboolean
connect_to_stream (GrdVncPipeWireStream  *stream,
                   GError               **error)
{
  struct pw_stream *pipewire_stream;
  uint8_t params_buffer[1024];
  struct spa_pod_builder pod_builder;
  struct spa_rectangle min_rect;
  struct spa_rectangle max_rect;
  struct spa_fraction min_framerate;
  struct spa_fraction max_framerate;
  const struct spa_pod *params[2];
  int ret;

pipewire_stream = pw_stream_new (stream->pipewire_core,
                                   "grd-vnc-pipewire-stream",
                                   NULL);

min_rect = SPA_RECTANGLE (1, 1);
  max_rect = SPA_RECTANGLE (INT32_MAX, INT32_MAX);
  min_framerate = SPA_FRACTION (1, 1);
  max_framerate = SPA_FRACTION (30, 1);

pod_builder = SPA_POD_BUILDER_INIT (params_buffer, sizeof (params_buffer));
  params[0] = spa_pod_builder_add_object (
    &pod_builder,
    SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
    SPA_FORMAT_mediaType, SPA_POD_Id (SPA_MEDIA_TYPE_video),
    SPA_FORMAT_mediaSubtype, SPA_POD_Id (SPA_MEDIA_SUBTYPE_raw),
    SPA_FORMAT_VIDEO_format, SPA_POD_Id (SPA_VIDEO_FORMAT_BGRx),
    SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle (&min_rect,
                                                           &min_rect,
                                                           &max_rect),
    SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction (&SPA_FRACTION(0, 1)),
    SPA_FORMAT_VIDEO_maxFramerate, SPA_POD_CHOICE_RANGE_Fraction (&min_framerate,
                                                                  &min_framerate,
                                                                  &max_framerate),
    0);

stream->pipewire_stream = pipewire_stream;

pw_stream_add_listener (pipewire_stream,
                          &stream->pipewire_stream_listener,
                          &stream_events,
                          stream);

return TRUE;
}

static void
on_core_error (void       *user_data,
               uint32_t    id,
               int         seq,
               int         res,
               const char *message)
{
  GrdVncPipeWireStream *stream = GRD_VNC_PIPEWIRE_STREAM (user_data);

g_warning ("Pipewire core error: id:%u %s", id, message);

if (id == PW_ID_CORE && res == -EPIPE)
    g_signal_emit (stream, signals[CLOSED], 0);
}

static const struct pw_core_events core_events = {
  PW_VERSION_CORE_EVENTS,
  .error = on_core_error,
};

GrdVncPipeWireStream *
grd_vnc_pipewire_stream_new (GrdSessionVnc  *session_vnc,
                             uint32_t        src_node_id,
                             GError        **error)
{
  g_autoptr (GrdVncPipeWireStream) stream = NULL;
  GrdPipeWireSource *pipewire_source;

grd_maybe_initialize_pipewire ();

stream = g_object_new (GRD_TYPE_VNC_PIPEWIRE_STREAM, NULL);
  stream->session = session_vnc;
  stream->src_node_id = src_node_id;

pw_core_add_listener (stream->pipewire_core,
                        &stream->pipewire_core_listener,
                        &core_events,
                        stream);

if (!connect_to_stream (stream, error))
    return NULL;

return g_steal_pointer (&stream);
}

static void
grd_vnc_pipewire_stream_finalize (GObject *object)
{
  GrdVncPipeWireStream *stream = GRD_VNC_PIPEWIRE_STREAM (object);

G_OBJECT_CLASS (grd_vnc_pipewire_stream_parent_class)->finalize (object);
}

static void
grd_vnc_pipewire_stream_init (GrdVncPipeWireStream *stream)
{
  g_mutex_init (&stream->frame_mutex);
}

static void
grd_vnc_pipewire_stream_class_init (GrdVncPipeWireStreamClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->finalize = grd_vnc_pipewire_stream_finalize;

signals[CLOSED] = g_signal_new ("closed",
                                  G_TYPE_FROM_CLASS (klass),
                                  G_SIGNAL_RUN_LAST,
                                  0,
                                  NULL, NULL, NULL,
                                  G_TYPE_NONE, 0);
}
0707010000003B000081A40000000000000000000000016141EE1000000583000000000000000000000000000000000000003800000000gnome-remote-desktop-40.2/src/grd-vnc-pipewire-stream.h/*
 * Copyright (C) 2018 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#ifndef GRD_VNC_PIPEWIRE_STREAM_H
#define GRD_VNC_PIPEWIRE_STREAM_H

#include <glib-object.h>
#include <stdint.h>

#include "grd-session-vnc.h"

#define GRD_TYPE_VNC_PIPEWIRE_STREAM grd_vnc_pipewire_stream_get_type ()
G_DECLARE_FINAL_TYPE (GrdVncPipeWireStream, grd_vnc_pipewire_stream,
                      GRD, VNC_PIPEWIRE_STREAM,
                      GObject)

GrdVncPipeWireStream * grd_vnc_pipewire_stream_new (GrdSessionVnc  *session_vnc,
                                                    uint32_t        src_node_id,
                                                    GError        **error);

#endif /* GRD_VNC_PIPEWIRE_STREAM_H */
0707010000003C000081A40000000000000000000000016141EE1000001AAC000000000000000000000000000000000000002F00000000gnome-remote-desktop-40.2/src/grd-vnc-server.c/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#include "config.h"

#include "grd-vnc-server.h"

#include <gio/gio.h>
#include <rfb/rfb.h>

#include "grd-context.h"
#include "grd-session-vnc.h"

enum
{
  PROP_0,

PROP_CONTEXT,
};

struct _GrdVncServer
{
  GSocketService parent;

GList *sessions;

GList *stopped_sessions;
  guint idle_task;

GrdContext *context;
};

G_DEFINE_TYPE (GrdVncServer, grd_vnc_server, G_TYPE_SOCKET_SERVICE);

GrdContext *
grd_vnc_server_get_context (GrdVncServer *vnc_server)
{
  return vnc_server->context;
}

GrdVncServer *
grd_vnc_server_new (GrdContext *context)
{
  GrdVncServer *vnc_server;

vnc_server = g_object_new (GRD_TYPE_VNC_SERVER,
                             "context", context,
                             NULL);

return vnc_server;
}

static void
grd_vnc_server_cleanup_stopped_sessions (GrdVncServer *vnc_server)
{
  g_list_free_full (vnc_server->stopped_sessions, g_object_unref);
  vnc_server->stopped_sessions = NULL;
}

static gboolean
cleanup_stopped_sessions_idle (GrdVncServer *vnc_server)
{
  grd_vnc_server_cleanup_stopped_sessions (vnc_server);
  vnc_server->idle_task = 0;

return G_SOURCE_REMOVE;
}

static void
on_session_stopped (GrdSession *session, GrdVncServer *vnc_server)
{
  g_debug ("VNC session stopped");

vnc_server->stopped_sessions = g_list_append (vnc_server->stopped_sessions,
                                                session);
  vnc_server->sessions = g_list_remove (vnc_server->sessions, session);
  if (!vnc_server->idle_task)
    {
      vnc_server->idle_task =
        g_idle_add ((GSourceFunc) cleanup_stopped_sessions_idle,
                    vnc_server);
    }
}

static gboolean
on_incoming (GSocketService    *service,
             GSocketConnection *connection)
{
  GrdVncServer *vnc_server = GRD_VNC_SERVER (service);
  GrdSessionVnc *session_vnc;

g_debug ("New incoming VNC connection");

if (vnc_server->sessions)
    {
      /* TODO: Add the rfbScreen instance to GrdVncServer to support multiple
       * sessions. */
      g_debug ("Refusing new VNC connection: already an active session");
      return TRUE;
    }

session_vnc = grd_session_vnc_new (vnc_server, connection);
  vnc_server->sessions = g_list_append (vnc_server->sessions, session_vnc);
  grd_context_add_session (vnc_server->context, GRD_SESSION (session_vnc));

g_signal_connect (session_vnc, "stopped",
                    G_CALLBACK (on_session_stopped),
                    vnc_server);

return TRUE;
}

gboolean
grd_vnc_server_start (GrdVncServer  *vnc_server,
                      GError       **error)
{
  GrdSettings *settings = grd_context_get_settings (vnc_server->context);

if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (vnc_server),
                                        grd_settings_get_vnc_port (settings),
                                        NULL,
                                        error))
    return FALSE;

g_signal_connect (vnc_server, "incoming", G_CALLBACK (on_incoming), NULL);

return TRUE;
}

static void
stop_and_unref_session (GrdSession *session)
{
  grd_session_stop (session);
  g_object_unref (session);
}

static void
grd_vnc_server_set_property (GObject      *object,
                             guint         prop_id,
                             const GValue *value,
                             GParamSpec   *pspec)
{
  GrdVncServer *vnc_server = GRD_VNC_SERVER (object);

switch (prop_id)
    {
    case PROP_CONTEXT:
      vnc_server->context = g_value_get_object (value);
      break;

default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
grd_vnc_server_get_property (GObject    *object,
                             guint       prop_id,
                             GValue     *value,
                             GParamSpec *pspec)
{
  GrdVncServer *vnc_server = GRD_VNC_SERVER (object);

switch (prop_id)
    {
    case PROP_CONTEXT:
      g_value_set_object (value, vnc_server->context);

default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
grd_vnc_server_dispose (GObject *object)
{
  GrdVncServer *vnc_server = GRD_VNC_SERVER (object);

if (vnc_server->idle_task)
    {
      g_source_remove (vnc_server->idle_task);
      vnc_server->idle_task = 0;
    }

if (vnc_server->stopped_sessions)
    {
      grd_vnc_server_cleanup_stopped_sessions (vnc_server);
    }
  if (vnc_server->sessions)
    {
      g_list_free_full (vnc_server->sessions,
                        (GDestroyNotify) stop_and_unref_session);
      vnc_server->sessions = NULL;
    }

G_OBJECT_CLASS (grd_vnc_server_parent_class)->dispose (object);
}

static void
grd_vnc_server_constructed (GObject *object)
{
  GrdVncServer *vnc_server = GRD_VNC_SERVER (object);

if (grd_context_get_debug_flags (vnc_server->context) & GRD_DEBUG_VNC)
    rfbLogEnable (1);
  else
    rfbLogEnable (0);

G_OBJECT_CLASS (grd_vnc_server_parent_class)->constructed (object);
}

static void
grd_vnc_server_init (GrdVncServer *vnc_server)
{
}

static void
grd_vnc_server_class_init (GrdVncServerClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->set_property = grd_vnc_server_set_property;
  object_class->get_property = grd_vnc_server_get_property;
  object_class->dispose = grd_vnc_server_dispose;
  object_class->constructed = grd_vnc_server_constructed;

g_object_class_install_property (object_class,
                                   PROP_CONTEXT,
                                   g_param_spec_object ("context",
                                                        "GrdContext",
                                                        "The GrdContext instance",
                                                        GRD_TYPE_CONTEXT,
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT_ONLY |
                                                        G_PARAM_STATIC_STRINGS));
}
0707010000003D000081A40000000000000000000000016141EE1000000566000000000000000000000000000000000000002F00000000gnome-remote-desktop-40.2/src/grd-vnc-server.h/*
 * Copyright (C) 2015 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * Written by:
 *     Jonas Ådahl <jadahl@gmail.com>
 */

#ifndef GRD_VNC_SERVER_H
#define GRD_VNC_SERVER_H

#include <gio/gio.h>
#include <glib-object.h>

#include "grd-types.h"

#define GRD_TYPE_VNC_SERVER (grd_vnc_server_get_type ())
G_DECLARE_FINAL_TYPE (GrdVncServer,
                      grd_vnc_server,
                      GRD, VNC_SERVER,
                      GSocketService);

GrdContext *grd_vnc_server_get_context (GrdVncServer *vnc_server);

gboolean grd_vnc_server_start (GrdVncServer *vnc_server, GError **error);

GrdVncServer *grd_vnc_server_new (GrdContext *context);

#endif /* GRD_VNC_SERVER_H */
0707010000003E000081A40000000000000000000000016141EE1000000F1A000000000000000000000000000000000000002A00000000gnome-remote-desktop-40.2/src/meson.builddeps = [
  cairo_dep,
  glib_dep,
  gio_dep,
  gio_unix_dep,
  pipewire_dep,
  libsecret_dep,
  libnotify_dep,
]

daemon_sources = files([
  'grd-clipboard.c',
  'grd-clipboard.h',
  'grd-context.c',
  'grd-context.h',
  'grd-daemon.c',
  'grd-daemon.h',
  'grd-damage-utils.c',
  'grd-damage-utils.h',
  'grd-mime-type.c',
  'grd-mime-type.h',
  'grd-pipewire-utils.c',
  'grd-pipewire-utils.h',
  'grd-private.h',
  'grd-prompt.c',
  'grd-prompt.h',
  'grd-session.c',
  'grd-session.h',
  'grd-settings.c',
  'grd-settings.h',
  'grd-stream.c',
  'grd-stream.h',
  'grd-types.h',
])

if have_rdp
  daemon_sources += files([
    'grd-clipboard-rdp.c',
    'grd-clipboard-rdp.h',
    'grd-rdp-event-queue.c',
    'grd-rdp-event-queue.h',
    'grd-rdp-fuse-clipboard.c',
    'grd-rdp-fuse-clipboard.h',
    'grd-rdp-pipewire-stream.c',
    'grd-rdp-pipewire-stream.h',
    'grd-rdp-sam.c',
    'grd-rdp-sam.h',
    'grd-rdp-server.c',
    'grd-rdp-server.h',
    'grd-session-rdp.c',
    'grd-session-rdp.h',
  ])

deps += [
    freerdp_dep,
    freerdp_client_dep,
    freerdp_server_dep,
    fuse_dep,
    winpr_dep,
    xkbcommon_dep,
  ]
endif

if have_vnc
  daemon_sources += files([
    'grd-clipboard-vnc.c',
    'grd-clipboard-vnc.h',
    'grd-session-vnc.c',
    'grd-session-vnc.h',
    'grd-vnc-cursor.c',
    'grd-vnc-cursor.h',
    'grd-vnc-pipewire-stream.c',
    'grd-vnc-pipewire-stream.h',
    'grd-vnc-server.c',
    'grd-vnc-server.h',
  ])

deps += [
    libvncserver_dep,
  ]
endif

gen_daemon_sources = []

gen_daemon_sources += gnome.gdbus_codegen('grd-dbus-screen-cast',
                                          'org.gnome.Mutter.ScreenCast.xml',
                                          interface_prefix: 'org.gnome.Mutter.',
                                          namespace: 'GrdDBus')
gen_daemon_sources += gnome.gdbus_codegen('grd-dbus-remote-desktop',
                                          'org.gnome.Mutter.RemoteDesktop.xml',
                                          interface_prefix: 'org.gnome.Mutter.',
                                          namespace: 'GrdDBus')

daemon_sources += gen_daemon_sources

control_sources = ([
  'grd-control.c'
])

executable('gnome-remote-desktop-daemon',
           daemon_sources,
           dependencies: deps,
           include_directories: [configinc],
           install: true,
           install_dir: libexecdir)

executable('gnome-remote-desktop-control',
           control_sources,
           dependencies: [glib_dep, gio_dep],
           include_directories: [configinc],
           install : false)

service_config = configuration_data()
service_config.set('libexecdir', libexecdir)

configure_file(input: 'gnome-remote-desktop.service.in',
               output: 'gnome-remote-desktop.service',
               configuration: service_config,
               install_dir: servicedir)

custom_target('gsettings-enums',
              input: 'grd-enums.h',
              output: 'org.gnome.desktop.remote-desktop.enums.xml',
              install: true,
              install_dir: join_paths(datadir, 'glib-2.0', 'schemas'),
              capture: true,
              command: ['glib-mkenums',
                '--comments', '',
                '--fhead', '<schemalist>',
                '--vhead', '  <@type@ id="org.gnome.desktop.remote-desktop.@EnumName@">',
                '--vprod', '    <value nick="@valuenick@" value="@valuenum@"/>',
                '--vtail', '  </@type@>',
                '--ftail', '</schemalist>',
                '@INPUT@'])
schema = 'org.gnome.desktop.remote-desktop.gschema.xml'
generated_schema = configure_file(output: schema,
                                  input: schema + '.in',
                                  copy: true)
install_data(generated_schema,
             install_dir: schemadir)
gnome.compile_schemas()
0707010000003F000081A40000000000000000000000016141EE1000002C5A000000000000000000000000000000000000004100000000gnome-remote-desktop-40.2/src/org.gnome.Mutter.RemoteDesktop.xml<!DOCTYPE node PUBLIC
'-//freedesktop//DTD D-BUS Object Introspection 1.0//EN'
'http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd'>
<node>

<!--
      org.gnome.Mutter.RemoteDesktop:
      @short_description: Remote desktop interface

This API is private and not intended to be used outside of the integrated
      system that uses libmutter. No compatibility between versions are
      promised.
  -->
  <interface name="org.gnome.Mutter.RemoteDesktop">

<method name="CreateSession">
      <arg name="session_path" type="o" direction="out" />
    </method>

<!--
	SupportedDeviceTypes:
	@short_description: Bit mask of supported device types

Device types:
	  1: keyboard
	  2: pointer
	  4: touchscreen
    -->
    <property name="SupportedDeviceTypes" type="u" access="read" />

<property name="Version" type="i" access="read" />

</interface>

<interface name="org.gnome.Mutter.RemoteDesktop.Session">

<!--
	SessionId:

An identification string used for identifying a remote desktop session.
	It can be used to associate screen cast sessions with a remote desktop session.
    -->
    <property name="SessionId" type="s" access="read" />

<!--
	Start:

Start the remote desktop session
    -->
    <method name="Start" />

<!--
	Stop:

Stop the remote desktop session
    -->
    <method name="Stop" />

<!--
	Closed:

The session has closed.

A session doesn't have to have been started before it may be closed.
	After it being closed, it can no longer be used.
    -->
    <signal name="Closed" />

<!--
	NotifyKeyboardKeycode:

A key identified by an evdev keycode was pressed or released
     -->
    <method name="NotifyKeyboardKeycode">
      <arg name="keycode" type="u" direction="in" />
      <arg name="state" type="b" direction="in" />
    </method>

<!--
	NotifyKeyboardKeysym:

A key identified by a keysym was pressed or released
     -->
    <method name="NotifyKeyboardKeysym">
      <arg name="keysym" type="u" direction="in" />
      <arg name="state" type="b" direction="in" />
    </method>

<!--
	NotifyPointerButton:

A pointer button was pressed or released
     -->
    <method name="NotifyPointerButton">
      <arg name="button" type="i" direction="in" />
      <arg name="state" type="b" direction="in" />
    </method>

<!--
	NotifyPointerAxis:

A smooth pointer axis event notification. Relative motion deltas are to be
	interpreted as pixel movement of a standardized mouse.

Additionally to the smooth pointer axis event notification, an emulated
	discrete pointer axis event notification is emitted based on the submitted
	accumulated smooth scrolling steps.
	The base for these emulated discrete pointer axis event is the discrete step
	with the value 10.0.
	This means that for a delta dx (or dy) with the value 10.0 one emulated
	discrete scrolling event is emitted.
	For a high resolution smooth pointer axis event, a smaller value is submitted
	for each scrolling step.
	This means: For a double resolution mouse wheel one emulated discrete event
	is emitted for 2 smooth pointer axis events with each having the value 5.0.

Possible @flags:
	  1: finish - scroll motion was finished (e.g. fingers lifted)
	  2: source_wheel - The scroll event is originated by a mouse wheel.
	  4: source_finger - The scroll event is originated by one or more fingers on
	                     the device (eg. touchpads).
	  8: source_continuous - The scroll event is originated by the motion of some
	                          device (eg. a scroll button is set).

Maximum one of the @flags 'source_wheel', 'source_finger',
	  'source_continuous' may be specified.
	  If no source flag is specified, `source_finger` is assumed.
     -->
    <method name="NotifyPointerAxis">
      <arg name="dx" type="d" direction="in" />
      <arg name="dy" type="d" direction="in" />
      <arg name="flags" type="u" direction="in" />
    </method>

<!--
	NotifyPointerAxisDiscrete:

A discrete pointer axis event notification
     -->
    <method name="NotifyPointerAxisDiscrete">
      <arg name="axis" type="u" direction="in" />
      <arg name="steps" type="i" direction="in" />
    </method>

<!--
	NotifyPointerMotionRelative:

A relative pointer motion event notification
     -->
    <method name="NotifyPointerMotionRelative">
      <arg name="dx" type="d" direction="in" />
      <arg name="dy" type="d" direction="in" />
    </method>

<!--
	NotifyPointerMotionAbsolute:

A absolute pointer motion event notification
     -->
    <method name="NotifyPointerMotionAbsolute">
      <arg name="stream" type="s" direction="in" />
      <arg name="x" type="d" direction="in" />
      <arg name="y" type="d" direction="in" />
    </method>

<!--
	NotifyTouchDown:

A absolute pointer motion event notification
     -->
    <method name="NotifyTouchDown">
      <arg name="stream" type="s" direction="in" />
      <arg name="slot" type="u" direction="in" />
      <arg name="x" type="d" direction="in" />
      <arg name="y" type="d" direction="in" />
    </method>

<!--
	NotifyTouchMotion:

A absolute pointer motion event notification
     -->
    <method name="NotifyTouchMotion">
      <arg name="stream" type="s" direction="in" />
      <arg name="slot" type="u" direction="in" />
      <arg name="x" type="d" direction="in" />
      <arg name="y" type="d" direction="in" />
    </method>

<!--
	NotifyTouchUp:

A absolute pointer motion event notification
     -->
    <method name="NotifyTouchUp">
      <arg name="slot" type="u" direction="in" />
    </method>

<!--
        EnableClipboard:
        @options: Options for the clipboard

Available @options include:

* "mime-types" (as): List of mime types, for which the clipboard of the
                             remote desktop client has content.
                             Each mime-type is in string form, e.g. "image/jpeg",
                             "text/plain", etc..
                             If this list is included in @options, then this call
                             is equivalent to calling 'EnableClipboard' and
                             'SetSelection' atomically.

Enables the clipboard for the remote desktop client which will allow it
        to call the methods 'SetSelection', 'DisableClipboard', 'SelectionWrite',
        'SelectionWriteDone', 'SelectionRead'.
        The 'SelectionOwnerChanged' signal will also be emitted when the
        selection owner changes to inform the API user of new clipboard mime
        types, and the 'SelectionTransfer' signal will be emitted to request the
        advertised clipboard content of a mime type.
    -->
    <method name="EnableClipboard">
      <arg name="options" type="a{sv}" direction="in" />
    </method>

<!--
        DisableClipboard:

Unregisters all clipboard types that were advertised by the
        remote desktop client.
        The 'SelectionOwnerChanged' or 'SelectionTransfer' signals will not be
        emitted any more.
        Any 'SelectionTransfer' signals that weren't answered yet with a
        'SelectionWriteDone' call, will be answered with a 'SelectionWriteDone'
        call where 'success' is 'false'.
    -->
    <method name="DisableClipboard" />

<!--
        SetSelection:
        @options: Options for the clipboard selection

Available @options include:

Sets the owner of the clipboard formats in 'mime-types' in @options to
        the remote desktop client, i.e. the remote desktop client has data for
        these advertised clipboard formats.
    -->
    <method name="SetSelection">
      <arg name="options" type="a{sv}" direction="in" />
    </method>

<!--
        SelectionWrite:
        @serial: The serial of the request where this answer is directed to
        @fd: The file descriptor where the data will be written to

Answer to 'SelectionTransfer' signal. Contains the fd where the clipboard
        content will be written to.
    -->
    <method name="SelectionWrite">
      <arg name="serial" type="u" direction="in" />
      <annotation name="org.gtk.GDBus.C.UnixFD" value="true"/>
      <arg name="fd" type="h" direction="out" />
    </method>

<!--
        SelectionWriteDone:
        @serial: The serial of the request where this answer is directed to
        @success: A boolean which indicates whether the transfer of the clipboard
                  data was successful ('true') or not ('false').

Notifies that the transfer of the clipboard data has either completed
        successfully, or failed.
    -->
    <method name="SelectionWriteDone">
      <arg name="serial" type="u" direction="in" />
      <arg name="success" type="b" direction="in" />
    </method>

<!--
        SelectionRead:
        @mime_type: The mime-type string of the requested format
        @fd: The file descriptor where the data will be written to

Transfer the clipboard content given the specified mime type to the
        method caller via a file descriptor.
        It is the callee that creates the file descriptor.
    -->
    <method name="SelectionRead">
      <arg name="mime_type" type="s" direction="in" />
      <annotation name="org.gtk.GDBus.C.UnixFD" value="true"/>
      <arg name="fd" type="h" direction="out" />
    </method>

<!--
        SelectionOwnerChanged:
        @options: Options for the clipboard selection

Available @options include:

* "mime-types" (as): List of mime types, for which the clipboard of the
                             remote desktop client has content.
                             Each mime-type is in string form, e.g. "image/jpeg",
                             "text/plain", etc..
        * "session-is-owner" (b): 'true', if the remote desktop clients clipboard
                                  is already owner of these types, else 'false'.

Informs the remote desktop client of new clipboard formats that are
        available.
    -->
    <signal name="SelectionOwnerChanged">
      <arg name="options" type="a{sv}" direction="in" />
    </signal>

<!--
        SelectionTransfer:
        @mime_type: The mime-type string of the requested format
        @serial: The serial, that the answer of this particular request, MUST use

Requests the data for a clipboard format from the remote desktop client.
        MUST NOT be called when the remote desktop clients clipboard is (already)
        disabled.
    -->
    <signal name="SelectionTransfer">
      <arg name="mime_type" type="s" direction="in" />
      <arg name="serial" type="u" direction="in" />
    </signal>

</interface>

</node>
07070100000040000081A40000000000000000000000016141EE1000000922000000000000000000000000000000000000003E00000000gnome-remote-desktop-40.2/src/org.gnome.Mutter.ScreenCast.xml<!DOCTYPE node PUBLIC
'-//freedesktop//DTD D-BUS Object Introspection 1.0//EN'
'http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd'>
<node>

<!--
      org.gnome.Mutter.ScreenCast:
      @short_description: Screen cast interface

Available @properties (see RecordMonitor and RecordWindow)
  -->
  <interface name="org.gnome.Mutter.ScreenCast">

<!--
	CreateSession:
	@properties: Properties
	@session: Path to the new session object

* "remote-desktop-session-id" (s): The ID of a remote desktop session.
					   Remote desktop driven screen casts
					   are started and stopped by the remote
					   desktop session.
    -->
    <method name="CreateSession">
      <arg name="properties" type="a{sv}" direction="in" />
      <arg name="session_path" type="o" direction="out" />
    </method>

</interface>

<!--
	Start:

Start the screen cast session
    -->
    <method name="Start" />

<!--
	Stop:

Stop the screen cast session
    -->
    <method name="Stop" />

<!--
	Closed:

The session has closed.
    -->
    <signal name="Closed" />

<!--
	RecordMonitor:
	@connector: Connector of the monitor to record
	@properties: Properties
	@session: Path to the new session object

Record a single monitor.

Available @properties include: (none)
    -->
    <method name="RecordMonitor">
      <arg name="connector" type="s" direction="in" />
      <arg name="properties" type="a{sv}" direction="in" />
      <arg name="stream_path" type="o" direction="out" />
    </method>

<!--
	RecordWindow:
	@properties: Properties
	@session: Path to the new session object

Record a single monitor.

Available @properties include: (none)
    -->
    <method name="RecordWindow">
      <arg name="properties" type="a{sv}" direction="in" />
      <arg name="stream_path" type="o" direction="out" />
    </method>
  </interface>

<interface name="org.gnome.Mutter.ScreenCast.Stream">

<signal name="PipeWireStreamAdded">
      <annotation name="org.gtk.GDBus.C.Name" value="pipewire-stream-added"/>
      <arg name="node_id" type="u" direction="out" />
    </signal>

</interface>

</node>
07070100000041000081A40000000000000000000000016141EE10000008D2000000000000000000000000000000000000004E00000000gnome-remote-desktop-40.2/src/org.gnome.desktop.remote-desktop.gschema.xml.in<schemalist>
  <schema id='org.gnome.desktop.remote-desktop' path='/org/gnome/desktop/remote-desktop/'>
  </schema>
  <schema id='org.gnome.desktop.remote-desktop.rdp' path='/org/gnome/desktop/remote-desktop/rdp/'>
    <key name='tls-cert' type='s'>
      <default>''</default>
      <summary>Path to the certificate file</summary>
      <description>
        In Order to be able to use RDP with TLS Security, both the private key
        file and the certificate file need to be provided to the RDP server.
      </description>
    </key>
    <key name='tls-key' type='s'>
      <default>''</default>
      <summary>Path to the private key file</summary>
      <description>
        In Order to be able to use RDP with TLS Security, both the private key
        file and the certificate file need to be provided to the RDP server.
      </description>
    </key>
    <key name='view-only' type='b'>
      <default>true</default>
      <summary>Only allow remote connections to view the screen content</summary>
      <description>
        When view-only is true, remote RDP connections cannot manipulate input
        devices (e.g. mouse and keyboard).
      </description>
    </key>
  </schema>
  <schema id='org.gnome.desktop.remote-desktop.vnc' path='/org/gnome/desktop/remote-desktop/vnc/'>
    <key name='view-only' type='b'>
      <default>true</default>
      <summary>Only allow remote connections to view the screen content</summary>
      <description>
	When view-only is true, remote VNC connections cannot manipulate input
	devices (e.g. mouse and keyboard).
      </description>
    </key>
    <key name='auth-method' enum='org.gnome.desktop.remote-desktop.GrdVncAuthMethod'>
      <default>'prompt'</default>
      <summary>Method used to authenticate VNC connections</summary>
      <description>
	The VNC authentication method describes how a remote connection is
	authenticated. It can currently be done in two different ways:

* prompt   - by prompting the user for each new connection, requiring a
		      person with physical access to the workstation to
		      explicitly approve the new connection.
	 * password - by requiring the remote client to provide a known password
      </description>
    </key>
  </schema>
</schemalist>
07070100000042000041ED0000000000000000000000016141EE1000000000000000000000000000000000000000000000002000000000gnome-remote-desktop-40.2/tests07070100000043000081A40000000000000000000000016141EE1000000212000000000000000000000000000000000000002C00000000gnome-remote-desktop-40.2/tests/meson.buildif have_vnc
  test_client_vnc = executable(
    'test-client-vnc',
    files(['test-client-vnc.c']),
    dependencies: [glib_dep,
    libvncclient_dep],
    include_directories: [configinc],
    install: false)

test_runner = find_program('vnc-test-runner.sh')

test_env = environment()
  test_env.set('TEST_SRCDIR', top_srcdir)
  test_env.set('TEST_BUILDDIR', builddir)
  test_env.set('NO_AT_BRIDGE', '1')

test('gnome-remote-desktop/vnc', test_runner,
    env: test_env,
    is_parallel: false,
    timeout: 10,
  )
endif
07070100000044000081ED0000000000000000000000016141EE1000000A22000000000000000000000000000000000000003100000000gnome-remote-desktop-40.2/tests/run-vnc-tests.py#!/usr/bin/python3

import dbus
import os
import time
import os.path
import subprocess
import sys

from gi.repository import GLib

from dbus.mainloop.glib import DBusGMainLoop

mutter = None

DBusGMainLoop(set_as_default=True)
loop = GLib.MainLoop()
bus = dbus.SessionBus()

vnc_client_failed = None
vnc_server_failed = None

os.environ['GNOME_REMOTE_DESKTOP_TEST_VNC_PASSWORD'] = 'secret'
os.environ['MUTTER_DEBUG_DUMMY_MODE_SPECS'] = '1024x768'

def run_vnc_test_client():
  print("Running VNC test client")
  global vnc_client_failed
  builddir=os.getenv("TEST_BUILDDIR")
  vnc_test_client_path = os.path.join(builddir, 'tests', 'test-client-vnc')
  vnc_test_client = subprocess.Popen([vnc_test_client_path, 'localhost:5912'],
                                     stderr=subprocess.STDOUT)
  vnc_test_client.wait()
  if vnc_test_client.wait() != 0:
    print("VNC test client exited incorrectly")
    vnc_client_failed = True
  else:
    vnc_client_failed = False

def start_vnc_server():
  print("Starting VNC server")
  global vnc_server
  builddir=os.getenv("TEST_BUILDDIR")
  vnc_server_path = os.path.join(builddir, 'src', 'gnome-remote-desktop-daemon')
  vnc_server = subprocess.Popen([vnc_server_path, '--vnc-port', '5912'],
                                stderr=subprocess.STDOUT)
  time.sleep(5)

def stop_vnc_server():
  print("Stopping VNC server")
  global vnc_server
  global vnc_server_failed
  vnc_server.terminate()
  vnc_server.wait()
  if vnc_server.returncode != -15 and vnc_server.returncode != 0:
    print("VNC server exited incorrectly: %d"%(vnc_server.returncode))
    vnc_server_failed = True
  else:
    vnc_server_failed = False

def remote_desktop_name_appeared_cb(name):
  if name == '':
    return
  print("Remote desktop capable display server appeared")
  start_vnc_server()
  run_vnc_test_client()
  stop_vnc_server()
  stop_mutter()

def start_mutter():
  global mutter
  print("Starting mutter")
  mutter = subprocess.Popen(['mutter', '--nested', '--wayland'],
                            stderr=subprocess.STDOUT)

def stop_mutter():
  global mutter
  global loop
  if mutter == None:
    print("no mutter")
    return
  print("Stopping mutter")
  mutter.terminate()
  print("Waiting for mutter to terminate")
  if mutter.wait() != 0:
    print("Mutter exited incorrectly")
    sys.exit(1)
  print("Done")
  loop.quit()

bus.watch_name_owner('org.gnome.Mutter.RemoteDesktop',
                     remote_desktop_name_appeared_cb)

start_mutter()

loop.run()

if vnc_server_failed != False or vnc_client_failed != False:
  sys.exit(1)
else:
  sys.exit(0)
07070100000045000081A40000000000000000000000016141EE1000000C73000000000000000000000000000000000000003200000000gnome-remote-desktop-40.2/tests/test-client-vnc.c/*
 * Copyright (C) 2019 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 */

#include "config.h"

#include <glib.h>
#include <rfb/rfbclient.h>
#include <stdio.h>

static gboolean saw_correct_size = FALSE;

static rfbBool
handle_malloc_framebuffer (rfbClient *rfb_client)
{
  if (rfb_client->width == 1024 &&
      rfb_client->height == 768)
    saw_correct_size = TRUE;

g_clear_pointer (&rfb_client->frameBuffer, g_free);
  rfb_client->frameBuffer = g_malloc0 (rfb_client->width *
                                       rfb_client->height *
                                       rfb_client->format.bitsPerPixel / 4);

return TRUE;
}

static void
handle_got_framebuffer_update (rfbClient *rfb_client,
                               int        x,
                               int        y,
                               int        width,
                               int        height)
{
  if (saw_correct_size)
    exit(EXIT_SUCCESS);
}

static char *
handle_get_password (rfbClient *rfb_client)
{
  const char *test_password;

test_password = g_getenv ("GNOME_REMOTE_DESKTOP_TEST_VNC_PASSWORD");
  g_assert (test_password);

return g_strdup (test_password);
}

int
main (int    argc,
      char **argv)
{
  rfbClient *rfb_client;
  const int bits_per_sample = 8;
  const int samples_per_pixel = 3;
  const int bytes_per_pixel = 4;

rfb_client = rfbGetClient (bits_per_sample,
                             samples_per_pixel,
                             bytes_per_pixel);

rfb_client->MallocFrameBuffer = handle_malloc_framebuffer;
  rfb_client->canHandleNewFBSize = TRUE;
  rfb_client->GotFrameBufferUpdate = handle_got_framebuffer_update;
  rfb_client->GetPassword = handle_get_password;
  rfb_client->listenPort = LISTEN_PORT_OFFSET;
  rfb_client->listen6Port = LISTEN_PORT_OFFSET;

if (!rfbInitClient (rfb_client, &argc, argv))
    {
      g_warning ("Failed to initialize VNC client");
      return EXIT_FAILURE;
    }

while (TRUE)
    {
      int ret;
      const int timeout_us = 500;

ret = WaitForMessage (rfb_client, timeout_us);
      if (ret < 0)
        {
          g_warning ("WaitForMessage failed");
          rfbClientCleanup (rfb_client);
          return EXIT_FAILURE;
        }
      else if (ret > 0)
        {
          if (!HandleRFBServerMessage (rfb_client))
            {
              g_warning ("HandleRFBServerMessage failed");
              rfbClientCleanup (rfb_client);
              return EXIT_FAILURE;
            }
        }
    }
}
07070100000046000081ED0000000000000000000000016141EE100000006A000000000000000000000000000000000000003300000000gnome-remote-desktop-40.2/tests/vnc-test-runner.sh#!/usr/bin/env bash

dbus-run-session -- xvfb-run -s '+iglx -noreset' $TEST_SRCDIR/tests/run-vnc-tests.py
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!947 blocks

Places

File gnome-remote-desktop-40.2.obscpio of Package gnome-remote-desktop (Revision c0a6a08948bbee2add3b86dc6af8d30c)

Places