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

    <head>
    <link rel="stylesheet" href="/styles/main.css?s=1714581448">
    <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™: 1.1.0</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 1.1.0
    <span class="release-type">
        
        
            (Archived)
        
    </span>
</h1>

<div class="readable-content">

    

    
        
        <div class="note">
            <p>Apache Guacamole 1.1.0 is an archived release, and was
            originally released on 2020-01-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/1.1.0/gug">Manual</a></li>
        
            <li><a href="/doc/1.1.0/guacamole-common">guacamole-common</a></li>
        
            <li><a href="/doc/1.1.0/guacamole-common-js">guacamole-common-js</a></li>
        
            <li><a href="/doc/1.1.0/guacamole-ext">guacamole-ext</a></li>
        
            <li><a href="/doc/1.1.0/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/guacamole/1.1.0/source/guacamole-client-1.1.0.tar.gz">guacamole-client-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/source/guacamole-client-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/source/guacamole-client-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/source/guacamole-server-1.1.0.tar.gz">guacamole-server-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/source/guacamole-server-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/source/guacamole-server-1.1.0.tar.gz.sha256">SHA-256</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/guacamole/1.1.0/binary/guacamole-1.1.0.war">guacamole-1.1.0.war</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-1.1.0.war.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-1.1.0.war.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-cas-1.1.0.tar.gz">guacamole-auth-cas-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-cas-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-cas-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-duo-1.1.0.tar.gz">guacamole-auth-duo-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-duo-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-duo-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-header-1.1.0.tar.gz">guacamole-auth-header-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-header-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-header-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-jdbc-1.1.0.tar.gz">guacamole-auth-jdbc-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-jdbc-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-jdbc-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-ldap-1.1.0.tar.gz">guacamole-auth-ldap-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-ldap-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-ldap-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-openid-1.1.0.tar.gz">guacamole-auth-openid-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-openid-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-openid-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-quickconnect-1.1.0.tar.gz">guacamole-auth-quickconnect-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-quickconnect-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-quickconnect-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
            <tr>
                
                
                <td class="filename"><a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-totp-1.1.0.tar.gz">guacamole-auth-totp-1.1.0.tar.gz</a></td>
                <td class="signatures">
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-totp-1.1.0.tar.gz.asc">PGP</a>
                    
                        
                        <a href="https://archive.apache.org/dist/guacamole/1.1.0/binary/guacamole-auth-totp-1.1.0.tar.gz.sha256">SHA-256</a>
                    
                </td>
            </tr>
        
    </table>


    </div>

    <!-- Release notes -->
    <div id="release-notes">
        <h1>Release notes</h1>
        <p>The 1.1.0 release features support for dynamic image quality and for connecting
directly to the terminals of Kubernetes pods. Issues with user group support
discovered following the 1.0.0 release have been fixed, issues with LDAP
support have been resolved through migrating to the <a href="https://directory.apache.org/api/">Apache Directory
API</a>, and issues with RDP support have been
resolved through migrating to FreeRDP 2.0.0.</p>

<p><strong>The 1.1.0 release is compatible with 1.0.0 components.</strong> Version numbering
from 1.0.0 onward is intended to indicate backward compatibility, with changes
to the major (leftmost) version number being made only when compatibility with
previous releases has been broken. You should upgrade 1.0.0 components to 1.1.0
when possible, however things should continue to work correctly in the interim:</p>

<ul>
  <li>Extensions written for 1.0.0 can be used by 1.1.0.</li>
  <li>Components written for the version of the Guacamole protocol used by 1.0.0
can be used with components of the 1.1.0 release.</li>
</ul>

<p>Regardless of inter-component compatibility, <strong>there are changes in 1.1.0 which
may affect downstream packagers of guacamole-server and downstream users of
libguac or the Guacamole protocol</strong>. Please see the <a href="#deprecation--compatibility-notes">deprecation /
compatibility notes</a> section for more
information.</p>

<h2 id="new-features-and-improvements">New features and improvements</h2>

<h3 id="migration-to-freerdp-200">Migration to FreeRDP 2.0.0</h3>

<p>Guacamole has historically supported FreeRDP’s 1.0 and 1.1 branches, as well as
several pre-release 1.2.x tags made over time. With these versions of FreeRDP
no longer being actively maintained, and with support for these versions being
removed from most Linux distributions, Guacamole’s RDP support has been
migrated to FreeRDP 2.0.0.</p>

