<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">

    <head>
    <link rel="stylesheet" href="/styles/main.css?s=1712697967">
    <link rel="icon" type="image/svg+xml" href="/images/logos/guac-classic-logo.svg"/>
    <link rel="icon" type="image/png" href="/images/logos/guac-classic-logo-64.png"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no, target-densitydpi=device-dpi"/>
    <meta charset="UTF-8"/>
    <title>Apache Guacamole™: 0.9.10-incubating</title>
</head>


    <body class="">

        <!-- Header -->
<div id="header">
    <div class="readable-content">
        <h1><a href="/">Apache Guacamole™</a></h1>
        <ul id="navigation" class="menu">
            

    
    

    
    

    
    
        
            
                <li>
                    <a href="/releases/"
                        
                            class="releases"
                            >Release Archives</a>
                </li>
            
        
    

    
    

    
    

    
    
        
            
                <li class="dropdown">
                    
                    <a class="dropdown-toggle "
                       href="#">Documentation</a>
                    <ul class="dropdown-menu">
                        

    
    

    
    
        
            
                <li>
                    <a href="/faq/"
                        >FAQ</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="/api-documentation/"
                        >API / Development</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="/doc/gug/"
                        >Guacamole Manual</a>
                </li>
            
        
    


                    </ul>
                </li>
            
        
    

    
    

    
    
        
            
                <li class="dropdown">
                    
                    <a class="dropdown-toggle "
                       href="#">Community</a>
                    <ul class="dropdown-menu">
                        

    
    
        
            
                <li>
                    <a href="/open-source/"
                        >Contributing to Guacamole</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="/support/#mailing-lists"
                        >Mailing Lists</a>
                </li>
            
        
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="https://issues.apache.org/jira/browse/GUACAMOLE/"
                        >Bug/Issue Tracker</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="https://github.com/search?utf8=%E2%9C%93&q=repo%3Aapache%2Fguacamole-client+repo%3Aapache%2Fguacamole-server+repo%3Aapache%2Fguacamole-manual+repo%3Aapache%2Fguacamole-website&type=repositories&ref=searchresults"
                        >Source Code</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    


                    </ul>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="/security/"
                        >Security Reports</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    
        
            
                <li class="dropdown">
                    
                    <a class="dropdown-toggle "
                       href="#">Support</a>
                    <ul class="dropdown-menu">
                        

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="/support/#mailing-lists"
                        >Mailing Lists</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="https://issues.apache.org/jira/browse/GUACAMOLE/"
                        >Bug/Issue Tracker</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="/support/#commercial-support"
                        >Commercial Support</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    

    
    


                    </ul>
                </li>
            
        
    

    
    
        
            
                <li class="dropdown">
                    
                    <a class="dropdown-toggle apache"
                       href="#">ASF</a>
                    <ul class="dropdown-menu">
                        

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="http://www.apache.org/"
                        >ASF Homepage</a>
                </li>
            
        
    

    
    

    
    
        
            
                <li>
                    <a href="http://www.apache.org/licenses/"
                        >License</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="http://www.apache.org/foundation/thanks.html"
                        >Thanks</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="http://www.apache.org/foundation/sponsorship.html"
                        >Sponsorship</a>
                </li>
            
        
    

    
    

    
    

    
    

    
    
        
            
                <li>
                    <a href="http://www.apache.org/foundation/policies/conduct.html"
                        >Code of Conduct</a>
                </li>
            
        
    

    
    


                    </ul>
                </li>
            
        
    

    
    

    
    


        </ul>
    </div>
</div>


        <!-- Content -->
        <div class="fullwidth-content">
            <h1 class="title">
    Apache Guacamole 0.9.10-incubating
    <span class="release-type">
        
        
            (Archived)
        
    </span>
</h1>

