XFREERDP(1)                        xfreerdp                        XFREERDP(1)


                 .SH "NAME" xfreerdp - FreeRDP X11 client

     .SH "SYNOPSIS"

           .PP xxffrreeeerrddpp [file] [options] [/v:server[:port]]

           .SH "DESCRIPTION"

                 .PP xxffrreeeerrddpp is an X11 Remote Desktop Protocol (RDP) client
which is part of the FreeRDP project. An RDP server is built-in to many
editions of Windows. Alternative servers included xrdp and VRDP (VirtualBox).


     .SH "OPTIONS"


               .PP //aa:_a_d_d_i_n[,_o_p_t_i_o_n_s], //aaddddiinn:_a_d_d_i_n[,_o_p_t_i_o_n_s]


                                    Addin

                                               .RE                .PP
           //aaccttiioonn--ssccrriipptt:_f_i_l_e_-_n_a_m_e


                                        Action script
               (default:~/.config/freerdp/action.sh)

                                                   .RE                .PP
               //aaddmmiinn, //ccoonnssoollee


                                                                 Admin (or
                   console) session

                                                       .RE                .PP
                   ++aaeerroo


                                                desktop composition
                       (default:off)

                                                           .RE
                                      .PP //aapppp:_p_a_t_h or ||_a_l_i_a_s


                                                    Remote application program

                                                               .RE
                                          .PP //aapppp--ccmmdd:_p_a_r_a_m_e_t_e_r_s


                                                        Remote application
                               command-line parameters

                                                                   .RE
                                              .PP //aapppp--ffiillee:_f_i_l_e_-_n_a_m_e


                                                            File to open with
                                   remote application

                                                                       .RE
                                                  .PP //aapppp--gguuiidd:_a_p_p_-_g_u_i_d


                                                                Remote
                                       application GUID

                                                                           .RE
                                                      .PP //aapppp--iiccoonn:_i_c_o_n_-_p_a_t_h


                                                                    Remote
                                           application icon for user interface


                                                          .RE
                                                          .PP
                                           //aapppp--nnaammee:_a_p_p_-_n_a_m_e


                                                                        Remote
                                               application name for user
                                               interface


                                                              .RE
                                                              .PP
                                               //aassssiissttaannccee:_p_a_s_s_w_o_r_d


                                                                            Remote
                                                   assistance password


                                                                  .RE
                                                                  .PP
                                                   ++aassyynncc--cchhaannnneellss


                                                                                Asynchronous
                                                       channels (experimental)
                                                       (default:off)


                                                                      .RE
                                                                      .PP
                                                       ++aassyynncc--iinnppuutt


                                                                                    Asynchronous
                                                           input (default:off)


                                                                          .RE
                                                                          .PP
                                                           ++aassyynncc--uuppddaattee


                                                                                        Asynchronous
                                                               update
                                                               (default:off)


                                                                              .RE
                                                                              .PP
                                                               //aauuddiioo--mmooddee:_m_o_d_e


                                                                                            Audio
                                                                   output mode


                                                                                  .RE
                                                                                  .PP
                                                                   ++aauutthh--oonnllyy


                                                                                                Authenticate
                                                                       only
                                                                       (default:off)


                                                                                      .RE
                                                                                      .PP
                                                                       --aauutthheennttiiccaattiioonn


                                                                                                    Authentication
                                                                           (expermiental)
                                                                           (default:on)


                                                                                          .RE
                                                                                          .PP
                                                                           ++aauuttoo--rreeccoonnnneecctt


                                                                                                        Automatic
                                                                               reconnection
                                                                               (default:off)


                                                                                              .RE
                                                                                              .PP
                                                                               //aauuttoo--rreeccoonnnneecctt--mmaaxx--rreettrriieess:_r_e_t_r_i_e_s


                                                                                                            Automatic
                                                                                   reconnection
                                                                                   maximum
                                                                                   retries,
                                                                                   0
                                                                                   for
                                                                                   unlimited
                                                                                   [0,1000]


                                                                                                  .RE
                                                                                                  .PP
                                                                                   --bbiittmmaapp--ccaacchhee


                                                                                                                bitmap
                                                                                       cache
                                                                                       (default:on)


                                                                                                      .RE
                                                                                                      .PP
                                                                                       //bbpppp:_d_e_p_t_h


                                                                                                                    Session
                                                                                           bpp
                                                                                           (color
                                                                                           depth)
                                                                                           (default:16)


                                                                                                          .RE
                                                                                                          .PP
                                                                                           //bbuuiillddccoonnffiigg


                                                                                                                        Print
                                                                                               the
                                                                                               build
                                                                                               configuration


                                                                                                              .RE
                                                                                                              .PP
                                                                                               //cceerrtt--iiggnnoorree


                                                                                                                            Ignore
                                                                                                   certificate


                                                                                                                  .RE
                                                                                                                  .PP
                                                                                                   //cceerrtt--nnaammee:_n_a_m_e


                                                                                                                                Certificate
                                                                                                       name


                                                                                                                      .RE
                                                                                                                      .PP
                                                                                                       //cceerrtt--ttooffuu


                                                                                                                                    Automatically
                                                                                                           accept
                                                                                                           certificate
                                                                                                           on
                                                                                                           first
                                                                                                           connect


                                                                                                                          .RE
                                                                                                                          .PP
                                                                                                           //cclliieenntt--hhoossttnnaammee:_n_a_m_e


                                                                                                                                        Client
                                                                                                               Hostname
                                                                                                               to
                                                                                                               send
                                                                                                               to
                                                                                                               server


                                                                                                                              .RE
                                                                                                                              .PP
                                                                                                               --cclliippbbooaarrdd


                                                                                                                                            Redirect
                                                                                                                   clipboard
                                                                                                                   (default:on)


                                                                                                                                  .RE
                                                                                                                                  .PP
                                                                                                                   //ccooddeecc--ccaacchhee:rfx|nsc|jpeg


                                                                                                                                                Bitmap
                                                                                                                       codec
                                                                                                                       cache


                                                                                                                                      .RE
                                                                                                                                      .PP
                                                                                                                       --ccoommpprreessssiioonn,
                                                                                                                       --zz


                                                                                                                                                    compression
                                                                                                                           (default:on)


                                                                                                                                          .RE
                                                                                                                                          .PP
                                                                                                                           //ccoommpprreessssiioonn--lleevveell:_l_e_v_e_l


                                                                                                                                                        Compression
                                                                                                                               level
                                                                                                                               (0,1,2)


                                                                                                                                              .RE
                                                                                                                                              .PP
                                                                                                                               ++ccrreeddeennttiiaallss--ddeelleeggaattiioonn


                                                                                                                                                            credentials
                                                                                                                                   delegation
                                                                                                                                   (default:off)


                                                                                                                                                  .RE
                                                                                                                                                  .PP
                                                                                                                                   //dd:_d_o_m_a_i_n


                                                                                                                                                                Domain


                                                                                                                                                      .RE
                                                                                                                                                      .PP
                                                                                                                                       --ddeeccoorraattiioonnss


                                                                                                                                                                    Window
                                                                                                                                           decorations
                                                                                                                                           (default:on)


                                                                                                                                                          .RE
                                                                                                                                                          .PP
                                                                                                                                           //ddiisspp


                                                                                                                                                                        Display
                                                                                                                                               control


                                                                                                                                                              .RE
                                                                                                                                                              .PP
                                                                                                                                               //ddrriivvee:_n_a_m_e,_p_a_t_h


                                                                                                                                                                            Redirect
                                                                                                                                                   directory
                                                                                                                                                   <path<
                                                                                                                                                   as
                                                                                                                                                   named
                                                                                                                                                   share
                                                                                                                                                   <name<


                                                                                                                                                                  .RE
                                                                                                                                                                  .PP
                                                                                                                                                   ++ddrriivveess


                                                                                                                                                                                Redirect
                                                                                                                                                       all
                                                                                                                                                       mount
                                                                                                                                                       points
                                                                                                                                                       as
                                                                                                                                                       shares
                                                                                                                                                       (default:off)


                                                                                                                                                                      .RE
                                                                                                                                                                      .PP
                                                                                                                                                       //ddvvcc:_c_h_a_n_n_e_l[,_o_p_t_i_o_n_s]


                                                                                                                                                                                    Dynamic
                                                                                                                                                           virtual
                                                                                                                                                           channel


                                                                                                                                                                          .RE
                                                                                                                                                                          .PP
                                                                                                                                                           //ddyynnaammiicc--rreessoolluuttiioonn


                                                                                                                                                                                        Send
                                                                                                                                                               resolution
                                                                                                                                                               updates
                                                                                                                                                               when
                                                                                                                                                               the
                                                                                                                                                               window
                                                                                                                                                               is
                                                                                                                                                               resized


                                                                                                                                                                              .RE
                                                                                                                                                                              .PP
                                                                                                                                                               //eecchhoo,
                                                                                                                                                               //eecchhoo


                                                                                                                                                                                            Echo
                                                                                                                                                                   channel


                                                                                                                                                                                  .RE
                                                                                                                                                                                  .PP
                                                                                                                                                                   --eennccrryyppttiioonn


                                                                                                                                                                                                Encryption
                                                                                                                                                                       (experimental)
                                                                                                                                                                       (default:on)


                                                                                                                                                                                      .RE
                                                                                                                                                                                      .PP
                                                                                                                                                                       //eennccrryyppttiioonn--mmeetthhooddss:[40,][56,][128,][FIPS]


                                                                                                                                                                                                    RDP
                                                                                                                                                                           standard
                                                                                                                                                                           security
                                                                                                                                                                           encryption
                                                                                                                                                                           methods


                                                                                                                                                                                          .RE
                                                                                                                                                                                          .PP
                                                                                                                                                                           //ff


                                                                                                                                                                                                        Fullscreen
                                                                                                                                                                               mode
                                                                                                                                                                               (<Ctrl<+<Alt<+<Enter<
                                                                                                                                                                               toggles
                                                                                                                                                                               fullscreen)


                                                                                                                                                                                              .RE
                                                                                                                                                                                              .PP
                                                                                                                                                                               --ffaasstt--ppaatthh


                                                                                                                                                                                                            fast-path
                                                                                                                                                                                   input/output
                                                                                                                                                                                   (default:on)


                                                                                                                                                                                                  .RE
                                                                                                                                                                                                  .PP
                                                                                                                                                                                   ++ffiippssmmooddee


                                                                                                                                                                                                                FIPS
                                                                                                                                                                                       mode
                                                                                                                                                                                       (default:off)


                                                                                                                                                                                                      .RE
                                                                                                                                                                                                      .PP
                                                                                                                                                                                       --ffllooaattbbaarr


                                                                                                                                                                                                                    floatbar
                                                                                                                                                                                           in
                                                                                                                                                                                           fullscreen
                                                                                                                                                                                           mode
                                                                                                                                                                                           (default:on)


                                                                                                                                                                                                          .RE
                                                                                                                                                                                                          .PP
                                                                                                                                                                                           ++ffoonnttss


                                                                                                                                                                                                                        smooth
                                                                                                                                                                                               fonts
                                                                                                                                                                                               (ClearType)
                                                                                                                                                                                               (default:off)


                                                                                                                                                                                                              .RE
                                                                                                                                                                                                              .PP
                                                                                                                                                                                               //ffrraammee--aacckk:_n_u_m_b_e_r


                                                                                                                                                                                                                            Number
                                                                                                                                                                                                   of
                                                                                                                                                                                                   frame
                                                                                                                                                                                                   acknowledgement


                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                   //ffrroomm--ssttddiinn[:force]


                                                                                                                                                                                                                                Read
                                                                                                                                                                                                       credentials
                                                                                                                                                                                                       from
                                                                                                                                                                                                       stdin.
                                                                                                                                                                                                       With
                                                                                                                                                                                                       <force<
                                                                                                                                                                                                       the
                                                                                                                                                                                                       prompt
                                                                                                                                                                                                       is
                                                                                                                                                                                                       done
                                                                                                                                                                                                       before
                                                                                                                                                                                                       connection,
                                                                                                                                                                                                       otherwise
                                                                                                                                                                                                       on
                                                                                                                                                                                                       server
                                                                                                                                                                                                       request.


                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                       //gg:_g_a_t_e_w_a_y[:_p_o_r_t]


                                                                                                                                                                                                                                    Gateway
                                                                                                                                                                                                           Hostname


                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                           //ggaatteewwaayy--uussaaggee--mmeetthhoodd:direct|detect,
                                                                                                                                                                                                           //gguumm:direct|detect


                                                                                                                                                                                                                                        Gateway
                                                                                                                                                                                                               usage
                                                                                                                                                                                                               method


                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                               //ggdd:_d_o_m_a_i_n


                                                                                                                                                                                                                                            Gateway
                                                                                                                                                                                                                   domain


                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                   //ggddii:sw|hw


                                                                                                                                                                                                                                                GDI
                                                                                                                                                                                                                       rendering


                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                       //ggeeoommeettrryy


                                                                                                                                                                                                                                                    Geometry
                                                                                                                                                                                                                           tracking
                                                                                                                                                                                                                           channel


                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                           ++ggeessttuurreess


                                                                                                                                                                                                                                                        Consume
                                                                                                                                                                                                                               multitouch
                                                                                                                                                                                                                               input
                                                                                                                                                                                                                               locally
                                                                                                                                                                                                                               (default:off)


                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                               //ggffxx[:RFX]


                                                                                                                                                                                                                                                            RDP8
                                                                                                                                                                                                                                   graphics
                                                                                                                                                                                                                                   pipeline
                                                                                                                                                                                                                                   (experimental)


                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                   ++ggffxx--pprrooggrreessssiivvee


                                                                                                                                                                                                                                                                RDP8
                                                                                                                                                                                                                                       graphics
                                                                                                                                                                                                                                       pipeline
                                                                                                                                                                                                                                       using
                                                                                                                                                                                                                                       progressive
                                                                                                                                                                                                                                       codec
                                                                                                                                                                                                                                       (default:off)


                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                       ++ggffxx--ssmmaallll--ccaacchhee


                                                                                                                                                                                                                                                                    RDP8
                                                                                                                                                                                                                                           graphics
                                                                                                                                                                                                                                           pipeline
                                                                                                                                                                                                                                           using
                                                                                                                                                                                                                                           small
                                                                                                                                                                                                                                           cache
                                                                                                                                                                                                                                           mode
                                                                                                                                                                                                                                           (default:off)


                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                           ++ggffxx--tthhiinn--cclliieenntt


                                                                                                                                                                                                                                                                        RDP8
                                                                                                                                                                                                                                               graphics
                                                                                                                                                                                                                                               pipeline
                                                                                                                                                                                                                                               using
                                                                                                                                                                                                                                               thin
                                                                                                                                                                                                                                               client
                                                                                                                                                                                                                                               mode
                                                                                                                                                                                                                                               (default:off)


                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                               ++ggllyypphh--ccaacchhee


                                                                                                                                                                                                                                                                            Glyph
                                                                                                                                                                                                                                                   cache
                                                                                                                                                                                                                                                   (experimental)
                                                                                                                                                                                                                                                   (default:off)


                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                   //ggpp:_p_a_s_s_w_o_r_d


                                                                                                                                                                                                                                                                                Gateway
                                                                                                                                                                                                                                                       password


                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                       --ggrraabb--kkeeyybbooaarrdd


                                                                                                                                                                                                                                                                                    Grab
                                                                                                                                                                                                                                                           keyboard
                                                                                                                                                                                                                                                           (default:on)


                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                           //ggtt:rpc|http|auto


                                                                                                                                                                                                                                                                                        Gateway
                                                                                                                                                                                                                                                               transport
                                                                                                                                                                                                                                                               type


                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                               //gguu:[_d_o_m_a_i_n\]_u_s_e_r
                                                                                                                                                                                                                                                               or
                                                                                                                                                                                                                                                               _u_s_e_r[@_d_o_m_a_i_n]


                                                                                                                                                                                                                                                                                            Gateway
                                                                                                                                                                                                                                                                   username


                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                   //ggaatt:_a_c_c_e_s_s
                                                                                                                                                                                                                                                                   _t_o_k_e_n


                                                                                                                                                                                                                                                                                                Gateway
                                                                                                                                                                                                                                                                       Access
                                                                                                                                                                                                                                                                       Token


                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                       //hh:_h_e_i_g_h_t


                                                                                                                                                                                                                                                                                                    Height
                                                                                                                                                                                                                                                                           (default:768)


                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                           ++hheeaarrttbbeeaatt


                                                                                                                                                                                                                                                                                                        Support
                                                                                                                                                                                                                                                                               heartbeat
                                                                                                                                                                                                                                                                               PDUs
                                                                                                                                                                                                                                                                               (default:off)


                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                               //hheellpp,
                                                                                                                                                                                                                                                                               //??


                                                                                                                                                                                                                                                                                                            Print
                                                                                                                                                                                                                                                                                   help


                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                   ++hhoommee--ddrriivvee


                                                                                                                                                                                                                                                                                                                Redirect
                                                                                                                                                                                                                                                                                       user
                                                                                                                                                                                                                                                                                       home
                                                                                                                                                                                                                                                                                       as
                                                                                                                                                                                                                                                                                       share
                                                                                                                                                                                                                                                                                       (default:off)


                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                       //iippvv66,
                                                                                                                                                                                                                                                                                       //66


                                                                                                                                                                                                                                                                                                                    Prefer
                                                                                                                                                                                                                                                                                           IPv6
                                                                                                                                                                                                                                                                                           AAA
                                                                                                                                                                                                                                                                                           record
                                                                                                                                                                                                                                                                                           over
                                                                                                                                                                                                                                                                                           IPv4
                                                                                                                                                                                                                                                                                           A
                                                                                                                                                                                                                                                                                           record


                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                           //kkbbdd:0x_i_d
                                                                                                                                                                                                                                                                                           or
                                                                                                                                                                                                                                                                                           _n_a_m_e


                                                                                                                                                                                                                                                                                                                        Keyboard
                                                                                                                                                                                                                                                                                               layout


                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                               //kkbbdd--ffnn--kkeeyy:_v_a_l_u_e


                                                                                                                                                                                                                                                                                                                            Function
                                                                                                                                                                                                                                                                                                   key
                                                                                                                                                                                                                                                                                                   value


                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                   //kkbbdd--lliisstt


                                                                                                                                                                                                                                                                                                                                List
                                                                                                                                                                                                                                                                                                       keyboard
                                                                                                                                                                                                                                                                                                       layouts


                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                       //kkbbdd--ssuubbttyyppee:_i_d


                                                                                                                                                                                                                                                                                                                                    Keyboard
                                                                                                                                                                                                                                                                                                           subtype


                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                           //kkbbdd--ttyyppee:_i_d


                                                                                                                                                                                                                                                                                                                                        Keyboard
                                                                                                                                                                                                                                                                                                               type


                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                               //llooaadd--bbaallaannccee--iinnffoo:_i_n_f_o_-_s_t_r_i_n_g


                                                                                                                                                                                                                                                                                                                                            Load
                                                                                                                                                                                                                                                                                                                   balance
                                                                                                                                                                                                                                                                                                                   info


                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                   //lloogg--ffiilltteerrss:_t_a_g:_l_e_v_e_l[,_t_a_g:_l_e_v_e_l[,...]]


                                                                                                                                                                                                                                                                                                                                                Set
                                                                                                                                                                                                                                                                                                                       logger
                                                                                                                                                                                                                                                                                                                       filters,
                                                                                                                                                                                                                                                                                                                       see
                                                                                                                                                                                                                                                                                                                       wLog(7)
                                                                                                                                                                                                                                                                                                                       for
                                                                                                                                                                                                                                                                                                                       details


                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                       //lloogg--lleevveell:OFF|FATAL|ERROR|WARN|INFO|DEBUG|TRACE


                                                                                                                                                                                                                                                                                                                                                    Set
                                                                                                                                                                                                                                                                                                                           the
                                                                                                                                                                                                                                                                                                                           default
                                                                                                                                                                                                                                                                                                                           log
                                                                                                                                                                                                                                                                                                                           level,
                                                                                                                                                                                                                                                                                                                           see
                                                                                                                                                                                                                                                                                                                           wLog(7)
                                                                                                                                                                                                                                                                                                                           for
                                                                                                                                                                                                                                                                                                                           details


                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                           //mmaaxx--ffaasstt--ppaatthh--ssiizzee:_s_i_z_e


                                                                                                                                                                                                                                                                                                                                                        Specify
                                                                                                                                                                                                                                                                                                                               maximum
                                                                                                                                                                                                                                                                                                                               fast-path
                                                                                                                                                                                                                                                                                                                               update
                                                                                                                                                                                                                                                                                                                               size


                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                               //mmaaxx--lloooopp--ttiimmee:_t_i_m_e


                                                                                                                                                                                                                                                                                                                                                            Specify
                                                                                                                                                                                                                                                                                                                                   maximum
                                                                                                                                                                                                                                                                                                                                   time
                                                                                                                                                                                                                                                                                                                                   in
                                                                                                                                                                                                                                                                                                                                   milliseconds
                                                                                                                                                                                                                                                                                                                                   spend
                                                                                                                                                                                                                                                                                                                                   treating
                                                                                                                                                                                                                                                                                                                                   packets


                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                   ++mmeennuu--aanniimmss


                                                                                                                                                                                                                                                                                                                                                                menu
                                                                                                                                                                                                                                                                                                                                       animations
                                                                                                                                                                                                                                                                                                                                       (default:off)


                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                       //mmiiccrroopphhoonnee[:[sys:_s_y_s,][dev:_d_e_v,][format:_f_o_r_m_a_t,][rate:_r_a_t_e,][channel:_c_h_a_n_n_e_l]],
                                                                                                                                                                                                                                                                                                                                       //mmiicc[:[sys:_s_y_s,][dev:_d_e_v,][format:_f_o_r_m_a_t,][rate:_r_a_t_e,][channel:_c_h_a_n_n_e_l]]


                                                                                                                                                                                                                                                                                                                                                                    Audio
                                                                                                                                                                                                                                                                                                                                           input
                                                                                                                                                                                                                                                                                                                                           (microphone)


                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                           //mmoonniittoorr--lliisstt


                                                                                                                                                                                                                                                                                                                                                                        List
                                                                                                                                                                                                                                                                                                                                               detected
                                                                                                                                                                                                                                                                                                                                               monitors


                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                               //mmoonniittoorrss:_i_d[,_i_d[,...]]


                                                                                                                                                                                                                                                                                                                                                                            Select
                                                                                                                                                                                                                                                                                                                                                   monitors
                                                                                                                                                                                                                                                                                                                                                   to
                                                                                                                                                                                                                                                                                                                                                   use


                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                   --mmoouussee--mmoottiioonn


                                                                                                                                                                                                                                                                                                                                                                                Send
                                                                                                                                                                                                                                                                                                                                                       mouse
                                                                                                                                                                                                                                                                                                                                                       motion
                                                                                                                                                                                                                                                                                                                                                       (default:on)


                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                       //mmuullttiimmeeddiiaa[:[sys:_s_y_s,][dev:_d_e_v,][decoder:_d_e_c_o_d_e_r]],
                                                                                                                                                                                                                                                                                                                                                       //mmmmrr[:[sys:_s_y_s,][dev:_d_e_v,][decoder:_d_e_c_o_d_e_r]]


                                                                                                                                                                                                                                                                                                                                                                                    Redirect
                                                                                                                                                                                                                                                                                                                                                           multimedia
                                                                                                                                                                                                                                                                                                                                                           (video)


                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                           //mmuullttiimmoonn[:force]


                                                                                                                                                                                                                                                                                                                                                                                        Use
                                                                                                                                                                                                                                                                                                                                                               multiple
                                                                                                                                                                                                                                                                                                                                                               monitors


                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                               ++mmuullttiittoouucchh


                                                                                                                                                                                                                                                                                                                                                                                            Redirect
                                                                                                                                                                                                                                                                                                                                                                   multitouch
                                                                                                                                                                                                                                                                                                                                                                   input
                                                                                                                                                                                                                                                                                                                                                                   (default:off)


                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                   ++mmuullttiittrraannssppoorrtt


                                                                                                                                                                                                                                                                                                                                                                                                Support
                                                                                                                                                                                                                                                                                                                                                                       multitransport
                                                                                                                                                                                                                                                                                                                                                                       protocol
                                                                                                                                                                                                                                                                                                                                                                       (default:off)


                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                       --nneeggoo


                                                                                                                                                                                                                                                                                                                                                                                                    protocol
                                                                                                                                                                                                                                                                                                                                                                           security
                                                                                                                                                                                                                                                                                                                                                                           negotiation
                                                                                                                                                                                                                                                                                                                                                                           (default:on)


                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                           //nneettwwoorrkk:modem|broadband|broadband-low|broadband-high|wan|lan|auto


                                                                                                                                                                                                                                                                                                                                                                                                        Network
                                                                                                                                                                                                                                                                                                                                                                               connection
                                                                                                                                                                                                                                                                                                                                                                               type


                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                               //nnsscc,
                                                                                                                                                                                                                                                                                                                                                                               //nnssccooddeecc


                                                                                                                                                                                                                                                                                                                                                                                                            NSCodec
                                                                                                                                                                                                                                                                                                                                                                                   support


                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                   --ooffffssccrreeeenn--ccaacchhee


                                                                                                                                                                                                                                                                                                                                                                                                                offscreen
                                                                                                                                                                                                                                                                                                                                                                                       bitmap
                                                                                                                                                                                                                                                                                                                                                                                       cache
                                                                                                                                                                                                                                                                                                                                                                                       (default:on)


                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                       //oorriieennttaattiioonn:0|90|180|270


                                                                                                                                                                                                                                                                                                                                                                                                                    Orientation
                                                                                                                                                                                                                                                                                                                                                                                           of
                                                                                                                                                                                                                                                                                                                                                                                           display
                                                                                                                                                                                                                                                                                                                                                                                           in
                                                                                                                                                                                                                                                                                                                                                                                           degrees


                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                           ++oolldd--lliicceennssee


                                                                                                                                                                                                                                                                                                                                                                                                                        Use
                                                                                                                                                                                                                                                                                                                                                                                               the
                                                                                                                                                                                                                                                                                                                                                                                               old
                                                                                                                                                                                                                                                                                                                                                                                               license
                                                                                                                                                                                                                                                                                                                                                                                               workflow
                                                                                                                                                                                                                                                                                                                                                                                               (no
                                                                                                                                                                                                                                                                                                                                                                                               CAL
                                                                                                                                                                                                                                                                                                                                                                                               and
                                                                                                                                                                                                                                                                                                                                                                                               hwId
                                                                                                                                                                                                                                                                                                                                                                                               set
                                                                                                                                                                                                                                                                                                                                                                                               to
                                                                                                                                                                                                                                                                                                                                                                                               0)
                                                                                                                                                                                                                                                                                                                                                                                               (default:off)


                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                               //pp:_p_a_s_s_w_o_r_d


                                                                                                                                                                                                                                                                                                                                                                                                                            Password


                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                   //ppaarraalllleell[:_n_a_m_e[,_p_a_t_h]]


                                                                                                                                                                                                                                                                                                                                                                                                                                Redirect
                                                                                                                                                                                                                                                                                                                                                                                                       parallel
                                                                                                                                                                                                                                                                                                                                                                                                       device


                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                       //ppaarreenntt--wwiinnddooww:_w_i_n_d_o_w_-_i_d


                                                                                                                                                                                                                                                                                                                                                                                                                                    Parent
                                                                                                                                                                                                                                                                                                                                                                                                           window
                                                                                                                                                                                                                                                                                                                                                                                                           id


                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                           ++ppaasssswwoorrdd--iiss--ppiinn


                                                                                                                                                                                                                                                                                                                                                                                                                                        Use
                                                                                                                                                                                                                                                                                                                                                                                                               smart
                                                                                                                                                                                                                                                                                                                                                                                                               card
                                                                                                                                                                                                                                                                                                                                                                                                               authentication
                                                                                                                                                                                                                                                                                                                                                                                                               with
                                                                                                                                                                                                                                                                                                                                                                                                               password
                                                                                                                                                                                                                                                                                                                                                                                                               as
                                                                                                                                                                                                                                                                                                                                                                                                               smart
                                                                                                                                                                                                                                                                                                                                                                                                               card
                                                                                                                                                                                                                                                                                                                                                                                                               PIN
                                                                                                                                                                                                                                                                                                                                                                                                               (default:off)


                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                               //ppccbb:_b_l_o_b


                                                                                                                                                                                                                                                                                                                                                                                                                                            Preconnection
                                                                                                                                                                                                                                                                                                                                                                                                                   Blob


                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                   //ppcciidd:_i_d


                                                                                                                                                                                                                                                                                                                                                                                                                                                Preconnection
                                                                                                                                                                                                                                                                                                                                                                                                                       Id


                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                       //pphheeiigghhtt:_h_e_i_g_h_t


                                                                                                                                                                                                                                                                                                                                                                                                                                                    Physical
                                                                                                                                                                                                                                                                                                                                                                                                                           height
                                                                                                                                                                                                                                                                                                                                                                                                                           of
                                                                                                                                                                                                                                                                                                                                                                                                                           display
                                                                                                                                                                                                                                                                                                                                                                                                                           (in
                                                                                                                                                                                                                                                                                                                                                                                                                           millimeters)


                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                           //ppllaayy--rrffxx:_p_c_a_p_-_f_i_l_e


                                                                                                                                                                                                                                                                                                                                                                                                                                                        Replay
                                                                                                                                                                                                                                                                                                                                                                                                                               rfx
                                                                                                                                                                                                                                                                                                                                                                                                                               pcap
                                                                                                                                                                                                                                                                                                                                                                                                                               file


                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                               //ppoorrtt:_n_u_m_b_e_r


                                                                                                                                                                                                                                                                                                                                                                                                                                                            Server
                                                                                                                                                                                                                                                                                                                                                                                                                                   port


                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                   ++pprriinntt--rreeccoonnnneecctt--ccooookkiiee


                                                                                                                                                                                                                                                                                                                                                                                                                                                                Print
                                                                                                                                                                                                                                                                                                                                                                                                                                       base64
                                                                                                                                                                                                                                                                                                                                                                                                                                       reconnect
                                                                                                                                                                                                                                                                                                                                                                                                                                       cookie
                                                                                                                                                                                                                                                                                                                                                                                                                                       after
                                                                                                                                                                                                                                                                                                                                                                                                                                       connecting
                                                                                                                                                                                                                                                                                                                                                                                                                                       (default:off)


                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                       //pprriinntteerr[:_n_a_m_e[,_d_r_i_v_e_r]]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Redirect
                                                                                                                                                                                                                                                                                                                                                                                                                                           printer
                                                                                                                                                                                                                                                                                                                                                                                                                                           device


                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                           //pprrooxxyy:[_p_r_o_t_o://][_u_s_e_r:_p_a_s_s_w_o_r_d@]_h_o_s_t:_p_o_r_t


                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Proxy
                                                                                                                                                                                                                                                                                                                                                                                                                                               settings:
                                                                                                                                                                                                                                                                                                                                                                                                                                               override
                                                                                                                                                                                                                                                                                                                                                                                                                                               env.var
                                                                                                                                                                                                                                                                                                                                                                                                                                               (see
                                                                                                                                                                                                                                                                                                                                                                                                                                               also
                                                                                                                                                                                                                                                                                                                                                                                                                                               environment
                                                                                                                                                                                                                                                                                                                                                                                                                                               variable
                                                                                                                                                                                                                                                                                                                                                                                                                                               below).
                                                                                                                                                                                                                                                                                                                                                                                                                                               Protocol
                                                                                                                                                                                                                                                                                                                                                                                                                                               "socks5"
                                                                                                                                                                                                                                                                                                                                                                                                                                               should
                                                                                                                                                                                                                                                                                                                                                                                                                                               be
                                                                                                                                                                                                                                                                                                                                                                                                                                               given
                                                                                                                                                                                                                                                                                                                                                                                                                                               explicitly
                                                                                                                                                                                                                                                                                                                                                                                                                                               where
                                                                                                                                                                                                                                                                                                                                                                                                                                               "http"
                                                                                                                                                                                                                                                                                                                                                                                                                                               is
                                                                                                                                                                                                                                                                                                                                                                                                                                               default.
                                                                                                                                                                                                                                                                                                                                                                                                                                               Note:
                                                                                                                                                                                                                                                                                                                                                                                                                                               socks
                                                                                                                                                                                                                                                                                                                                                                                                                                               proxy
                                                                                                                                                                                                                                                                                                                                                                                                                                               is
                                                                                                                                                                                                                                                                                                                                                                                                                                               not
                                                                                                                                                                                                                                                                                                                                                                                                                                               supported
                                                                                                                                                                                                                                                                                                                                                                                                                                               by
                                                                                                                                                                                                                                                                                                                                                                                                                                               env.
                                                                                                                                                                                                                                                                                                                                                                                                                                               variable


                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                               //pptthh:_p_a_s_s_w_o_r_d_-_h_a_s_h,
                                                                                                                                                                                                                                                                                                                                                                                                                                               //ppaassss--tthhee--hhaasshh:_p_a_s_s_w_o_r_d_-_h_a_s_h


                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pass
                                                                                                                                                                                                                                                                                                                                                                                                                                                   the
                                                                                                                                                                                                                                                                                                                                                                                                                                                   hash
                                                                                                                                                                                                                                                                                                                                                                                                                                                   (restricted
                                                                                                                                                                                                                                                                                                                                                                                                                                                   admin
                                                                                                                                                                                                                                                                                                                                                                                                                                                   mode)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                   //ppwwiiddtthh:_w_i_d_t_h


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Physical
                                                                                                                                                                                                                                                                                                                                                                                                                                                       width
                                                                                                                                                                                                                                                                                                                                                                                                                                                       of
                                                                                                                                                                                                                                                                                                                                                                                                                                                       display
                                                                                                                                                                                                                                                                                                                                                                                                                                                       (in
                                                                                                                                                                                                                                                                                                                                                                                                                                                       millimeters)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                       //rreeccoonnnneecctt--ccooookkiiee:_b_a_s_e_6_4_-_c_o_o_k_i_e


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pass
                                                                                                                                                                                                                                                                                                                                                                                                                                                           base64
                                                                                                                                                                                                                                                                                                                                                                                                                                                           reconnect
                                                                                                                                                                                                                                                                                                                                                                                                                                                           cookie
                                                                                                                                                                                                                                                                                                                                                                                                                                                           to
                                                                                                                                                                                                                                                                                                                                                                                                                                                           the
                                                                                                                                                                                                                                                                                                                                                                                                                                                           connection


                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                           //rreeddiirreecctt--pprreeffeerr:_F_Q_D_N_|_I_P_|_N_E_T_B_I_O_S[,_F_Q_D_N_|_I_P_|_N_E_T_B_I_O_S[,_F_Q_D_N_|_I_P_|_N_E_T_B_I_O_S]]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Override
                                                                                                                                                                                                                                                                                                                                                                                                                                                               the
                                                                                                                                                                                                                                                                                                                                                                                                                                                               preferred
                                                                                                                                                                                                                                                                                                                                                                                                                                                               redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                               order


                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                               //rreellaaxx--oorrddeerr--cchheecckkss,
                                                                                                                                                                                                                                                                                                                                                                                                                                                               //rreellaaxx--oorrddeerr--cchheecckkss


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Do
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   not
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   check
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   if
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   RDP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   order
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   was
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   announced
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   during
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   capability
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   exchange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   only
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   connecting
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   buggy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   server


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //rreessttrriicctteedd--aaddmmiinn,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //rreessttrriicctteeddAAddmmiinn


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Restricted
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       admin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       mode


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //rrffxx


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RemoteFX


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //rrffxx--mmooddee:image|video


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RemoteFX
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               mode


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //ssccaallee:100|140|180


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Scaling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   factor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   display
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (default:100)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //ssccaallee--ddeesskkttoopp:_p_e_r_c_e_n_t_a_g_e


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Scaling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       factor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       desktop
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       applications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (value
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       between
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       100
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       500)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (default:100)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //ssccaallee--ddeevviiccee:100|140|180


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Scaling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           factor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           app
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           store
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           applications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (default:100)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //sseecc:rdp|tls|nla|ext


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Force
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               specific
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               protocol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               security


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ++sseecc--eexxtt


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NLA
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   extended
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   protocol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   security
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (default:off)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   --sseecc--nnllaa


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NLA
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       protocol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       security
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (default:on)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       --sseecc--rrddpp


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RDP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           protocol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           security
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (default:on)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           --sseecc--ttllss


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TLS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               protocol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               security
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (default:on)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //sseerriiaall[:_n_a_m_e[,_p_a_t_h[,_d_r_i_v_e_r[,permissive]]]],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //ttttyy[:_n_a_m_e[,_p_a_t_h[,_d_r_i_v_e_r[,permissive]]]]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Redirect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   serial
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   device


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //sshheellll:_s_h_e_l_l


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Alternate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       shell


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //sshheellll--ddiirr:_d_i_r


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Shell
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           working
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           directory


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //ssiizzee:_w_i_d_t_hx_h_e_i_g_h_t
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _p_e_r_c_e_n_t%[wh]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Screen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               size
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (default:1024x768)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //ssmmaarrtt--ssiizziinngg[:_w_i_d_t_hx_h_e_i_g_h_t]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Scale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   remote
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   desktop
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   window
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   size


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //ssmmaarrttccaarrdd[:_s_t_r[,_s_t_r...]]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Redirect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       smartcard
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       devices
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       containing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <str<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       their
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       names.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //ssmmaarrttccaarrdd--llooggoonn


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Activates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Smartcard
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Logon
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           authentication.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (EXPERIMENTAL:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           NLA
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           not
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           supported)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //ssoouunndd[:[sys:_s_y_s,][dev:_d_e_v,][format:_f_o_r_m_a_t,][rate:_r_a_t_e,][channel:_c_h_a_n_n_e_l,][latency:_l_a_t_e_n_c_y,][quality:_q_u_a_l_i_t_y]],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //aauuddiioo[:[sys:_s_y_s,][dev:_d_e_v,][format:_f_o_r_m_a_t,][rate:_r_a_t_e,][channel:_c_h_a_n_n_e_l,][latency:_l_a_t_e_n_c_y,][quality:_q_u_a_l_i_t_y]]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Audio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               output
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (sound)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //ssppaann


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Span
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   screen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   over
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   multiple
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   monitors


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //ssppnn--ccllaassss:_s_e_r_v_i_c_e_-_c_l_a_s_s


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SPN
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       authentication
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       service
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       class


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //sssshh--aaggeenntt,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //sssshh--aaggeenntt


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SSH
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Agent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           forwarding
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           channel


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //tt:_t_i_t_l_e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //ttiittllee:_t_i_t_l_e


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Window
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               title


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               --tthheemmeess


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            themes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (default:on)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //ttllss--cciipphheerrss:netmon|ma|ciphers


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Allowed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       TLS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ciphers


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //ttllss--sseecclleevveell:_l_e_v_e_l


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TLS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           security
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           level
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           defaults
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (default:1)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           --ttooggggllee--ffuullllssccrreeeenn


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Alt+Ctrl+Enter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               toggles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               fullscreen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (default:on)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //uu:[_d_o_m_a_i_n\]_u_s_e_r
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _u_s_e_r[@_d_o_m_a_i_n]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Username


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ++uunnmmaapp--bbuuttttoonnss


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Let
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       see
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       real
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       physical
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       pointer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       button
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (default:off)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //uussbb:[dbg,][dev:_d_e_v,][id|addr,][auto]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Redirect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           USB
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           device


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //vv:_s_e_r_v_e_r[:port]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               hostname


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //vvcc:_c_h_a_n_n_e_l[,_o_p_t_i_o_n_s]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Static
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   virtual
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   channel


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //vveerrssiioonn


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Print
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       version


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //vviiddeeoo


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Video
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           optimized
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           remoting
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           channel


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //vvmmccoonnnneecctt[:_v_m_i_d]


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Hyper-V
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               console
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               port
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               2179,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               disable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               negotiation)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //ww:_w_i_d_t_h


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Width
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (default:1024)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   --wwaallllppaappeerr


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                wallpaper
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (default:on)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ++wwiinnddooww--ddrraagg


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    full
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           window
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           drag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (default:off)


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //wwiinnddooww--ppoossiittiioonn:_x_p_o_sx_y_p_o_s


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        window
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               position


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //wwmm--ccllaassss:_c_l_a_s_s_-_n_a_m_e


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Set
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   WM_CLASS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   hint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   window
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   instance


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //wwoorrkkaarreeaa


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       available
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       work
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       area


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      .RE


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            .SH
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       "ENVIRONMENT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       VARIABLES"


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       wlog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       environment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       variable


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               xfreerdp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           uses
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           wLog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           as
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           its
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           log
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           facility,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           you
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           can
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           refer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           corresponding
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           man
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           page
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (wlog(7))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           more
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           informations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Arguments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           passed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           via
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _/_l_o_g_-_l_e_v_e_l
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _/_l_o_g_-_f_i_l_t_e_r_s
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           have
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           precedence
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           over
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           environment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           variables.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     .RE


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                .SH
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "EXAMPLES"


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           xxffrreeeerrddpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ccoonnnneeccttiioonn..rrddpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //pp::PPwwdd112233!!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //ff


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Connect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               fullscreen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               mode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               using
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               stored
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _c_o_n_n_e_c_t_i_o_n_._r_d_p
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               password
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _P_w_d_1_2_3_!


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               xxffrreeeerrddpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //uu::UUSSEERR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //ssiizzee::5500%%hh
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //vv::rrddpp..ccoonnttoossoo..ccoomm


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Connect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   host
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _r_d_p_._c_o_n_t_o_s_o_._c_o_m
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   with
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   user
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _U_S_E_R
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   size
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _5_0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _p_e_r_c_e_n_t
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _o_f
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _t_h_e
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _h_e_i_g_h_t.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   width
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (w)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   set
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   instead
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   height
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (h)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   like
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /size:50%w.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   50
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   percent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   width
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   used.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   xxffrreeeerrddpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //uu::CCOONNTTOOSSOO\\\\JJoohhnnDDooee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //pp::PPwwdd112233!!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //vv::rrddpp..ccoonnttoossoo..ccoomm


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Connect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       host
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _r_d_p_._c_o_n_t_o_s_o_._c_o_m
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       with
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       user
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _C_O_N_T_O_S_O_\_\_J_o_h_n_D_o_e
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       password
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _P_w_d_1_2_3_!


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       xxffrreeeerrddpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //uu::JJoohhnnDDooee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //pp::PPwwdd112233!!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //ww::11336666
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //hh::776688
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //vv::119922..116688..11..110000::44448899


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Connect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           host
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _1_9_2_._1_6_8_._1_._1_0_0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           on
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           port
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _4_4_8_9
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           with
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           user
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _J_o_h_n_D_o_e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           password
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _P_w_d_1_2_3_!.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           The
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           screen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           width
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           set
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _1_3_6_6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           height
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _7_6_8


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           xxffrreeeerrddpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //uu::JJoohhnnDDooee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //pp::PPwwdd112233!!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //vvmmccoonnnneecctt::CC882244FF5533EE--9955DD22--4466CC66--99AA1188--2233AA55BBBB440033553322
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //vv::119922..116688..11..110000


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Establish
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               connection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               host
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _1_9_2_._1_6_8_._1_._1_0_0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               with
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               user
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _J_o_h_n_D_o_e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               password
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _P_w_d_1_2_3_!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               connect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Hyper-V
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               console
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               port
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               2179,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               disable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               negotiation)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               with
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               VMID
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _C_8_2_4_F_5_3_E_-_9_5_D_2_-_4_6_C_6_-_9_A_1_8_-_2_3_A_5_B_B_4_0_3_5_3_2


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ++cclliippbbooaarrdd


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   clipboard
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   redirection


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //ddrriivvee::hhoommee,,//hhoommee//uusseerr


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       drive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _/_h_o_m_e_/_u_s_e_r
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       as
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       home
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       drive


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //ssmmaarrttccaarrdd::<<ddeevviiccee>>


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           smartcard
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           device
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _d_e_v_i_c_e


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //pprriinntteerr::<<ddeevviiccee>>,,<<ddrriivveerr>>


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               printer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               printer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _d_e_v_i_c_e
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               using
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               driver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _d_r_i_v_e_r


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //sseerriiaall::<<ddeevviiccee>>


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   serial
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   port
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   port
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _d_e_v_i_c_e


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //ppaarraalllleell::<<ddeevviiccee>>


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       port
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       port
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _d_e_v_i_c_e


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       //ssoouunndd::ssyyss::aallssaa


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           audio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           output
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           using
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           device
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _s_y_s_:_a_l_s_a


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           //mmiiccrroopphhoonnee::ssyyss::aallssaa


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               audio
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               using
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               device
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _s_y_s_:_a_l_s_a


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               //mmuullttiimmeeddiiaa::ssyyss::aallssaa


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   multimedia
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   using
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   device
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _s_y_s_:_a_l_s_a


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             .RE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   //uussbb::iidd,,ddeevv::005544cc::00226688


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Activate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       USB
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       device
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       redirection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       device
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       identified
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       by
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _0_5_4_c_:_0_2_6_8


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 .RE


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            .SH
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       "LINKS"


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            .PP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       hhttttpp::////wwwwww..ffrreeeerrddpp..ccoomm//


AAUUTTHHOORR
       The FreeRDP Team


freerdp                           2019-07-31                       XFREERDP(1)