<p>This migration inherently fixed several issues with RDP support, but also
<a href="#freerdp-200-or-later-is-now-required-for-rdp-support">necessitated dropping support for any version of FreeRDP older than 2.0.0</a>.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-125">GUACAMOLE-125</a> - Sometimes session is not initialised on Full screen</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-249">GUACAMOLE-249</a> - Update RDP plugin support to 2.0.0 releases</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-413">GUACAMOLE-413</a> - RDP NLA fails when username contains accented characters</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-707">GUACAMOLE-707</a> - Docker image missing support for RD connection broker / display update</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-847">GUACAMOLE-847</a> - Memory leak when using RDP with audio data</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-900">GUACAMOLE-900</a> - RDPDR fails after resizing when “resize-method” is “reconnect”</li>
</ul>

<h3 id="migration-to-the-apache-directory-api">Migration to the Apache Directory API</h3>

<p>Older versions of Guacamole used the JLDAP library to provide LDAP support.
This library is unmaintained, and Guacamole’s LDAP support has now migrated to
the <a href="https://directory.apache.org/api/">Apache Directory API</a>. This migration
also inherently fixed issues with LDAP result handling and error logging.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-234">GUACAMOLE-234</a> - Migrate from JLDAP to Apache Directory LDAP API</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-309">GUACAMOLE-309</a> - LDAP error details not properly logged</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-717">GUACAMOLE-717</a> - LDAP authentication fails if search result count exceeds ldap-max-search-result</li>
</ul>

<h3 id="accessing-active-sessions-without-share-links">Accessing active sessions without share links</h3>

<p>When using an extension which supports active connection tracking, such as the
<a href="/doc/1.1.0/gug/jdbc-auth.html">various supported databases</a>, users can join
active connections to which they have access without having to generate share
links, even if those active connections were established from a different
machine. Non-administrative users can join their own connections, while
administrative users can join any active connection.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-360">GUACAMOLE-360</a> - Autoreconnect only most recent session</li>
</ul>

<h3 id="dynamic-image-quality-adjustment">Dynamic image quality adjustment</h3>

<p>Since the 0.9.9 release, Guacamole has <a href="/releases/0.9.9/#dynamic-jpegwebp-compression">automatically used JPEG or WebP
compression</a> when heuristics
detect that doing so is appropriate. The quality of JPEG and WebP compression
is now also adjusted dynamically based on performance measurements of the
connected client.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-632">GUACAMOLE-632</a> - Dynamically adjust JPEG/WebP quality</li>
</ul>

<h3 id="support-for-connecting-to-kubernetes-pods">Support for connecting to Kubernetes pods</h3>

<p>Similar to Guacamole’s support for <a href="/doc/1.1.0/gug/configuring-guacamole.html#ssh">SSH</a>
and <a href="/doc/1.1.0/gug/configuring-guacamole.html#telnet">telnet</a>, Guacamole can
now provide terminal access to <a href="/doc/1.1.0/gug/configuring-guacamole.html#kubernetes">Kubernetes pods</a>
using the same mechanism as <code class="language-plaintext highlighter-rouge">kubectl attach</code>. This allows Guacamole to be used
to interact with Kubernetes pods without requiring that those pods host an SSH
or telnet service.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-623">GUACAMOLE-623</a> - Add support for attaching to Kubernetes pods</li>
</ul>

<h3 id="improvements-to-docker-images">Improvements to Docker images</h3>

<p>Additional configuration options are now available for the Docker images,
including additional authentication extensions and the ability to change the
web application’s log level. An issue which prevented validation of RDP
certificates by the guacd image has been corrected, and environment variables
have been added for all LDAP properties that were previously missing
corresponding variables.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-146">GUACAMOLE-146</a> - Finer control of the tomcat context path in Docker</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-271">GUACAMOLE-271</a> - Duo in docker image</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-626">GUACAMOLE-626</a> - Add support for Docker secrets to startup.sh</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-674">GUACAMOLE-674</a> - Pass-through LDAP member attribute env variable in Docker start script</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-682">GUACAMOLE-682</a> - Add option to build client docker with RADIUS support</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-683">GUACAMOLE-683</a> - Openid support for docker</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-688">GUACAMOLE-688</a> - Docker Version ldap-user-search-filter is missing</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-694">GUACAMOLE-694</a> - guacd docker container can’t validate RDP certificate</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-704">GUACAMOLE-704</a> - LDAP Follow Referrals for Docker Container</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-713">GUACAMOLE-713</a> - Add configuration setting for logback logging verbosity level</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-716">GUACAMOLE-716</a> - Add all LDAP properties to Docker start script</li>
</ul>