<div class="readable-content">

    

    
        
        <div class="note">
            <p>Apache Guacamole 0.9.10-incubating is an archived release, and was
            originally released on 2016-12-29. <strong>The
            latest release of Apache Guacamole is <a href="/releases/1.5.5/">1.5.5</a>.</strong></p>
        </div>
    

    <div id="links">

        
    
        <h2>Release documentation</h2>
    
    <ul>
        
            <li><a href="/doc/0.9.10-incubating/gug">Manual</a></li>
        
            <li><a href="/doc/0.9.10-incubating/guacamole-common">guacamole-common</a></li>
        
            <li><a href="/doc/0.9.10-incubating/guacamole-common-js">guacamole-common-js</a></li>
        
            <li><a href="/doc/0.9.10-incubating/guacamole-ext">guacamole-ext</a></li>
        
            <li><a href="/doc/0.9.10-incubating/libguac">libguac</a></li>
        
    </ul>



    </div>

    <p>Apache Guacamole is split into two subprojects: "guacamole-client", the
    HTML5 web application which serves the Guacamole client to users, and
    "guacamole-server", the remote desktop proxy which the web application
    communicates with. The source code for each of these may be downloaded
    below.</p>

    <p>You <strong>must</strong> <a href="https://www.apache.org/info/verification.html">
    verify the integrity of any downloaded files</a> using the OpenPGP signatures
    we provide with each release. The signatures should be verified against the
    <a href="https://downloads.apache.org/guacamole/KEYS">KEYS</a>
    file, which contains the OpenPGP keys of Apache Guacamole's Release Managers.
    Checksums of each released file are also provided.</p>

    <!-- Source archives -->
    <div class="release-downloads">
        
    <table>
        <tr>
            <th>Filename</th>
            <th>Signatures / Hashes</th>
        </tr>
        
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/source/guacamole-client-0.9.10-incubating.tar.gz">guacamole-client-0.9.10-incubating.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/source/guacamole-client-0.9.10-incubating.tar.gz.md5">MD5</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/source/guacamole-client-0.9.10-incubating.tar.gz.sha">SHA</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/source/guacamole-client-0.9.10-incubating.tar.gz.asc">PGP</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/source/guacamole-server-0.9.10-incubating.tar.gz">guacamole-server-0.9.10-incubating.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/source/guacamole-server-0.9.10-incubating.tar.gz.md5">MD5</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/source/guacamole-server-0.9.10-incubating.tar.gz.sha">SHA</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/source/guacamole-server-0.9.10-incubating.tar.gz.asc">PGP</a>
                    
                </td>
            </tr>
        
    </table>


    </div>

    <p>If you do not wish to build Apache Guacamole entirely from source, pre-built
    versions of the web application (.war) and all extensions are provided here in
    binary form for convenience.  <strong>Please note that guacamole-server must
    still be built and installed from source.</strong></p>

    <!-- All binaries -->
    <div class="release-downloads">
        
    <table>
        <tr>
            <th>Filename</th>
            <th>Signatures / Hashes</th>
        </tr>
        
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-0.9.10-incubating.war">guacamole-0.9.10-incubating.war</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-0.9.10-incubating.war.md5">MD5</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-0.9.10-incubating.war.sha">SHA</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-0.9.10-incubating.war.asc">PGP</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-jdbc-0.9.10-incubating.tar.gz">guacamole-auth-jdbc-0.9.10-incubating.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-jdbc-0.9.10-incubating.tar.gz.md5">MD5</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-jdbc-0.9.10-incubating.tar.gz.sha">SHA</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-jdbc-0.9.10-incubating.tar.gz.asc">PGP</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-ldap-0.9.10-incubating.tar.gz">guacamole-auth-ldap-0.9.10-incubating.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-ldap-0.9.10-incubating.tar.gz.md5">MD5</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-ldap-0.9.10-incubating.tar.gz.sha">SHA</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-ldap-0.9.10-incubating.tar.gz.asc">PGP</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-noauth-0.9.10-incubating.tar.gz">guacamole-auth-noauth-0.9.10-incubating.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-noauth-0.9.10-incubating.tar.gz.md5">MD5</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-noauth-0.9.10-incubating.tar.gz.sha">SHA</a>
                    
                        
                        <a href="https://archive.apache.org/dist/incubator/guacamole/0.9.10-incubating/binary/guacamole-auth-noauth-0.9.10-incubating.tar.gz.asc">PGP</a>
                    
                </td>
            </tr>
        
    </table>


    </div>

    <!-- Release notes -->
    <div id="release-notes">
        <h1>Release notes</h1>
        <p>The 0.9.10-incubating release is Apache Guacamole’s first release under the
Apache Incubator. It features support for both screen sharing and recording,
improved file transfer behavior, and support for LDAP within the Docker images.
Local clipboard integration has also been added (for those browsers which
support it), as well as audio input for RDP, theming/branding via extensions,
and several other improvements.</p>

<p><strong>This release contains changes which break compatibility with past releases.</strong>
Please see the <a href="#deprecation--compatibility-notes">deprecation / compatibility
notes</a> section for more information.</p>

<h2 id="were-incubating">We’re incubating!</h2>

<p>The Guacamole project has been accepted into the <a href="http://incubator.apache.org/">Apache
Incubator</a>, and is thus now Apache Guacamole
(incubating). Beyond simply moving the website, this necessitated a number of
changes, including switching to the <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache
License</a> and migrating Guacamole’s
Java API and Maven artifacts from <code class="language-plaintext highlighter-rouge">org.glyptodon.guacamole</code> to
<code class="language-plaintext highlighter-rouge">org.apache.guacamole</code>.  If you are simply using the Guacamole web application
as-is, the transition should be fairly seamless, but downstream users of the
APIs will need to update their source to make use of this release.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-1">GUACAMOLE-1</a> - Update source licenses and LICENSE / NOTICE / DISCLAIMER</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-3">GUACAMOLE-3</a> - Contribution guidelines are incorrect</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-93">GUACAMOLE-93</a> - Migrate Docker images to build from git</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-97">GUACAMOLE-97</a> - Update documentation for Docker images</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-107">GUACAMOLE-107</a> - Update documentation with respect to Apache</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-116">GUACAMOLE-116</a> - Strip pre-built minified JavaScript libraries from source tarball</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-131">GUACAMOLE-131</a> - JavaScript libraries should not be bundled in source</li>
</ul>

<h2 id="screen-sharing">Screen sharing</h2>

<p>Guacamole now supports screen sharing for all protocols, even those which do
not inherently support it, like RDP and SSH. When granted permission, users can
generate temporary share links for their active connections, with those links
being invalidated when they disconnect. The degree of access granted by a share
link is defined by the “sharing profile” used to generate that link.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-5">GUACAMOLE-5</a> - Allow creation of per-connection share links</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-13">GUACAMOLE-13</a> - Finally stabilize and merge GUAC-844 to master</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-52">GUACAMOLE-52</a> - Do not delete history records</li>
</ul>

<h2 id="screen-recording">Screen recording</h2>

<p>All supported protocols (VNC, RDP, SSH, and telnet) can now be configured to
record sessions to disk for later playback. These session recordings are
actually Guacamole protocol dumps of the graphical updates being sent from the
Guacamole server to users of that connection. They can be converted to a normal
video stream using the new “guacenc” utility, which is part of the
guacamole-server build.</p>

<p>Additionally, text-based protocols (SSH and telnet) can record sessions as
text, using the same two-file format used by the <code class="language-plaintext highlighter-rouge">script</code> and <code class="language-plaintext highlighter-rouge">scriptreplay</code>
commands.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-4">GUACAMOLE-4</a> - Implement session recording</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-16">GUACAMOLE-16</a> - Implement text-based screen recording for SSH/telnet</li>
</ul>

<h2 id="streamlined-file-transfers">Streamlined file transfers</h2>

<p>The Guacamole web application now handles file transfers via HTTP. This speeds
things up considerably, removes limitations on file size imposed by JavaScript,
and removes the need for manually initiating the actual download by clicking a
link.</p>

<p>File transfer is still handled via the Guacamole protocol. The streams are
dynamically intercepted, stripped, and exposed via HTTP by the web application
in response to specific REST API requests. This is strictly a frontend change
and does not affect the core Guacamole stack and protocol, which continues to
handle file transfer as it always has.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-44">GUACAMOLE-44</a> - Upload/download of files that are more than 1 GB fail</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-46">GUACAMOLE-46</a> - File uploads are very slow</li>
</ul>

<h2 id="rdp-audio-input">RDP audio input</h2>