<h3 id="changing-terminal-color-scheme-of-active-connections">Changing terminal color scheme of active connections</h3>

<p>The parameters of Guacamole connections generally can only be changed prior to
establishing the connection. This restriction continues to hold true for
sensitive parameters, but has been relaxed for parameters which control the
appearance of Guacamole’s terminal emulator.</p>

<p>The Guacamole protocol has been updated to define a means of temporarily
applying connection parameter changes to an active connection, while
restricting the parameters that can be changed such that the nature of the
connection is still controlled by the administrator. These changes to the
protocol are leveraged by the Guacamole webapp to present a terminal color
scheme editor within the Guacamole menu that can be used to change the terminal
appearance while the connection is active.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-629">GUACAMOLE-629</a> - Stream protocol argument values</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-630">GUACAMOLE-630</a> - Allow terminal color scheme to be changed while connection is running</li>
</ul>

<h3 id="terminal-emulator-improvements">Terminal emulator improvements</h3>

<p>The general behavior of Guacamole’s terminal emulator has been improved to more
closely match the behavior of native terminal emulators with respect to how
text is selected and deselected, and the maximum scrollback buffer size can now
be configured.</p>

<p>For the sake of automating interaction with terminal sessions, the behavior of
terminal output that has been redirected to pipe streams can now be forced to
flush immediately and/or to additionally render within the terminal, and <a href="/doc/1.1.0/gug/configuring-guacamole.html#ssh-stdin-pipe">user
input can be supplied using a pipe stream</a>,
independent of key events.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-191">GUACAMOLE-191</a> - Allow deselection of text in terminal by single clicking</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-441">GUACAMOLE-441</a> - guacd ssh plugin segfault when copy text to clipboard</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-573">GUACAMOLE-573</a> - Allow selection of text in terminal while scrolling</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-574">GUACAMOLE-574</a> - Allow terminal input to be read from an inbound pipe stream</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-597">GUACAMOLE-597</a> - Allow fine-grained control of terminal output redirection via pipe streams</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-610">GUACAMOLE-610</a> - Allow scrollback buffer size to be configured</li>
</ul>

<h3 id="improvements-to-ssh-and-telnet-support">Improvements to SSH and telnet support</h3>

<p>The “none” authentication method for SSH is now supported, as may be required
by some SSH servers, and the locale of the SSH session can now be set via the
<code class="language-plaintext highlighter-rouge">LANG</code> environment variable. Handling of SSH and telnet connection errors is
also improved, allowing balancing connection groups containing SSH and telnet
connections to transparently fail over without user-visible errors.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-622">GUACAMOLE-622</a> - Allow webapp-side handling of connection errors for SSH and telnet</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-547">GUACAMOLE-547</a> - Add support for the “none” SSH authentication method</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-649">GUACAMOLE-649</a> - Allow SSH locale to be explicitly set</li>
</ul>

<h3 id="ldap-and-cas-attributes-as-parameter-tokens">LDAP and CAS attributes as parameter tokens</h3>

<p>Attributes associated with LDAP and CAS user accounts can now be passed through
as <a href="/doc/1.1.0/gug/configuring-guacamole.html#parameter-tokens">parameter tokens</a>.
The names of these tokens are derived from the names of the attributes and can
be used to alter the behavior of a connection dynamically depending on which
user is connecting.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-524">GUACAMOLE-524</a> - Allow LDAP attributes to be used as token</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-579">GUACAMOLE-579</a> - Allow CAS attributes to be used as tokens</li>
</ul>

<h3 id="improved-authentication-backend-error-handling">Improved authentication backend error handling</h3>