<p>RDP’s <code class="language-plaintext highlighter-rouge">AUDIO_INPUT</code> channel is now supported. If your RDP server supports audio
input, corresponding support can be enabled on your RDP connections in
Guacamole.</p>

<p>Audio recording only occurs when an application running within the remote
desktop requests access, and then only if that access is granted by the user.
The user will be prompted by their browser to allow or deny access.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-25">GUACAMOLE-25</a> - Add support for audio input</li>
</ul>

<h2 id="keyboard-improvements">Keyboard improvements</h2>

<p>Use of the numeric keypad was broken in version 0.9.9. This should now be
fixed.</p>

<p>New keymaps for RDP have also been contributed, including  Dutch, Japanese, and
fixes for the existing French layout.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-6">GUACAMOLE-6</a> - Netherlands keyboard layout created</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-7">GUACAMOLE-7</a> - Wrong French keyboard layout</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-15">GUACAMOLE-15</a> - Japanese keymap support on RDP</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-19">GUACAMOLE-19</a> - “@” characters don’t work with French keyboard under IE11</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-51">GUACAMOLE-51</a> - Keypad not properly mapped in RDP, SSH, and telnet</li>
</ul>

<h2 id="local-clipboard-integration">Local clipboard integration</h2>

<p>Guacamole will now use the <a href="https://www.w3.org/TR/clipboard-apis/">W3C Clipboard
API</a> (<code class="language-plaintext highlighter-rouge">document.execCommand()</code>) to
attempt to read the local clipboard. Few browsers allow this in circumstances
compatible with remote desktop, IE11 among them. If this fails, things continue
to work as they have in past releases (clipboard access via the Guacamole
menu/sidebar).</p>

<p>IE11 will prompt the user to allow clipboard access. Other browsers will
typically deny access without any sort of prompt. For Chrome, there is a
third-party extension, <a href="https://chrome.google.com/webstore/detail/clipboard-permission-mana/ipbhneeanpgkaleihlknhjiaamobkceh">Clipboard Permission
Manager</a>,
which allows the user to grant unrestricted access to the W3C Clipboard API on
a per-domain basis.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-24">GUACAMOLE-24</a> - Directly integrate local clipboard</li>
</ul>

<h2 id="theming-extensions">Theming extensions</h2>

<p>Guacamole’s extension system now supports modification of the HTML structure
in addition to the authentication and CSS/JavaScript/translation modification
components. This is achieved through specially-formatted HTML “patches”,
documented in more detail within the manual.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-9">GUACAMOLE-9</a> - Allow modification of HTML via extensions</li>
</ul>

<h2 id="docker-improvements">Docker improvements</h2>

<p>The Guacamole Docker images have been updated to support LDAP, as well as the
concurrency limit properties of the database authentication backend.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-8">GUACAMOLE-8</a> - Allow concurrency properties to be configured within Docker</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-21">GUACAMOLE-21</a> - Support LDAP within Docker image</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-27">GUACAMOLE-27</a> - Bring Docker images into new git repositories</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-50">GUACAMOLE-50</a> - Update Docker containers to use Java 8</li>
</ul>

<h2 id="improved-user-management">Improved user management</h2>

<p>Support for role-based access control within LDAP via the standard <code class="language-plaintext highlighter-rouge">seeAlso</code>
attribute has been added, allowing access to connections to be dictated on a
per-group basis, rather than strictly per-user.</p>

<p>Guacamole’s administrative interface has also been mildly enhanced, adding a
convenient “Clone” button for copying users and their associated permissions
(similar to the “Clone” button already available for connections).</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-12">GUACAMOLE-12</a> - Allow LDAP role-based access control for guacConfigGroups</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-14">GUACAMOLE-14</a> - Add support for cloning existing users</li>
</ul>

<h2 id="absolute-concurrency-limits">Absolute concurrency limits</h2>

<p>Administrators can now restrict the total number of active connections allowed
by a Guacamole server. Unlike other existing concurrency limits, this limit
ignores connection and user identity; it is a strict absolute limit covering
overall use.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-26">GUACAMOLE-26</a> - Add support for overall concurrency limits</li>
</ul>

<h2 id="session-affinity-sticky-sessions">Session affinity (“sticky sessions”)</h2>