<p>In past versions of Guacamole, a broken authentication configuration would
typically result in the Guacamole interface not rendering at all, resulting in
a blank, white page. Guacamole will now display a generic error message if
authentication is impossible due to a server failure, and supports falling
through to other extensions as backups when explicitly configured to do so.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-598">GUACAMOLE-598</a> - Fail cleanly if authentication backend is down / misconfigured</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-611">GUACAMOLE-611</a> - Selectively fall through to other extensions when authentication fails</li>
</ul>

<h3 id="timezone-redirection-for-ssh-and-rdp">Timezone redirection for SSH and RDP</h3>

<p>Automatic pass-through of the user’s timezone is now supported for both SSH and
RDP. In the case of SSH, which doesn’t natively support timezone redirection,
this is accomplished through remotely setting the <code class="language-plaintext highlighter-rouge">TZ</code> environment variable.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-422">GUACAMOLE-422</a> - Timezone Redirection</li>
</ul>

<h2 id="internationalization">Internationalization</h2>

<h3 id="swiss-german-and-danish-keymaps-for-rdp">Swiss-German and Danish keymaps for RDP</h3>

<p>Keymaps have been added to better support RDP servers which use the
Swiss-German or Danish keyboard layouts. As always, bear in mind that <a href="/faq/#does-guacamole-support-my-keyboard-layout">the
client side of Guacamole is independent of keyboard layout</a>.
Additional keyboard layouts for RDP are mainly of benefit if:</p>

<ol>
  <li>Your RDP server does not support Unicode events.</li>
  <li>Your RDP server is set to a keyboard layout which is not the default (US English).</li>
</ol>

<p>If your RDP server is set to US English and supports Unicode events, it should
not be necessary to select a specific layout. The user’s local keyboard should
simply work, regardless of whether it matches the layout of the RDP server.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-354">GUACAMOLE-354</a> - Add Swiss-German keymap for RDP</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-712">GUACAMOLE-712</a> - Add Danish keymap</li>
</ul>

<h3 id="simplified-chinese-translation-of-web-interface">Simplified Chinese translation of web interface</h3>

<p>The web interface of Guacamole has been translated into Simplified Chinese.
Simplified Chinese will now automatically be selected if accessing Guacamole
from a browser whose default language is set to Chinese. The language can also
be <a href="/doc/gug/using-guacamole.html#display-language">manually selected</a> within
Guacamole’s preferences.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-569">GUACAMOLE-569</a> - Add translation for Simplified Chinese</li>
</ul>

<h2 id="bug-fixes">Bug fixes</h2>

<h3 id="group-permission-behavior">Group permission behavior</h3>

<p>Issues with the new support for user groups were identified following the 1.0.0
release which resulted in permissions not taking effect if granted via user
groups from different authentication extensions. These issues have now been
fixed. User group permissions should be inherited as expected, regardless of
whether user group membership is dictated by a different extension than the
permissions granted to that group.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-696">GUACAMOLE-696</a> - Apply database groups if authenticated user matches database user</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-697">GUACAMOLE-697</a> - Connection Error when permissions assigned to user and to group user is in</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-715">GUACAMOLE-715</a> - Permission management based on LDAP groups not working as documented</li>
</ul>

<h3 id="build-issues">Build issues</h3>

<p>The guacamole-server build for the 1.0.0 release and older would fail with
newer compilers due to additional warnings and with newer versions of FFmpeg
due to functions becoming deprecated. These issues have been corrected, and the
guacamole-server build should now succeed on affected platforms.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-353">GUACAMOLE-353</a> - Clarify ASF header within Makefile.am, etc. regarding build system output</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-637">GUACAMOLE-637</a> - Compile error: ‘strncpy’ output may be truncated copying 7 bytes from a string of length 7</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-638">GUACAMOLE-638</a> - Compile error: ‘avcodec_register_all’ is deprecated</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-662">GUACAMOLE-662</a> - Failing unit tests for guacamole-server not triggering build failure</li>
</ul>

<h2 id="platform--api-changes">Platform / API changes</h2>

<h3 id="deprecation-of-the-nest-instruction">Deprecation of the <code class="language-plaintext highlighter-rouge">nest</code> instruction</h3>

<p>The <a href="/doc/1.1.0/gug/protocol-reference.html#nest-stream-instruction"><code class="language-plaintext highlighter-rouge">nest</code></a>
instruction was created in the early days of the Guacamole protocol as a means
of splitting up large instructions. At the time, this was necessary because
images and audio were transmitted within instructions that required the entire
block of data to be available at once. The <code class="language-plaintext highlighter-rouge">nest</code> instruction thus provided a
means of streaming data for instructions that otherwise did not support it.</p>

<p>The Guacamole protocol switched over to instructions with actual stream
semantics around the 0.9.0 release (back in 2014). Since that time, the <code class="language-plaintext highlighter-rouge">nest</code>
instruction has become unnecessary, and is actually no longer used in practice.</p>

<p>The <code class="language-plaintext highlighter-rouge">nest</code> instruction is now marked as deprecated. It is still supported by
the JavaScript Guacamole client, but support can be expected to be removed in a
future release. Downstream usages of the Guacamole protocol which still use the
<code class="language-plaintext highlighter-rouge">nest</code> instruction should cease using it.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-661">GUACAMOLE-661</a> - Deprecate “nest” instruction</li>
</ul>

<h2 id="miscellaneous-fixesimprovements">Miscellaneous fixes/improvements</h2>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-510">GUACAMOLE-510</a> - Nested socket index is not initialized</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-571">GUACAMOLE-571</a> - Typo in homeController loading rootConnectionGroups</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-572">GUACAMOLE-572</a> - guacamole-server README says “test-based protocol” instead of “text-based protocol”</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-582">GUACAMOLE-582</a> - Manual still references Glyptodon JIRA</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-585">GUACAMOLE-585</a> - Dead code in JavaScript formField module</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-593">GUACAMOLE-593</a> - Make Member attribute customizable</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-624">GUACAMOLE-624</a> - Include user profile attributes within search filter</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-628">GUACAMOLE-628</a> - RDP mapping for Right Ctrl incorrect</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-639">GUACAMOLE-639</a> - Add installation of libtool-bin for Debian/Ubuntu</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-699">GUACAMOLE-699</a> - Multiple fixes and improvements for the german translation</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-718">GUACAMOLE-718</a> - Grammatical error in TOTP two-factor authentication manual.</li>
</ul>

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

<p>Each 1.x release of Apache Guacamole should be compatible with components of
older 1.x releases. This compatibility is intended at the Guacamole protocol
level and at the extension level, but not necessarily at the API level. This
means:</p>

<ul>
  <li>Extensions from older 1.x releases should still work in binary form, but may
need code changes before their source will build against a newer version of
guacamole-ext.</li>
  <li>Software which uses the Guacamole protocol of an older 1.x release should
still work.</li>
  <li>Software which uses libguac from an older 1.x release should still work by
continuing to use the libguac from that release, as newer versions of
libguac may not be API/ABI compatible. In the case of third-party protocol
support plugins for guacd, this means that the guacd from that release must
also be used. Compatibility with respect to libguac is represented by the
<a href="https://en.wikipedia.org/wiki/Soname">soname</a>.</li>
  <li>You should update to newer versions where applicable and when possible.</li>
</ul>

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

<h2 id="guacamole-protocol-changes">Guacamole protocol changes</h2>

<h3 id="deprecation-of-the-nest-instruction-1">Deprecation of the <code class="language-plaintext highlighter-rouge">nest</code> instruction</h3>

<p>The <a href="/doc/1.1.0/gug/protocol-reference.html#nest-stream-instruction"><code class="language-plaintext highlighter-rouge">nest</code></a>
instruction was created in the early days of the Guacamole protocol as a means
of splitting up large instructions. At the time, this was necessary because
images and audio were transmitted within instructions that required the entire
block of data to be available at once. The <code class="language-plaintext highlighter-rouge">nest</code> instruction thus provided a
means of streaming data for instructions that otherwise did not support it.</p>

<p>The Guacamole protocol switched over instructions with actual stream semantics
around the 0.9.0 release (back in 2014). Since that time, the <code class="language-plaintext highlighter-rouge">nest</code>
instruction has become unnecessary, and is actually no longer used in practice.</p>

<p>The <code class="language-plaintext highlighter-rouge">nest</code> instruction is now marked as deprecated. It is still supported by
the JavaScript Guacamole client, but support can be expected to be removed in a
future release. Downstream usages of the Guacamole protocol which still use the
<code class="language-plaintext highlighter-rouge">nest</code> instruction should cease using it.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-661">GUACAMOLE-661</a> - Deprecate “nest” instruction</li>
</ul>