<p>For the cases where balancing groups may route users to any one of several
desktops, and it is important that users are consistently routed to the same
desktop to avoid losing work, administrators can now enable “session affinity”
on those balancing groups. Users of those balancing groups will then be
directed to the same underlying connection until they logout from Guacamole.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-53">GUACAMOLE-53</a> - Add support for session affinity within balancing groups</li>
</ul>

<h2 id="exposing-terminal-output-to-javascript">Exposing terminal output to JavaScript</h2>

<p>Both SSH and telnet now expose raw text output via the Guacamole protocol’s
“pipe streams” (essentially named pipes). Though not leveraged by the Guacamole
web application, downstream users of the Guacamole API can grab and handle the
data sent along these streams as they see fit using client-side JavaScript.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-17">GUACAMOLE-17</a> - Allow terminal output to be redirected to pipe streams</li>
</ul>

<h2 id="miscellaneous-bugs">Miscellaneous bugs</h2>

<p>This latest release of Guacamole also includes fixes for minor usability issues
in IE11, failures to render errors properly under certain circumstances, and
typos in Guacamole’s French translation.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-10">GUACAMOLE-10</a> - Keyboard focus is permanently lost after clicking the URL bar in IE11</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-11">GUACAMOLE-11</a> - No error screen during an invalid SSH login in 0.9.8</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-18">GUACAMOLE-18</a> - Fix typo in French translation</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-22">GUACAMOLE-22</a> - Update missing french translations</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-23">GUACAMOLE-23</a> - __guac_socket_fd_select_handler() must always init fd_set</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-35">GUACAMOLE-35</a> - Performance flags not handled</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-66">GUACAMOLE-66</a> - Remove usage of Apache Commons Codec Library</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-67">GUACAMOLE-67</a> - I/O error in WebSocket can cause connection tracking to fail</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-76">GUACAMOLE-76</a> - Retrieval of connection group tree too slow</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-112">GUACAMOLE-112</a> - Update MessageFormat</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-115">GUACAMOLE-115</a> - Client may not cleanly disconnect if tunnel read() is blocking</li>
</ul>

<h1 id="deprecation--compatibility-notes">Deprecation / Compatibility notes</h1>

<p>As of 0.9.10-incubating, the following changes have been made which affect
compatibility with past releases:</p>

<h2 id="database-schema-changes">Database schema changes</h2>

<p>The MySQL and PostgreSQL schemas have changed to facilitate screen sharing
support. Users of the database authentication will need to run the
<code class="language-plaintext highlighter-rouge">upgrade-pre-0.9.10.sql</code> script specific to their chosen database.</p>

<h2 id="deprecation-of-the-basic-user-mapping-property">Deprecation of the <code class="language-plaintext highlighter-rouge">basic-user-mapping</code> property</h2>

<p>The <code class="language-plaintext highlighter-rouge">basic-user-mapping</code> property used to specify an alternative location for
<code class="language-plaintext highlighter-rouge">user-mapping.xml</code> is now deprecated. The property will continue to function as
in previous releases, but a warning will be logged advising of its deprecation.</p>

<p>Administrators should instead place their <code class="language-plaintext highlighter-rouge">user-mapping.xml</code> files directly
within <a href="/doc/0.9.10-incubating/gug/configuring-guacamole.html#guacamole-home"><code class="language-plaintext highlighter-rouge">GUACAMOLE_HOME</code></a>.</p>

<h2 id="removal-of-deprecated-lib-directory-and-auth-provider-properties">Removal of deprecated <code class="language-plaintext highlighter-rouge">lib-directory</code> and <code class="language-plaintext highlighter-rouge">auth-provider</code> properties</h2>

<p>The <code class="language-plaintext highlighter-rouge">lib-directory</code> and <code class="language-plaintext highlighter-rouge">auth-provider</code> properties have been deprecated since
the 0.9.7 release, in favor of a self-contained extension format which does not
require their use. From 0.9.7 on, though these properties still functioned as
in 0.9.6 and older, a warning was logged advising of their deprecation.</p>

<p>These properties have now been removed, and configurations which rely on these
properties will need to use the <code class="language-plaintext highlighter-rouge">extensions/</code> directory within
<a href="/doc/0.9.10-incubating/gug/configuring-guacamole.html#guacamole-home"><code class="language-plaintext highlighter-rouge">GUACAMOLE_HOME</code></a>
instead.</p>