<h3 id="changes-to-the-guacamole-protocol-handshake">Changes to the Guacamole protocol handshake</h3>

<p>The <a href="/doc/1.1.0/gug/guacamole-protocol.html#guacamole-protocol-handshake">Guacamole protocol handshake</a>
has been expanded with a new <a href="/doc/1.1.0/gug/protocol-reference.html#timezone-handshake-instruction"><code class="language-plaintext highlighter-rouge">timezone</code></a>
instruction to allow the Guacamole client to forward the user’s local timezone
through to the remote desktop. As the addition of a new handshake instruction
would normally make the new version of the protocol incompatible with older
versions, the handshake has also been modified to allow the Guacamole protocol
version to be negotiated, and to allow flexibility in the overall handshake:
handshake-specific instructions may now be sent in any order or omitted
entirely.</p>

<p>As these changes were made such that compatibility is preserved, downstream
usages of the Guacamole protocol should continue to work, however such usages
should be brought up to date when possible.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-422">GUACAMOLE-422</a> - Timezone Redirection</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-629">GUACAMOLE-629</a> - Stream protocol argument values</li>
</ul>

<h2 id="changes-to-guacamole-server-build-process--dependencies">Changes to guacamole-server build process / dependencies</h2>

<h3 id="install-location-for-freerdp-plugins-is-now-detected-by-configure">Install location for FreeRDP plugins is now detected by <code class="language-plaintext highlighter-rouge">configure</code></h3>

<p>The <code class="language-plaintext highlighter-rouge">configure</code> script will now automatically determine the correct install
location for FreeRDP plugins based on the location that the FreeRDP libraries
are installed. This location will be printed at the end of the summary
displayed when <code class="language-plaintext highlighter-rouge">configure</code> has finished running:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>...

   FreeRDP plugins: /usr/lib64/freerdp2
   Init scripts: no
   Systemd units: no

Type "make" to compile guacamole-server.
</code></pre></div></div>

<p>If the install location of FreeRDP plugins should not be automatically
detected, this behavior can be overridden by specifying the
<code class="language-plaintext highlighter-rouge">--with-freerdp-plugins-dir=&lt;path&gt;</code> option when running <code class="language-plaintext highlighter-rouge">configure</code>, where
<code class="language-plaintext highlighter-rouge">&lt;path&gt;</code> is the path to the desired install location.</p>

<h3 id="freerdp-200-requires-a-writable-home-directory">FreeRDP 2.0.0 requires a writable home directory</h3>

<p>The initialization process of the FreeRDP 2.0.0 library requires that the
current user have a valid, writable home directory. Attempts to connect using
RDP will fail if this is not the case, as FreeRDP will refuse to complete
initialization.</p>

<p>For Guacamole’s RDP support, this means that the user running guacd <strong>must</strong>
have a valid, writable home directory, and that RDP connections which worked as
expected in past Guacamole releases may begin failing if the user running guacd
does not have a valid home directory.</p>

<p>Sanity checks have been added to Guacamole’s RDP support which will log
warnings if these conditions are not met.</p>

<h3 id="freerdp-200-or-later-is-now-required-for-rdp-support">FreeRDP 2.0.0 or later is now required for RDP support</h3>

<p>With the addition of support for FreeRDP 2.0.0, <strong>support for older releases of
FreeRDP has been dropped</strong>. The extent of the API differences with older
versions of FreeRDP is simply too great to maintain. Downstream builds of
guacamole-server which are intended to include RDP support will need to be
updated to build against FreeRDP 2.0.0.</p>

<p><strong>Beware that “FreeRDP 2.0.0” is currently a misnomer.</strong> All versions of
FreeRDP 2.0.0 as of this writing are actually release candidates (2.0.0-rc0,
2.0.0-rc4, etc.) or git snapshots. There are incompatible API differences and
incompatible internal behavior differences between these release candidates and
between git snapshots, despite each having the same version number and
<a href="https://en.wikipedia.org/wiki/Soname">soname</a>. The FreeRDP 2.0.0 packages
provided by various distributions may not actually provide the same API, and
library functions with the same API may not actually behave in a compatible
manner, even though they otherwise appear identical to users of that
distribution.</p>

<p>The guacamole-server build has been tested against builds of FreeRDP from
source at:</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">2.0.0-rc0</code></li>
  <li><code class="language-plaintext highlighter-rouge">2.0.0-rc1</code></li>
  <li><code class="language-plaintext highlighter-rouge">2.0.0-rc2</code></li>
  <li><code class="language-plaintext highlighter-rouge">2.0.0-rc3</code></li>
  <li><code class="language-plaintext highlighter-rouge">2.0.0-rc4</code></li>
  <li>Current <code class="language-plaintext highlighter-rouge">master</code></li>
</ul>

<p>The guacamole-server build has also been tested against the builds of FreeRDP
packaged by the following specific Linux distributions:</p>

<ul>
  <li>
    <p><strong>Ubuntu 18.04 (“Bionic Beaver”)</strong></p>

    <p>The FreeRDP 2.0.0 packages provided by Ubuntu 18.04 are builds of
<strong><code class="language-plaintext highlighter-rouge">2.0.0-rc0</code></strong>.</p>
  </li>
  <li>
    <p><strong>CentOS 7</strong></p>

    <p>The FreeRDP 2.0.0 packages provided by CentOS 7 are builds of
<strong><code class="language-plaintext highlighter-rouge">2.0.0-rc4</code></strong>.</p>
  </li>
  <li>
    <p><strong>Debian stable (“Buster”)</strong>, <strong>Debian testing (“Bullseye”)</strong>, <strong>Ubuntu
19.04 (“Disco Dingo”)</strong>, and <strong>Ubuntu 19.10 (“Eoan Ermine”)</strong></p>

    <p>The FreeRDP 2.0.0 packages provided by Debian stable, Debian testing, Ubuntu
19.04, and Ubuntu 19.10 are builds of <strong>commit <code class="language-plaintext highlighter-rouge">2693389</code></strong>, a snapshot of
git <code class="language-plaintext highlighter-rouge">master</code> which is more recent than <code class="language-plaintext highlighter-rouge">2.0.0-rc4</code> (commit date is
2019-02-01).</p>
  </li>
  <li>
    <p><strong>Fedora 29</strong>, <strong>Fedora 30</strong>, and <strong>Fedora 31</strong></p>

    <p>The FreeRDP 2.0.0 packages provided by Fedora 29, 30, and 31 are builds of
<strong>commit <code class="language-plaintext highlighter-rouge">6015229</code></strong>, a snapshot of git <code class="language-plaintext highlighter-rouge">master</code> which is more recent than
<code class="language-plaintext highlighter-rouge">2.0.0-rc4</code> (commit date is 2019-08-12).</p>
  </li>
</ul>

<p>It is intended that RDP support will resume tracking and supporting FreeRDP
<code class="language-plaintext highlighter-rouge">master</code>, however it is possible that the frequency of API changes will require
support to again be restricted to releases and git tags.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-249">GUACAMOLE-249</a> - Update RDP plugin support to 2.0.0 releases</li>
</ul>

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

<h3 id="new-members-added-to-guac_user-and-guac_user_info-structures">New members added to <code class="language-plaintext highlighter-rouge">guac_user</code> and <code class="language-plaintext highlighter-rouge">guac_user_info</code> structures</h3>

<p>New members have been added to <code class="language-plaintext highlighter-rouge">guac_user</code> and <code class="language-plaintext highlighter-rouge">guac_user_info</code> which affect
the size of these structures. Additionally, because <code class="language-plaintext highlighter-rouge">guac_user_info</code> forms a
part of <code class="language-plaintext highlighter-rouge">guac_user</code>, this change also affects the memory offsets of members of
the <code class="language-plaintext highlighter-rouge">guac_user</code> structure which follow the <code class="language-plaintext highlighter-rouge">info</code> member, such as <code class="language-plaintext highlighter-rouge">data</code> and
various instruction handlers.</p>

<p>Downstream usages of libguac which make use of <code class="language-plaintext highlighter-rouge">guac_user</code> or <code class="language-plaintext highlighter-rouge">guac_user_info</code>
will need to be rebuilt to ensure that the structure sizes and memory offsets
used are correct.</p>

<ul>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-422">GUACAMOLE-422</a> - Timezone Redirection</li>
  <li><a href="https://issues.apache.org/jira/browse/GUACAMOLE-629">GUACAMOLE-629</a> - Stream protocol argument values</li>
</ul>


    </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>