<h2 id="rename-from-orgglyptodonguacamole-to-orgapacheguacamole">Rename from <code class="language-plaintext highlighter-rouge">org.glyptodon.guacamole</code> to <code class="language-plaintext highlighter-rouge">org.apache.guacamole</code></h2>

<p>As Guacamole is now a project operating under the Apache Incubator, its Java
classes and Maven artifacts have moved from the <code class="language-plaintext highlighter-rouge">org.glyptodon.guacamole</code>
package and groupId to <code class="language-plaintext highlighter-rouge">org.apache.guacamole</code>. Downstream developers using
Guacamole’s APIs will need to update their source code accordingly.</p>

<h2 id="extension-api-changes-for-screen-sharing">Extension API changes for screen sharing</h2>

<p>The Guacamole extension API (guacamole-ext) been changed to provide for storage
of sharing profile data, and to allow for extensions to generate temporary
credentials for shared connections. If you have written an extension for
Guacamole, you may need to implement additional functions in addition to
rebuilding your extension against the latest.</p>

<p>These changes center around the addition of the <a href="/doc/0.9.10-incubating/guacamole-ext/org/apache/guacamole/net/auth/Shareable.html"><code class="language-plaintext highlighter-rouge">Shareable</code></a> and
<a href="/doc/0.9.10-incubating/guacamole-ext/org/apache/guacamole/net/auth/SharingProfile.html"><code class="language-plaintext highlighter-rouge">SharingProfile</code></a>
interfaces, and primarily affect implementations of the following interfaces:</p>

<ul>
  <li><a href="/doc/0.9.10-incubating/guacamole-ext/org/apache/guacamole/net/auth/ActiveConnection.html"><code class="language-plaintext highlighter-rouge">ActiveConnection</code></a></li>
  <li><a href="/doc/0.9.10-incubating/guacamole-ext/org/apache/guacamole/net/auth/UserContext.html"><code class="language-plaintext highlighter-rouge">UserContext</code></a></li>
</ul>

<p>The <a href="/doc/0.9.10-incubating/gug/guacamole-ext.html">updated guacamole-ext
overview</a> within the manual
covers these changes, particularly the <a href="/doc/0.9.10-incubating/gug/guacamole-ext.html#ext-active-connections">managing/sharing active
connections</a>
section.</p>

<h2 id="libguac-api-changes">libguac API changes</h2>

<p>The libguac API has been extensively modified for the sake of screen sharing.
A new <a href="/doc/0.9.10-incubating/libguac/structguac__user.html"><code class="language-plaintext highlighter-rouge">guac_user</code></a>
structure has been added to represent each user sharing a logical connection,
where that connection is represented by
<a href="/doc/0.9.10-incubating/libguac/structguac__client.html"><code class="language-plaintext highlighter-rouge">guac_client</code></a>. This
requires a completely new initialization flow for protocol support
implementations, and any plugins which provide additional protocol support for
guacd will need to be updated.</p>

<p>These changes are documented in more detail in the <a href="/doc/0.9.10-incubating/gug/libguac.html">updated libguac
overview</a> within the manual.</p>


    </div>

</div>

        </div>

        <!-- Footer -->
<div id="footer">
    <div class="readable-content">

        <!-- Copyrights -->
        <p class="copyright">
            Copyright &copy; 2024 <a href="http://www.apache.org/">The Apache
                Software Foundation</a>, Licensed under the <a
            href="http://www.apache.org/licenses/LICENSE-2.0">Apache License,
            Version 2.0</a>.
        </p>

        <!-- Trademarks -->
        <p class="trademarks">
            Apache Guacamole, Guacamole, Apache, the Apache feather logo, and the
            Apache Guacamole project logo are trademarks of The Apache Software
            Foundation.
        </p>

    </div>
</div>


        <!-- jQuery -->
        <script src="/scripts/jquery.min.js" type="text/javascript"></script>

        <!-- Dropdown toggle -->
        <script src="/scripts/dropdown.js" type="text/javascript"></script>

    </body>
</html>
