2012-09-20 07:51:34 +04:00
|
|
|
/**
|
|
|
|
* xrdp: A Remote Desktop Protocol server.
|
|
|
|
*
|
2013-06-08 21:51:53 +04:00
|
|
|
* Copyright (C) Jay Sorg 2004-2013
|
2012-09-20 07:51:34 +04:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*
|
|
|
|
* this is the interface to libxrdp
|
|
|
|
*/
|
2005-06-28 07:11:35 +04:00
|
|
|
|
2017-03-03 07:33:23 +03:00
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
|
|
#include <config_ac.h>
|
|
|
|
#endif
|
|
|
|
|
2005-06-28 07:11:35 +04:00
|
|
|
#include "libxrdp.h"
|
2020-12-21 15:36:00 +03:00
|
|
|
#include "string_calls.h"
|
2013-06-24 02:00:24 +04:00
|
|
|
#include "xrdp_orders_rail.h"
|
2021-05-25 07:05:54 +03:00
|
|
|
#include "ms-rdpedisp.h"
|
2019-12-19 12:55:38 +03:00
|
|
|
#include "ms-rdpbcgr.h"
|
|
|
|
|
2016-12-15 11:39:13 +03:00
|
|
|
#define MAX_BITMAP_BUF_SIZE (16 * 1024) /* 16K */
|
2022-07-06 13:04:44 +03:00
|
|
|
#define TS_MONITOR_ATTRIBUTES_SIZE 20 /* [MS-RDPBCGR] 2.2.1.3.9 */
|
2016-12-15 11:39:13 +03:00
|
|
|
|
2005-06-28 07:11:35 +04:00
|
|
|
/******************************************************************************/
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_session *EXPORT_CC
|
2020-06-05 11:53:31 +03:00
|
|
|
libxrdp_init(tbus id, struct trans *trans, const char *xrdp_ini)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_session *session;
|
2005-06-28 07:11:35 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
session = (struct xrdp_session *)g_malloc(sizeof(struct xrdp_session), 1);
|
|
|
|
session->id = id;
|
2014-03-04 12:19:19 +04:00
|
|
|
session->trans = trans;
|
2020-06-05 11:53:31 +03:00
|
|
|
if (xrdp_ini != NULL)
|
|
|
|
{
|
|
|
|
session->xrdp_ini = g_strdup(xrdp_ini);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
session->xrdp_ini = g_strdup(XRDP_CFG_PATH "/xrdp.ini");
|
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
session->rdp = xrdp_rdp_create(session, trans);
|
|
|
|
session->orders = xrdp_orders_create(session, (struct xrdp_rdp *)session->rdp);
|
|
|
|
session->client_info = &(((struct xrdp_rdp *)session->rdp)->client_info);
|
2020-05-29 15:28:04 +03:00
|
|
|
session->check_for_app_input = 1;
|
2012-09-20 07:51:34 +04:00
|
|
|
return session;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_exit(struct xrdp_session *session)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
if (session == 0)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
xrdp_orders_delete((struct xrdp_orders *)session->orders);
|
|
|
|
xrdp_rdp_delete((struct xrdp_rdp *)session->rdp);
|
2020-06-05 11:53:31 +03:00
|
|
|
g_free(session->xrdp_ini);
|
2012-09-20 07:51:34 +04:00
|
|
|
g_free(session);
|
2005-06-28 07:11:35 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_disconnect(struct xrdp_session *session)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_rdp_disconnect((struct xrdp_rdp *)session->rdp);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2016-02-14 07:41:07 +03:00
|
|
|
libxrdp_process_incoming(struct xrdp_session *session)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2014-03-05 06:11:55 +04:00
|
|
|
int rv;
|
|
|
|
|
|
|
|
rv = xrdp_rdp_incoming((struct xrdp_rdp *)(session->rdp));
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
|
|
|
libxrdp_get_pdu_bytes(const char *aheader)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
const tui8 *header;
|
|
|
|
|
|
|
|
rv = -1;
|
|
|
|
header = (const tui8 *) aheader;
|
|
|
|
|
|
|
|
if (header[0] == 0x03)
|
|
|
|
{
|
|
|
|
/* TPKT */
|
|
|
|
rv = (header[2] << 8) | header[3];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Fast-Path */
|
|
|
|
if (header[1] & 0x80)
|
|
|
|
{
|
|
|
|
rv = ((header[1] & 0x7F) << 8) | header[2];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
rv = header[1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2016-01-14 19:32:09 +03:00
|
|
|
/* only used during connection */
|
2017-03-12 19:35:00 +03:00
|
|
|
struct stream *
|
2020-11-30 06:29:57 +03:00
|
|
|
libxrdp_force_read(struct trans *trans)
|
2014-03-05 06:11:55 +04:00
|
|
|
{
|
|
|
|
int bytes;
|
|
|
|
struct stream *s;
|
|
|
|
|
|
|
|
s = trans->in_s;
|
|
|
|
init_stream(s, 32 * 1024);
|
2014-07-23 16:31:45 +04:00
|
|
|
|
|
|
|
if (trans_force_read(trans, 4) != 0)
|
2014-03-05 06:11:55 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_force_read: header read error");
|
|
|
|
return NULL;
|
2014-03-05 06:11:55 +04:00
|
|
|
}
|
|
|
|
bytes = libxrdp_get_pdu_bytes(s->data);
|
2020-04-14 13:01:52 +03:00
|
|
|
if (bytes < 4 || bytes > s->size)
|
2014-03-05 06:11:55 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_force_read: bad header length %d", bytes);
|
|
|
|
return NULL;
|
2014-03-05 06:11:55 +04:00
|
|
|
}
|
2014-07-23 16:31:45 +04:00
|
|
|
if (trans_force_read(trans, bytes - 4) != 0)
|
2014-03-05 06:11:55 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_force_read: Can't read PDU");
|
|
|
|
return NULL;
|
2014-03-05 06:11:55 +04:00
|
|
|
}
|
|
|
|
return s;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2014-02-26 08:47:34 +04:00
|
|
|
libxrdp_process_data(struct xrdp_session *session, struct stream *s)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
|
|
|
int cont;
|
|
|
|
int rv;
|
|
|
|
int code;
|
|
|
|
int term;
|
|
|
|
int dead_lock_counter;
|
2014-03-05 06:11:55 +04:00
|
|
|
int do_read;
|
2014-02-26 08:47:34 +04:00
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
|
2014-03-05 06:11:55 +04:00
|
|
|
do_read = s == 0;
|
|
|
|
if (do_read && session->up_and_running)
|
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: error logic");
|
2014-03-05 06:11:55 +04:00
|
|
|
return 1;
|
|
|
|
}
|
2014-02-26 08:47:34 +04:00
|
|
|
if (session->in_process_data != 0)
|
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: error reentry");
|
2014-02-26 08:47:34 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
session->in_process_data++;
|
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
term = 0;
|
|
|
|
cont = 1;
|
|
|
|
rv = 0;
|
|
|
|
dead_lock_counter = 0;
|
|
|
|
|
2014-02-26 08:47:34 +04:00
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
while ((cont || !session->up_and_running) && !term)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
if (session->is_term != 0)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
if (session->is_term())
|
|
|
|
{
|
|
|
|
term = 1;
|
2014-03-05 06:11:55 +04:00
|
|
|
break;
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
code = 0;
|
|
|
|
|
2014-03-05 06:11:55 +04:00
|
|
|
if (do_read)
|
|
|
|
{
|
2014-03-06 00:38:17 +04:00
|
|
|
if (s == 0)
|
|
|
|
{
|
|
|
|
s = libxrdp_force_read(session->trans);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((s->next_packet == 0) || (s->next_packet >= s->end))
|
|
|
|
{
|
|
|
|
s = libxrdp_force_read(session->trans);
|
|
|
|
}
|
|
|
|
}
|
2014-03-05 06:11:55 +04:00
|
|
|
if (s == 0)
|
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: libxrdp_force_read failed");
|
2014-03-05 06:11:55 +04:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-26 08:47:34 +04:00
|
|
|
if (xrdp_rdp_recv(rdp, s, &code) != 0)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: xrdp_rdp_recv failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_process_data code %d", code);
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
switch (code)
|
|
|
|
{
|
|
|
|
case -1:
|
2014-03-10 05:39:39 +04:00
|
|
|
xrdp_caps_send_demand_active(rdp);
|
2012-09-20 07:51:34 +04:00
|
|
|
session->up_and_running = 0;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
dead_lock_counter++;
|
|
|
|
break;
|
2018-12-12 11:19:18 +03:00
|
|
|
case PDUTYPE_CONFIRMACTIVEPDU:
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Processing received "
|
|
|
|
"[MS-RDPBCGR] PDUTYPE_CONFIRMACTIVEPDU");
|
2014-03-10 05:39:39 +04:00
|
|
|
xrdp_caps_process_confirm_active(rdp, s);
|
2012-09-20 07:51:34 +04:00
|
|
|
break;
|
2018-12-12 11:19:18 +03:00
|
|
|
case PDUTYPE_DATAPDU:
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Processing received "
|
|
|
|
"[MS-RDPBCGR] PDUTYPE_DATAPDU");
|
2014-02-26 08:47:34 +04:00
|
|
|
if (xrdp_rdp_process_data(rdp, s) != 0)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: xrdp_rdp_process_data failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
cont = 0;
|
|
|
|
term = 1;
|
|
|
|
}
|
|
|
|
break;
|
2014-02-10 07:48:03 +04:00
|
|
|
case 2: /* FASTPATH_INPUT_EVENT */
|
2014-03-05 01:56:26 +04:00
|
|
|
if (xrdp_fastpath_process_input_event(rdp->sec_layer->fastpath_layer, s) != 0)
|
2014-03-02 03:39:34 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: xrdp_fastpath_process_input_event failed");
|
2020-11-30 06:29:57 +03:00
|
|
|
cont = 0;
|
|
|
|
term = 1;
|
2014-03-02 03:39:34 +04:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
break;
|
|
|
|
default:
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_WARNING, "unknown code = %d (ignored)", code);
|
2012-09-20 07:51:34 +04:00
|
|
|
dead_lock_counter++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dead_lock_counter > 100000)
|
|
|
|
{
|
|
|
|
/*This situation can happen and this is a workaround*/
|
|
|
|
cont = 0;
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_WARNING,
|
|
|
|
"Serious programming error: we were locked in a deadly loop. "
|
|
|
|
"Remaining bytes: %d", (int) (s->end - s->next_packet));
|
2014-02-26 08:47:34 +04:00
|
|
|
s->next_packet = 0;
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cont)
|
|
|
|
{
|
2014-03-06 00:38:17 +04:00
|
|
|
cont = (s->next_packet != 0) && (s->next_packet < s->end);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
2014-02-26 08:47:34 +04:00
|
|
|
session->in_process_data--;
|
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
return rv;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_send_palette(struct xrdp_session *session, int *palette)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2017-01-22 21:46:23 +03:00
|
|
|
int rv;
|
2012-09-20 07:51:34 +04:00
|
|
|
int i = 0;
|
|
|
|
int color = 0;
|
|
|
|
struct stream *s = (struct stream *)NULL;
|
|
|
|
|
|
|
|
if (session->client_info->bpp > 8)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2005-06-28 07:11:35 +04:00
|
|
|
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "sending palette (%s)",
|
|
|
|
((session->client_info->use_fast_path & 1) ?
|
|
|
|
"fastpath" : "slowpath"));
|
2014-07-27 02:06:35 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
/* clear orders */
|
|
|
|
libxrdp_orders_force_send(session);
|
|
|
|
make_stream(s);
|
|
|
|
init_stream(s, 8192);
|
2014-07-27 02:06:35 +04:00
|
|
|
|
2014-03-13 02:21:29 +04:00
|
|
|
if (session->client_info->use_fast_path & 1) /* fastpath output supported */
|
|
|
|
{
|
|
|
|
if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_palette: xrdp_rdp_init_fastpath failed");
|
2014-07-27 02:06:35 +04:00
|
|
|
free_stream(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2020-11-30 06:29:57 +03:00
|
|
|
else
|
|
|
|
{
|
2014-03-13 02:21:29 +04:00
|
|
|
xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TS_UPDATE_PALETTE_DATA */
|
2021-02-04 13:11:54 +03:00
|
|
|
out_uint16_le(s, RDP_UPDATE_PALETTE); /* updateType */
|
|
|
|
out_uint16_le(s, 0); /* pad2Octets */
|
|
|
|
out_uint16_le(s, 256); /* # of colors (low-bytes) */
|
|
|
|
out_uint16_le(s, 0); /* # of colors (high-bytes) */
|
2012-09-20 07:51:34 +04:00
|
|
|
|
2021-02-04 13:11:54 +03:00
|
|
|
/* paletteEntries */
|
2012-09-20 07:51:34 +04:00
|
|
|
for (i = 0; i < 256; i++)
|
|
|
|
{
|
|
|
|
color = palette[i];
|
|
|
|
out_uint8(s, color >> 16);
|
|
|
|
out_uint8(s, color >> 8);
|
|
|
|
out_uint8(s, color);
|
|
|
|
}
|
|
|
|
|
|
|
|
s_mark_end(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
if (session->client_info->use_fast_path & 1) /* fastpath output supported */
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_FP_UPDATE_PALETTE "
|
|
|
|
"paletteUpdateData = { updateType %d (UPDATETYPE_PALETTE), "
|
|
|
|
"pad2Octets <ignored>, numberColors 256, "
|
|
|
|
"paletteEntries <omitted from log> }", RDP_UPDATE_PALETTE);
|
2020-11-30 06:29:57 +03:00
|
|
|
if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s,
|
2014-03-13 02:21:29 +04:00
|
|
|
FASTPATH_UPDATETYPE_PALETTE) != 0)
|
2020-11-30 06:29:57 +03:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_palette: xrdp_rdp_send_fastpath failed");
|
2020-11-30 06:29:57 +03:00
|
|
|
free_stream(s);
|
|
|
|
return 1;
|
|
|
|
}
|
2014-03-13 02:21:29 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_UPDATE_PALETTE_DATA "
|
|
|
|
"updateType %d (UPDATETYPE_PALETTE), pad2Octets <ignored>, "
|
|
|
|
"numberColors 256, paletteEntries <omitted from log>",
|
|
|
|
RDP_UPDATE_PALETTE);
|
2020-11-30 06:29:57 +03:00
|
|
|
xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s,
|
2014-03-13 02:21:29 +04:00
|
|
|
RDP_DATA_PDU_UPDATE);
|
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
free_stream(s);
|
2014-07-27 02:06:35 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
/* send the orders palette too */
|
2017-01-22 21:46:23 +03:00
|
|
|
rv = libxrdp_orders_init(session);
|
|
|
|
if (rv == 0)
|
|
|
|
{
|
|
|
|
rv = libxrdp_orders_send_palette(session, palette, 0);
|
|
|
|
}
|
|
|
|
if (rv == 0)
|
|
|
|
{
|
|
|
|
rv = libxrdp_orders_send(session);
|
|
|
|
}
|
|
|
|
return rv;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
2010-10-26 15:08:28 +04:00
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_send_bell(struct xrdp_session *session)
|
2010-10-26 15:08:28 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct stream *s = (struct stream *)NULL;
|
2010-10-26 15:08:28 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
make_stream(s);
|
|
|
|
init_stream(s, 8192);
|
|
|
|
|
|
|
|
if (xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s) != 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_bell: xrdp_rdp_init_data failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
free_stream(s);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
out_uint32_le(s, 100); /* duration (ms) */
|
2021-01-24 01:57:15 +03:00
|
|
|
out_uint32_le(s, 440); /* frequency */
|
2012-09-20 07:51:34 +04:00
|
|
|
s_mark_end(s);
|
2021-01-24 01:57:15 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_PLAY_SOUND_PDU_DATA "
|
|
|
|
"duration 100 ms, frequency 440 Hz");
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
if (xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s, RDP_DATA_PDU_PLAY_SOUND) != 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_bell: xrdp_rdp_send_data failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
free_stream(s);
|
|
|
|
return 1;
|
|
|
|
}
|
2010-10-26 15:08:28 +04:00
|
|
|
|
|
|
|
free_stream(s);
|
2012-09-20 07:51:34 +04:00
|
|
|
return 0;
|
2010-10-26 15:08:28 +04:00
|
|
|
}
|
|
|
|
|
2005-06-28 07:11:35 +04:00
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
|
|
|
|
int bpp, char *data, int x, int y, int cx, int cy)
|
|
|
|
{
|
2016-12-15 11:39:13 +03:00
|
|
|
int line_bytes = 0;
|
2012-09-20 07:51:34 +04:00
|
|
|
int i = 0;
|
|
|
|
int j = 0;
|
2016-12-15 11:39:13 +03:00
|
|
|
int k;
|
2012-09-20 07:51:34 +04:00
|
|
|
int total_lines = 0;
|
|
|
|
int lines_sending = 0;
|
|
|
|
int Bpp = 0;
|
|
|
|
int e = 0;
|
|
|
|
int bufsize = 0;
|
|
|
|
int total_bufsize = 0;
|
|
|
|
int num_updates = 0;
|
2016-12-15 11:39:13 +03:00
|
|
|
int line_pad_bytes;
|
|
|
|
int server_line_bytes;
|
2012-09-20 07:51:34 +04:00
|
|
|
char *p_num_updates = (char *)NULL;
|
|
|
|
char *p = (char *)NULL;
|
|
|
|
char *q = (char *)NULL;
|
|
|
|
struct stream *s = (struct stream *)NULL;
|
|
|
|
struct stream *temp_s = (struct stream *)NULL;
|
2016-12-15 11:39:13 +03:00
|
|
|
tui32 pixel;
|
2012-09-20 07:51:34 +04:00
|
|
|
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: sending bitmap");
|
2012-09-20 07:51:34 +04:00
|
|
|
Bpp = (bpp + 7) / 8;
|
2016-12-15 11:39:13 +03:00
|
|
|
e = (4 - width) & 3;
|
|
|
|
switch (bpp)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2016-12-15 11:39:13 +03:00
|
|
|
case 15:
|
|
|
|
case 16:
|
|
|
|
server_line_bytes = width * 2;
|
|
|
|
break;
|
|
|
|
case 24:
|
|
|
|
case 32:
|
|
|
|
server_line_bytes = width * 4;
|
|
|
|
break;
|
|
|
|
default: /* 8 bpp */
|
|
|
|
server_line_bytes = width;
|
|
|
|
break;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
2016-12-15 11:39:13 +03:00
|
|
|
line_bytes = width * Bpp;
|
|
|
|
line_pad_bytes = line_bytes + e * Bpp;
|
2012-09-20 07:51:34 +04:00
|
|
|
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: bpp %d Bpp %d line_bytes %d "
|
2020-11-30 06:29:57 +03:00
|
|
|
"server_line_bytes %d", bpp, Bpp, line_bytes, server_line_bytes);
|
2012-09-20 07:51:34 +04:00
|
|
|
make_stream(s);
|
2016-12-15 11:39:13 +03:00
|
|
|
init_stream(s, MAX_BITMAP_BUF_SIZE);
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
if (session->client_info->use_bitmap_comp)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: compression");
|
2012-09-20 07:51:34 +04:00
|
|
|
make_stream(temp_s);
|
|
|
|
init_stream(temp_s, 65536);
|
|
|
|
i = 0;
|
|
|
|
|
|
|
|
if (cy <= height)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
i = cy;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
while (i > 0)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: i %d", i);
|
2016-12-15 11:39:13 +03:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
total_bufsize = 0;
|
|
|
|
num_updates = 0;
|
|
|
|
xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s);
|
2021-02-04 13:11:54 +03:00
|
|
|
out_uint16_le(s, RDP_UPDATE_BITMAP); /* updateType */
|
2012-09-20 07:51:34 +04:00
|
|
|
p_num_updates = s->p;
|
|
|
|
out_uint8s(s, 2); /* num_updates set later */
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if (session->client_info->op1)
|
|
|
|
{
|
|
|
|
s_push_layer(s, channel_hdr, 18);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
s_push_layer(s, channel_hdr, 26);
|
|
|
|
}
|
|
|
|
|
|
|
|
p = s->p;
|
2016-12-15 11:39:13 +03:00
|
|
|
|
|
|
|
if (bpp > 24)
|
|
|
|
{
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: 32 bpp");
|
2016-12-15 11:39:13 +03:00
|
|
|
lines_sending = xrdp_bitmap32_compress(data, width, height,
|
|
|
|
s, 32,
|
2020-11-30 06:29:57 +03:00
|
|
|
(MAX_BITMAP_BUF_SIZE - 100) - total_bufsize,
|
2016-12-15 11:39:13 +03:00
|
|
|
i - 1, temp_s, e, 0x10);
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: i %d lines_sending %d",
|
2020-11-30 06:29:57 +03:00
|
|
|
i, lines_sending);
|
2016-12-15 11:39:13 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
lines_sending = xrdp_bitmap_compress(data, width, height,
|
|
|
|
s, bpp,
|
2020-11-30 06:29:57 +03:00
|
|
|
(MAX_BITMAP_BUF_SIZE - 100) - total_bufsize,
|
2016-12-15 11:39:13 +03:00
|
|
|
i - 1, temp_s, e);
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: i %d lines_sending %d",
|
2020-11-30 06:29:57 +03:00
|
|
|
i, lines_sending);
|
2016-12-15 11:39:13 +03:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
if (lines_sending == 0)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
num_updates++;
|
|
|
|
bufsize = s->p - p;
|
|
|
|
total_bufsize += bufsize;
|
|
|
|
i = i - lines_sending;
|
|
|
|
s_mark_end(s);
|
|
|
|
s_pop_layer(s, channel_hdr);
|
|
|
|
out_uint16_le(s, x); /* left */
|
|
|
|
out_uint16_le(s, y + i); /* top */
|
|
|
|
out_uint16_le(s, (x + cx) - 1); /* right */
|
|
|
|
out_uint16_le(s, (y + i + lines_sending) - 1); /* bottom */
|
|
|
|
out_uint16_le(s, width + e); /* width */
|
|
|
|
out_uint16_le(s, lines_sending); /* height */
|
|
|
|
out_uint16_le(s, bpp); /* bpp */
|
|
|
|
|
|
|
|
if (session->client_info->op1)
|
|
|
|
{
|
|
|
|
out_uint16_le(s, 0x401); /* compress */
|
|
|
|
out_uint16_le(s, bufsize); /* compressed size */
|
|
|
|
j = (width + e) * Bpp;
|
|
|
|
j = j * lines_sending;
|
2016-12-16 01:47:37 +03:00
|
|
|
total_bufsize += 18; /* bytes since pop layer */
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
out_uint16_le(s, 0x1); /* compress */
|
|
|
|
out_uint16_le(s, bufsize + 8);
|
|
|
|
out_uint8s(s, 2); /* pad */
|
|
|
|
out_uint16_le(s, bufsize); /* compressed size */
|
|
|
|
j = (width + e) * Bpp;
|
|
|
|
out_uint16_le(s, j); /* line size */
|
|
|
|
j = j * lines_sending;
|
|
|
|
out_uint16_le(s, j); /* final size */
|
2016-12-16 01:47:37 +03:00
|
|
|
total_bufsize += 26; /* bytes since pop layer */
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
|
|
|
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: decompressed pixels %d "
|
2020-11-30 06:29:57 +03:00
|
|
|
"decompressed bytes %d compressed bytes %d",
|
|
|
|
lines_sending * (width + e),
|
|
|
|
line_pad_bytes * lines_sending, bufsize);
|
2016-12-15 11:39:13 +03:00
|
|
|
|
|
|
|
if (j > MAX_BITMAP_BUF_SIZE)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_WARNING, "libxrdp_send_bitmap: error, decompressed "
|
|
|
|
"size too big: %d bytes", j);
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
|
|
|
|
2016-12-15 11:39:13 +03:00
|
|
|
if (bufsize > MAX_BITMAP_BUF_SIZE)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_WARNING, "libxrdp_send_bitmap: error, compressed size "
|
|
|
|
"too big: %d bytes", bufsize);
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
s->p = s->end;
|
|
|
|
}
|
2016-12-15 11:39:13 +03:00
|
|
|
while (total_bufsize < MAX_BITMAP_BUF_SIZE && i > 0);
|
|
|
|
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: num_updates %d total_bufsize %d",
|
2020-11-30 06:29:57 +03:00
|
|
|
num_updates, total_bufsize);
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
p_num_updates[0] = num_updates;
|
|
|
|
p_num_updates[1] = num_updates >> 8;
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_UPDATE_BITMAP_DATA "
|
|
|
|
"updateType %d (UPDATETYPE_BITMAP), numberRectangles %d, "
|
|
|
|
"rectangles <omitted from log>",
|
|
|
|
RDP_UPDATE_BITMAP, num_updates);
|
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s,
|
|
|
|
RDP_DATA_PDU_UPDATE);
|
|
|
|
|
2016-12-15 11:39:13 +03:00
|
|
|
if (total_bufsize > MAX_BITMAP_BUF_SIZE)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_WARNING, "libxrdp_send_bitmap: error, total compressed "
|
|
|
|
"size too big: %d bytes", total_bufsize);
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
free_stream(temp_s);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
else
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: no compression");
|
2012-09-20 07:51:34 +04:00
|
|
|
total_lines = height;
|
|
|
|
i = 0;
|
|
|
|
p = data;
|
|
|
|
|
2016-12-15 11:39:13 +03:00
|
|
|
if (line_bytes > 0 && total_lines > 0)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
while (i < total_lines)
|
|
|
|
{
|
2016-12-15 11:39:13 +03:00
|
|
|
|
2016-12-16 01:47:37 +03:00
|
|
|
lines_sending = (MAX_BITMAP_BUF_SIZE - 100) / line_pad_bytes;
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
if (i + lines_sending > total_lines)
|
|
|
|
{
|
|
|
|
lines_sending = total_lines - i;
|
|
|
|
}
|
|
|
|
|
2016-12-15 11:39:13 +03:00
|
|
|
if (lines_sending == 0)
|
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_WARNING, "libxrdp_send_bitmap: error, lines_sending == zero");
|
2016-12-15 11:39:13 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:47:37 +03:00
|
|
|
p += server_line_bytes * lines_sending;
|
2012-09-20 07:51:34 +04:00
|
|
|
xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s);
|
|
|
|
out_uint16_le(s, RDP_UPDATE_BITMAP);
|
|
|
|
out_uint16_le(s, 1); /* num updates */
|
|
|
|
out_uint16_le(s, x);
|
|
|
|
out_uint16_le(s, y + i);
|
|
|
|
out_uint16_le(s, (x + cx) - 1);
|
|
|
|
out_uint16_le(s, (y + i + lines_sending) - 1);
|
|
|
|
out_uint16_le(s, width + e);
|
|
|
|
out_uint16_le(s, lines_sending);
|
|
|
|
out_uint16_le(s, bpp); /* bpp */
|
|
|
|
out_uint16_le(s, 0); /* compress */
|
2016-12-15 11:39:13 +03:00
|
|
|
out_uint16_le(s, line_pad_bytes * lines_sending); /* bufsize */
|
2012-09-20 07:51:34 +04:00
|
|
|
q = p;
|
|
|
|
|
2016-12-15 11:39:13 +03:00
|
|
|
switch (bpp)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2016-12-16 08:52:05 +03:00
|
|
|
case 8:
|
|
|
|
for (j = 0; j < lines_sending; j++)
|
|
|
|
{
|
|
|
|
q = q - line_bytes;
|
|
|
|
out_uint8a(s, q, line_bytes);
|
|
|
|
out_uint8s(s, e);
|
|
|
|
}
|
|
|
|
break;
|
2016-12-15 11:39:13 +03:00
|
|
|
case 15:
|
|
|
|
case 16:
|
|
|
|
for (j = 0; j < lines_sending; j++)
|
|
|
|
{
|
|
|
|
q = q - server_line_bytes;
|
|
|
|
for (k = 0; k < width; k++)
|
|
|
|
{
|
2020-11-30 06:29:57 +03:00
|
|
|
pixel = *((tui16 *)(q + k * 2));
|
2016-12-15 11:39:13 +03:00
|
|
|
out_uint16_le(s, pixel);
|
|
|
|
}
|
2016-12-16 08:52:05 +03:00
|
|
|
out_uint8s(s, e * 2);
|
2016-12-15 11:39:13 +03:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 24:
|
|
|
|
for (j = 0; j < lines_sending; j++)
|
|
|
|
{
|
|
|
|
q = q - server_line_bytes;
|
|
|
|
for (k = 0; k < width; k++)
|
|
|
|
{
|
2020-11-30 06:29:57 +03:00
|
|
|
pixel = *((tui32 *)(q + k * 4));
|
2016-12-15 11:39:13 +03:00
|
|
|
out_uint8(s, pixel);
|
|
|
|
out_uint8(s, pixel >> 8);
|
|
|
|
out_uint8(s, pixel >> 16);
|
|
|
|
}
|
2016-12-16 08:52:05 +03:00
|
|
|
out_uint8s(s, e * 3);
|
2016-12-15 11:39:13 +03:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 32:
|
|
|
|
for (j = 0; j < lines_sending; j++)
|
|
|
|
{
|
|
|
|
q = q - server_line_bytes;
|
|
|
|
for (k = 0; k < width; k++)
|
|
|
|
{
|
2020-11-30 06:29:57 +03:00
|
|
|
pixel = *((int *)(q + k * 4));
|
2016-12-15 11:39:13 +03:00
|
|
|
out_uint32_le(s, pixel);
|
|
|
|
}
|
2016-12-16 08:52:05 +03:00
|
|
|
out_uint8s(s, e * 4);
|
2016-12-15 11:39:13 +03:00
|
|
|
}
|
|
|
|
break;
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
s_mark_end(s);
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_UPDATE_BITMAP_DATA "
|
|
|
|
"updateType %d (UPDATETYPE_BITMAP), numberRectangles 1, "
|
|
|
|
"rectangles <omitted from log>",
|
|
|
|
RDP_UPDATE_BITMAP);
|
2012-09-20 07:51:34 +04:00
|
|
|
xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s,
|
|
|
|
RDP_DATA_PDU_UPDATE);
|
|
|
|
i = i + lines_sending;
|
|
|
|
}
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
free_stream(s);
|
|
|
|
return 0;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
|
2022-07-14 11:46:38 +03:00
|
|
|
char *data, char *mask, int x, int y, int bpp,
|
|
|
|
int width, int height)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
|
|
|
struct stream *s;
|
|
|
|
char *p;
|
2013-03-13 09:50:10 +04:00
|
|
|
tui16 *p16;
|
|
|
|
tui32 *p32;
|
2012-09-20 07:51:34 +04:00
|
|
|
int i;
|
|
|
|
int j;
|
2013-03-13 10:22:11 +04:00
|
|
|
int data_bytes;
|
2022-07-14 11:46:38 +03:00
|
|
|
int mask_bytes;
|
2012-09-20 07:51:34 +04:00
|
|
|
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "sending cursor");
|
2013-05-20 22:50:05 +04:00
|
|
|
if (bpp == 0)
|
|
|
|
{
|
|
|
|
bpp = 24;
|
|
|
|
}
|
2022-07-14 11:46:38 +03:00
|
|
|
if (width == 0)
|
|
|
|
{
|
|
|
|
width = 32;
|
|
|
|
}
|
|
|
|
if (height == 0)
|
|
|
|
{
|
|
|
|
height = 32;
|
|
|
|
}
|
2013-03-13 10:22:11 +04:00
|
|
|
/* error check */
|
|
|
|
if ((session->client_info->pointer_flags & 1) == 0)
|
|
|
|
{
|
2013-05-20 22:50:05 +04:00
|
|
|
if (bpp != 24)
|
2013-03-13 10:22:11 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "Send pointer: client does not support "
|
|
|
|
"new cursors. The only valid bpp is 24, received %d", bpp);
|
2013-03-13 10:22:11 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2021-02-04 13:11:54 +03:00
|
|
|
|
2022-07-14 11:46:38 +03:00
|
|
|
if ((bpp != 15) && (bpp != 16) && (bpp != 24) && (bpp != 32))
|
2013-03-13 10:22:11 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR,
|
2022-07-14 11:46:38 +03:00
|
|
|
"Send pointer: invalid bpp value. Expected 15, 16, 24 or 32, "
|
2021-02-04 13:11:54 +03:00
|
|
|
"received %d", bpp);
|
2013-03-13 10:22:11 +04:00
|
|
|
return 1;
|
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
make_stream(s);
|
2022-07-14 11:46:38 +03:00
|
|
|
data_bytes = width * height * ((bpp + 7) / 8);
|
|
|
|
mask_bytes = width * height / 8;
|
|
|
|
init_stream(s, data_bytes + mask_bytes + 8192);
|
2014-03-13 02:21:29 +04:00
|
|
|
if (session->client_info->use_fast_path & 1) /* fastpath output supported */
|
2013-03-13 09:50:10 +04:00
|
|
|
{
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_pointer: fastpath");
|
2014-03-13 02:21:29 +04:00
|
|
|
if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_pointer: xrdp_rdp_init_fastpath failed");
|
2014-03-22 11:28:52 +04:00
|
|
|
free_stream(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2022-07-14 11:46:38 +03:00
|
|
|
if ((session->client_info->pointer_flags & 1) != 0)
|
2014-03-13 02:21:29 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
out_uint16_le(s, bpp); /* TS_FP_POINTERATTRIBUTE -> newPointerUpdateData.xorBpp */
|
2014-03-13 02:21:29 +04:00
|
|
|
}
|
2013-03-13 09:50:10 +04:00
|
|
|
}
|
2014-03-15 18:10:20 +04:00
|
|
|
else /* slowpath */
|
2013-03-13 09:50:10 +04:00
|
|
|
{
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_pointer: slowpath");
|
2014-03-13 02:21:29 +04:00
|
|
|
xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s);
|
|
|
|
if ((session->client_info->pointer_flags & 1) == 0)
|
2020-11-30 06:29:57 +03:00
|
|
|
{
|
|
|
|
out_uint16_le(s, RDP_POINTER_COLOR);
|
|
|
|
out_uint16_le(s, 0); /* pad */
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Adding header [MS-RDPBCGR] TS_POINTER_PDU "
|
|
|
|
"messageType %d (TS_PTRMSGTYPE_COLOR), pad2Octets <ignored>",
|
|
|
|
RDP_POINTER_COLOR);
|
2020-11-30 06:29:57 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
out_uint16_le(s, RDP_POINTER_POINTER);
|
|
|
|
out_uint16_le(s, 0); /* pad */
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Adding header [MS-RDPBCGR] TS_POINTER_PDU "
|
|
|
|
"messageType %d (TS_PTRMSGTYPE_POINTER), pad2Octets <ignored>",
|
|
|
|
RDP_POINTER_POINTER);
|
|
|
|
|
|
|
|
out_uint16_le(s, bpp); /* TS_POINTERATTRIBUTE -> xorBpp */
|
2020-11-30 06:29:57 +03:00
|
|
|
}
|
2013-03-13 09:50:10 +04:00
|
|
|
}
|
2014-03-13 02:21:29 +04:00
|
|
|
|
2021-02-04 13:11:54 +03:00
|
|
|
/* the TS_COLORPOINTERATTRIBUTE field which is shared by
|
|
|
|
all of the pointer attribute PDU types */
|
|
|
|
out_uint16_le(s, cache_idx); /* cache_idx */
|
|
|
|
out_uint16_le(s, x); /* hotSpot.xPos */
|
|
|
|
out_uint16_le(s, y); /* hotSpot.yPos */
|
2022-07-14 11:46:38 +03:00
|
|
|
out_uint16_le(s, width); /* width */
|
|
|
|
out_uint16_le(s, height); /* height */
|
|
|
|
out_uint16_le(s, mask_bytes); /* lengthAndMask */
|
2021-02-04 13:11:54 +03:00
|
|
|
out_uint16_le(s, data_bytes); /* lengthXorMask */
|
|
|
|
|
|
|
|
/* xorMaskData */
|
2013-03-13 10:22:11 +04:00
|
|
|
switch (bpp)
|
2013-03-13 09:50:10 +04:00
|
|
|
{
|
2022-07-14 11:46:38 +03:00
|
|
|
case 15:
|
|
|
|
/* fallthrough */
|
2013-03-13 10:22:11 +04:00
|
|
|
case 16:
|
|
|
|
p16 = (tui16 *) data;
|
2022-07-14 11:46:38 +03:00
|
|
|
for (i = 0; i < height; i++)
|
2013-03-13 09:50:10 +04:00
|
|
|
{
|
2022-07-14 11:46:38 +03:00
|
|
|
for (j = 0; j < width; j++)
|
2013-03-13 10:22:11 +04:00
|
|
|
{
|
|
|
|
out_uint16_le(s, *p16);
|
|
|
|
p16++;
|
|
|
|
}
|
2013-03-13 09:50:10 +04:00
|
|
|
}
|
2013-03-13 10:22:11 +04:00
|
|
|
break;
|
|
|
|
case 24:
|
|
|
|
p = data;
|
2022-07-14 11:46:38 +03:00
|
|
|
for (i = 0; i < height; i++)
|
2013-03-13 09:50:10 +04:00
|
|
|
{
|
2022-07-14 11:46:38 +03:00
|
|
|
for (j = 0; j < width; j++)
|
2013-03-13 10:22:11 +04:00
|
|
|
{
|
|
|
|
out_uint8(s, *p);
|
|
|
|
p++;
|
|
|
|
out_uint8(s, *p);
|
|
|
|
p++;
|
|
|
|
out_uint8(s, *p);
|
|
|
|
p++;
|
|
|
|
}
|
2013-03-13 09:50:10 +04:00
|
|
|
}
|
2013-03-13 10:22:11 +04:00
|
|
|
break;
|
|
|
|
case 32:
|
|
|
|
p32 = (tui32 *) data;
|
2022-07-14 11:46:38 +03:00
|
|
|
for (i = 0; i < height; i++)
|
2013-03-13 09:50:10 +04:00
|
|
|
{
|
2022-07-14 11:46:38 +03:00
|
|
|
for (j = 0; j < width; j++)
|
2013-03-13 10:22:11 +04:00
|
|
|
{
|
|
|
|
out_uint32_le(s, *p32);
|
|
|
|
p32++;
|
|
|
|
}
|
2013-03-13 09:50:10 +04:00
|
|
|
}
|
2013-03-13 10:22:11 +04:00
|
|
|
break;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
2022-07-14 11:46:38 +03:00
|
|
|
out_uint8a(s, mask, mask_bytes); /* andMaskData */
|
2014-03-13 02:21:29 +04:00
|
|
|
out_uint8(s, 0); /* pad */
|
2012-09-20 07:51:34 +04:00
|
|
|
s_mark_end(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
if (session->client_info->use_fast_path & 1) /* fastpath output supported */
|
|
|
|
{
|
|
|
|
if ((session->client_info->pointer_flags & 1) == 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_FP_COLORPOINTERATTRIBUTE "
|
|
|
|
"cachedPointerUpdateData = { cacheIndex %d, "
|
2022-07-14 11:46:38 +03:00
|
|
|
"hotSpot.xPos %d, hotSpot.yPos %d, width %d, "
|
|
|
|
"height %d, lengthAndMask %d, lengthXorMask %d, "
|
2021-02-04 13:11:54 +03:00
|
|
|
"xorMaskData <omitted from log>, "
|
|
|
|
"andMaskData <omitted from log> }",
|
2022-07-14 11:46:38 +03:00
|
|
|
cache_idx, x, y, width, height, mask_bytes, data_bytes);
|
2014-03-13 02:21:29 +04:00
|
|
|
if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s,
|
2020-11-30 06:29:57 +03:00
|
|
|
FASTPATH_UPDATETYPE_COLOR) != 0)
|
2014-03-13 02:21:29 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_pointer: xrdp_rdp_send_fastpath failed");
|
2014-03-22 11:28:52 +04:00
|
|
|
free_stream(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_FP_POINTERATTRIBUTE "
|
|
|
|
"newPointerUpdateData.xorBpp %d, "
|
|
|
|
"newPointerUpdateData.colorPtrAttr = { cacheIndex %d, "
|
2022-07-14 11:46:38 +03:00
|
|
|
"hotSpot.xPos %d, hotSpot.yPos %d, width %d, "
|
|
|
|
"height %d, lengthAndMask %d, lengthXorMask %d, "
|
2021-02-04 13:11:54 +03:00
|
|
|
"xorMaskData <omitted from log>, "
|
|
|
|
"andMaskData <omitted from log> }",
|
2022-07-14 11:46:38 +03:00
|
|
|
bpp, cache_idx, x, y, width, height, mask_bytes, data_bytes);
|
2014-03-13 02:21:29 +04:00
|
|
|
if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s,
|
2020-11-30 06:29:57 +03:00
|
|
|
FASTPATH_UPDATETYPE_POINTER) != 0)
|
2014-03-13 02:21:29 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_pointer: xrdp_rdp_send_fastpath failed");
|
2014-03-22 11:28:52 +04:00
|
|
|
free_stream(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
if ((session->client_info->pointer_flags & 1) == 0)
|
|
|
|
{
|
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_COLORPOINTERATTRIBUTE "
|
|
|
|
"cacheIndex %d, "
|
2022-07-14 11:46:38 +03:00
|
|
|
"hotSpot.xPos %d, hotSpot.yPos %d, width %d, "
|
|
|
|
"height %d, lengthAndMask %d, lengthXorMask %d, "
|
2021-02-04 13:11:54 +03:00
|
|
|
"xorMaskData <omitted from log>, "
|
|
|
|
"andMaskData <omitted from log>",
|
2022-07-14 11:46:38 +03:00
|
|
|
cache_idx, x, y, width, height, mask_bytes, data_bytes);
|
2021-02-04 13:11:54 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_POINTERATTRIBUTE "
|
|
|
|
"xorBpp %d, colorPtrAttr = { cacheIndex %d, "
|
2022-07-14 11:46:38 +03:00
|
|
|
"hotSpot.xPos %d, hotSpot.yPos %d, width %d, "
|
|
|
|
"height %d, lengthAndMask %d, lengthXorMask %d, "
|
2021-02-04 13:11:54 +03:00
|
|
|
"xorMaskData <omitted from log>, "
|
|
|
|
"andMaskData <omitted from log> }",
|
2022-07-14 11:46:38 +03:00
|
|
|
bpp, cache_idx, x, y, width, height, mask_bytes, data_bytes);
|
2021-02-04 13:11:54 +03:00
|
|
|
}
|
2014-03-13 02:21:29 +04:00
|
|
|
xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s,
|
2020-11-30 06:29:57 +03:00
|
|
|
RDP_DATA_PDU_POINTER);
|
2014-03-13 02:21:29 +04:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
free_stream(s);
|
|
|
|
return 0;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_set_pointer(struct xrdp_session *session, int cache_idx)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct stream *s;
|
2005-06-28 07:11:35 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
make_stream(s);
|
|
|
|
init_stream(s, 8192);
|
2014-03-13 02:21:29 +04:00
|
|
|
|
|
|
|
if (session->client_info->use_fast_path & 1) /* fastpath output supported */
|
|
|
|
{
|
|
|
|
if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_set_pointer: xrdp_rdp_init_fastpath failed");
|
2018-01-29 10:27:24 +03:00
|
|
|
free_stream(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s);
|
|
|
|
out_uint16_le(s, RDP_POINTER_CACHED);
|
|
|
|
out_uint16_le(s, 0); /* pad */
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Adding header [MS-RDPBCGR] TS_POINTER_PDU "
|
|
|
|
"messageType %d (TS_PTRMSGTYPE_CACHED), pad2Octets <ignored>",
|
|
|
|
RDP_POINTER_CACHED);
|
2014-03-13 02:21:29 +04:00
|
|
|
}
|
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
out_uint16_le(s, cache_idx); /* cache_idx */
|
|
|
|
s_mark_end(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
|
|
|
|
if (session->client_info->use_fast_path & 1) /* fastpath output supported */
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_FP_CACHEDPOINTERATTRIBUTE "
|
|
|
|
"cachedPointerUpdateData.cacheIndex %d", cache_idx);
|
2014-03-13 02:21:29 +04:00
|
|
|
if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s,
|
2020-11-30 06:29:57 +03:00
|
|
|
FASTPATH_UPDATETYPE_CACHED) != 0)
|
2014-03-13 02:21:29 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_set_pointer: xrdp_rdp_send_fastpath failed");
|
2014-07-27 02:06:35 +04:00
|
|
|
free_stream(s);
|
2014-03-13 02:21:29 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_CACHEDPOINTERATTRIBUTE "
|
|
|
|
"cacheIndex %d", cache_idx);
|
2014-03-13 02:21:29 +04:00
|
|
|
xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s,
|
2020-11-30 06:29:57 +03:00
|
|
|
RDP_DATA_PDU_POINTER);
|
2014-03-13 02:21:29 +04:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
free_stream(s);
|
|
|
|
return 0;
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_init(struct xrdp_session *session)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_init((struct xrdp_orders *)session->orders);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send(struct xrdp_session *session)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send((struct xrdp_orders *)session->orders);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_force_send(struct xrdp_session *session)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_force_send((struct xrdp_orders *)session->orders);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_rect(struct xrdp_session *session, int x, int y,
|
|
|
|
int cx, int cy, int color, struct xrdp_rect *rect)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_rect((struct xrdp_orders *)session->orders,
|
|
|
|
x, y, cx, cy, color, rect);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_screen_blt(struct xrdp_session *session, int x, int y,
|
2005-06-28 07:11:35 +04:00
|
|
|
int cx, int cy, int srcx, int srcy,
|
2012-09-20 07:51:34 +04:00
|
|
|
int rop, struct xrdp_rect *rect)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_screen_blt((struct xrdp_orders *)session->orders,
|
|
|
|
x, y, cx, cy, srcx, srcy, rop, rect);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_pat_blt(struct xrdp_session *session, int x, int y,
|
2005-06-28 07:11:35 +04:00
|
|
|
int cx, int cy, int rop, int bg_color,
|
2012-09-20 07:51:34 +04:00
|
|
|
int fg_color, struct xrdp_brush *brush,
|
|
|
|
struct xrdp_rect *rect)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_pat_blt((struct xrdp_orders *)session->orders,
|
|
|
|
x, y, cx, cy, rop, bg_color, fg_color,
|
|
|
|
brush, rect);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_dest_blt(struct xrdp_session *session, int x, int y,
|
2005-06-28 07:11:35 +04:00
|
|
|
int cx, int cy, int rop,
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_rect *rect)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_dest_blt((struct xrdp_orders *)session->orders,
|
|
|
|
x, y, cx, cy, rop, rect);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_line(struct xrdp_session *session, int mix_mode,
|
2005-06-28 07:11:35 +04:00
|
|
|
int startx, int starty,
|
|
|
|
int endx, int endy, int rop, int bg_color,
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_pen *pen,
|
|
|
|
struct xrdp_rect *rect)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_line((struct xrdp_orders *)session->orders,
|
|
|
|
mix_mode, startx, starty, endx, endy,
|
|
|
|
rop, bg_color, pen, rect);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_mem_blt(struct xrdp_session *session, int cache_id,
|
2005-06-28 07:11:35 +04:00
|
|
|
int color_table, int x, int y, int cx, int cy,
|
|
|
|
int rop, int srcx, int srcy,
|
2012-09-20 07:51:34 +04:00
|
|
|
int cache_idx, struct xrdp_rect *rect)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_mem_blt((struct xrdp_orders *)session->orders,
|
|
|
|
cache_id, color_table, x, y, cx, cy, rop,
|
|
|
|
srcx, srcy, cache_idx, rect);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2017-03-12 19:35:00 +03:00
|
|
|
int
|
2020-11-30 06:29:57 +03:00
|
|
|
libxrdp_orders_composite_blt(struct xrdp_session *session, int srcidx,
|
2013-07-07 08:03:58 +04:00
|
|
|
int srcformat, int srcwidth, int srcrepeat,
|
2020-11-30 06:29:57 +03:00
|
|
|
int *srctransform, int mskflags,
|
2013-07-07 08:03:58 +04:00
|
|
|
int mskidx, int mskformat, int mskwidth,
|
|
|
|
int mskrepeat, int op, int srcx, int srcy,
|
|
|
|
int mskx, int msky, int dstx, int dsty,
|
|
|
|
int width, int height, int dstformat,
|
2020-11-30 06:29:57 +03:00
|
|
|
struct xrdp_rect *rect)
|
2013-07-07 08:03:58 +04:00
|
|
|
{
|
2020-11-30 06:29:57 +03:00
|
|
|
return xrdp_orders_composite_blt((struct xrdp_orders *)session->orders,
|
|
|
|
srcidx, srcformat, srcwidth, srcrepeat,
|
|
|
|
srctransform, mskflags,
|
|
|
|
mskidx, mskformat, mskwidth, mskrepeat,
|
|
|
|
op, srcx, srcy, mskx, msky, dstx, dsty,
|
|
|
|
width, height, dstformat, rect);
|
2013-07-07 08:03:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2005-06-28 07:11:35 +04:00
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_text(struct xrdp_session *session,
|
2005-06-28 07:11:35 +04:00
|
|
|
int font, int flags, int mixmode,
|
|
|
|
int fg_color, int bg_color,
|
|
|
|
int clip_left, int clip_top,
|
|
|
|
int clip_right, int clip_bottom,
|
|
|
|
int box_left, int box_top,
|
|
|
|
int box_right, int box_bottom,
|
2012-09-20 07:51:34 +04:00
|
|
|
int x, int y, char *data, int data_len,
|
|
|
|
struct xrdp_rect *rect)
|
2005-06-28 07:11:35 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_text((struct xrdp_orders *)session->orders,
|
|
|
|
font, flags, mixmode, fg_color, bg_color,
|
|
|
|
clip_left, clip_top, clip_right, clip_bottom,
|
|
|
|
box_left, box_top, box_right, box_bottom,
|
|
|
|
x, y, data, data_len, rect);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_palette(struct xrdp_session *session, int *palette,
|
2005-06-28 07:11:35 +04:00
|
|
|
int cache_id)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_palette((struct xrdp_orders *)session->orders,
|
|
|
|
palette, cache_id);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_raw_bitmap(struct xrdp_session *session,
|
|
|
|
int width, int height, int bpp, char *data,
|
2005-06-28 07:11:35 +04:00
|
|
|
int cache_id, int cache_idx)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_raw_bitmap((struct xrdp_orders *)session->orders,
|
|
|
|
width, height, bpp, data,
|
|
|
|
cache_id, cache_idx);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_bitmap(struct xrdp_session *session,
|
|
|
|
int width, int height, int bpp, char *data,
|
2005-06-28 07:11:35 +04:00
|
|
|
int cache_id, int cache_idx)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_bitmap((struct xrdp_orders *)session->orders,
|
|
|
|
width, height, bpp, data,
|
|
|
|
cache_id, cache_idx);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_font(struct xrdp_session *session,
|
|
|
|
struct xrdp_font_char *font_char,
|
2005-06-28 07:11:35 +04:00
|
|
|
int font_index, int char_index)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_font((struct xrdp_orders *)session->orders,
|
|
|
|
font_char, font_index, char_index);
|
2005-06-28 07:11:35 +04:00
|
|
|
}
|
2005-08-24 05:09:33 +04:00
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2024-02-15 19:20:04 +03:00
|
|
|
libxrdp_reset(struct xrdp_session *session)
|
2005-08-24 05:09:33 +04:00
|
|
|
{
|
2023-03-14 08:53:22 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_reset:");
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
/* this will send any lingering orders */
|
|
|
|
if (xrdp_orders_reset((struct xrdp_orders *)session->orders) != 0)
|
2005-08-24 05:09:33 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_reset: xrdp_orders_reset failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
return 1;
|
2005-08-24 05:09:33 +04:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
2024-02-01 01:14:56 +03:00
|
|
|
/*
|
|
|
|
* Stop output from the client during the deactivation-reactivation
|
|
|
|
* sequence [MS-RDPBCGR] 1.3.1.3 */
|
|
|
|
xrdp_rdp_suppress_output((struct xrdp_rdp *)session->rdp, 1,
|
|
|
|
XSO_REASON_DEACTIVATE_REACTIVATE, 0, 0, 0, 0);
|
|
|
|
|
2020-05-29 15:28:04 +03:00
|
|
|
/* shut down the rdp client
|
|
|
|
*
|
|
|
|
* When resetting the lib, disable application input checks, as
|
|
|
|
* otherwise we can send a channel message to the other end while
|
|
|
|
* the channels are inactive ([MS-RDPBCGR] 3.2.5.5.1 */
|
|
|
|
session->check_for_app_input = 0;
|
2016-05-03 23:07:13 +03:00
|
|
|
if (xrdp_rdp_send_deactivate((struct xrdp_rdp *)session->rdp) != 0)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_reset: xrdp_rdp_send_deactivate failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* this should do the resizing */
|
2014-03-10 05:39:39 +04:00
|
|
|
if (xrdp_caps_send_demand_active((struct xrdp_rdp *)session->rdp) != 0)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_reset: xrdp_caps_send_demand_active failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2020-05-29 15:28:04 +03:00
|
|
|
/* Re-enable application input checks */
|
|
|
|
session->check_for_app_input = 1;
|
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
return 0;
|
2005-08-24 05:09:33 +04:00
|
|
|
}
|
2006-03-17 04:10:24 +03:00
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_raw_bitmap2(struct xrdp_session *session,
|
|
|
|
int width, int height, int bpp, char *data,
|
2006-03-17 04:10:24 +03:00
|
|
|
int cache_id, int cache_idx)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_raw_bitmap2((struct xrdp_orders *)session->orders,
|
|
|
|
width, height, bpp, data,
|
|
|
|
cache_id, cache_idx);
|
2006-03-17 04:10:24 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_bitmap2(struct xrdp_session *session,
|
|
|
|
int width, int height, int bpp, char *data,
|
2012-05-21 21:38:32 +04:00
|
|
|
int cache_id, int cache_idx, int hints)
|
2006-03-17 04:10:24 +03:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_bitmap2((struct xrdp_orders *)session->orders,
|
|
|
|
width, height, bpp, data,
|
|
|
|
cache_id, cache_idx, hints);
|
2006-03-17 04:10:24 +03:00
|
|
|
}
|
2006-12-30 08:04:13 +03:00
|
|
|
|
2012-07-18 02:24:11 +04:00
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_bitmap3(struct xrdp_session *session,
|
|
|
|
int width, int height, int bpp, char *data,
|
2012-07-18 02:24:11 +04:00
|
|
|
int cache_id, int cache_idx, int hints)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_bitmap3((struct xrdp_orders *)session->orders,
|
|
|
|
width, height, bpp, data,
|
|
|
|
cache_id, cache_idx, hints);
|
2012-07-18 02:24:11 +04:00
|
|
|
}
|
|
|
|
|
2021-01-20 20:18:21 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
|
|
|
libxrdp_get_channel_count(const struct xrdp_session *session)
|
|
|
|
{
|
|
|
|
int count = 0;
|
|
|
|
const struct xrdp_rdp *rdp = (const struct xrdp_rdp *)session->rdp;
|
|
|
|
const struct xrdp_mcs *mcs = rdp->sec_layer->mcs_layer;
|
|
|
|
|
|
|
|
if (mcs->channel_list == NULL)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_WARNING,
|
|
|
|
"libxrdp_get_channel_count - No channel initialized");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
count = mcs->channel_list->count;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2006-12-30 08:04:13 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
/* returns error */
|
|
|
|
/* this function gets the channel name and its flags, index is zero
|
|
|
|
based. either channel_name or channel_flags can be passed in nil if
|
|
|
|
they are not needed */
|
|
|
|
int EXPORT_CC
|
2021-01-20 20:18:21 +03:00
|
|
|
libxrdp_query_channel(struct xrdp_session *session, int channel_id,
|
2012-09-20 07:51:34 +04:00
|
|
|
char *channel_name, int *channel_flags)
|
|
|
|
{
|
|
|
|
int count = 0;
|
|
|
|
struct xrdp_rdp *rdp = (struct xrdp_rdp *)NULL;
|
|
|
|
struct xrdp_mcs *mcs = (struct xrdp_mcs *)NULL;
|
|
|
|
struct mcs_channel_item *channel_item = (struct mcs_channel_item *)NULL;
|
|
|
|
|
|
|
|
rdp = (struct xrdp_rdp *)session->rdp;
|
|
|
|
mcs = rdp->sec_layer->mcs_layer;
|
|
|
|
|
|
|
|
if (mcs->channel_list == NULL)
|
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_query_channel - No channel initialized");
|
2012-09-20 07:51:34 +04:00
|
|
|
return 1 ;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = mcs->channel_list->count;
|
|
|
|
|
2021-01-20 20:18:21 +03:00
|
|
|
if (channel_id < 0 || channel_id >= count)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_query_channel: Channel index out of range. "
|
|
|
|
"max channel index %d, received channel index %d",
|
2021-01-20 20:18:21 +03:00
|
|
|
count, channel_id);
|
2012-09-20 07:51:34 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
channel_item = (struct mcs_channel_item *)
|
2021-01-20 20:18:21 +03:00
|
|
|
list_get_item(mcs->channel_list, channel_id);
|
2012-09-20 07:51:34 +04:00
|
|
|
|
2021-02-04 13:11:54 +03:00
|
|
|
if (channel_item == NULL)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
|
|
|
/* this should not happen */
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_query_channel - channel item is NULL");
|
2012-09-20 07:51:34 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (channel_name != 0)
|
|
|
|
{
|
|
|
|
g_strncpy(channel_name, channel_item->name, 8);
|
2021-01-20 20:18:21 +03:00
|
|
|
LOG(LOG_LEVEL_DEBUG, "libxrdp_query_channel - Channel %d name %s",
|
|
|
|
channel_id, channel_name);
|
2012-09-20 07:51:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (channel_flags != 0)
|
|
|
|
{
|
|
|
|
*channel_flags = channel_item->flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2006-12-30 08:04:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
2016-01-14 19:32:09 +03:00
|
|
|
/* returns a zero based index of the channel, -1 if error or it doesn't
|
2006-12-30 08:04:13 +03:00
|
|
|
exist */
|
|
|
|
int EXPORT_CC
|
2016-06-22 02:30:17 +03:00
|
|
|
libxrdp_get_channel_id(struct xrdp_session *session, const char *name)
|
2012-09-20 07:51:34 +04:00
|
|
|
{
|
|
|
|
int index = 0;
|
|
|
|
int count = 0;
|
|
|
|
struct xrdp_rdp *rdp = NULL;
|
|
|
|
struct xrdp_mcs *mcs = NULL;
|
|
|
|
struct mcs_channel_item *channel_item = NULL;
|
|
|
|
|
|
|
|
rdp = (struct xrdp_rdp *)session->rdp;
|
|
|
|
mcs = rdp->sec_layer->mcs_layer;
|
|
|
|
|
|
|
|
if (mcs->channel_list == NULL)
|
|
|
|
{
|
2020-12-05 21:28:34 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_get_channel_id No channel initialized");
|
2012-09-20 07:51:34 +04:00
|
|
|
return -1 ;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = mcs->channel_list->count;
|
|
|
|
|
|
|
|
for (index = 0; index < count; index++)
|
2006-12-30 08:04:13 +03:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
channel_item = (struct mcs_channel_item *)
|
|
|
|
list_get_item(mcs->channel_list, index);
|
|
|
|
|
|
|
|
if (channel_item != 0)
|
|
|
|
{
|
|
|
|
if (g_strcasecmp(name, channel_item->name) == 0)
|
|
|
|
{
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
}
|
2006-12-30 08:04:13 +03:00
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
return -1;
|
2006-12-30 08:04:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_send_to_channel(struct xrdp_session *session, int channel_id,
|
|
|
|
char *data, int data_len,
|
2008-12-16 05:18:36 +03:00
|
|
|
int total_data_len, int flags)
|
2006-12-30 08:04:13 +03:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_rdp *rdp = NULL;
|
|
|
|
struct xrdp_sec *sec = NULL;
|
|
|
|
struct xrdp_channel *chan = NULL;
|
|
|
|
struct stream *s = NULL;
|
|
|
|
|
|
|
|
rdp = (struct xrdp_rdp *)session->rdp;
|
|
|
|
sec = rdp->sec_layer;
|
|
|
|
chan = sec->chan_layer;
|
|
|
|
make_stream(s);
|
|
|
|
init_stream(s, data_len + 1024); /* this should be big enough */
|
|
|
|
|
|
|
|
if (xrdp_channel_init(chan, s) != 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_to_channel: xrdp_channel_init failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
free_stream(s);
|
|
|
|
return 1;
|
|
|
|
}
|
2023-03-14 08:53:22 +03:00
|
|
|
else
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_TRACE, "libxrdp_send_to_channel: xrdp_channel_init successful!");
|
|
|
|
}
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
/* here we make a copy of the data */
|
|
|
|
out_uint8a(s, data, data_len);
|
|
|
|
s_mark_end(s);
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] Virtual Channel PDU "
|
|
|
|
"data <omitted from log>");
|
2012-09-20 07:51:34 +04:00
|
|
|
|
|
|
|
if (xrdp_channel_send(chan, s, channel_id, total_data_len, flags) != 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_send_to_channel: xrdp_channel_send failed");
|
2012-09-20 07:51:34 +04:00
|
|
|
free_stream(s);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-12-30 08:04:13 +03:00
|
|
|
free_stream(s);
|
2012-09-20 07:51:34 +04:00
|
|
|
return 0;
|
2006-12-30 08:04:13 +03:00
|
|
|
}
|
2008-06-24 09:43:10 +04:00
|
|
|
|
2018-10-12 08:09:20 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
int
|
|
|
|
libxrdp_disable_channel(struct xrdp_session *session, int channel_id,
|
|
|
|
int is_disabled)
|
|
|
|
{
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
struct xrdp_mcs *mcs;
|
|
|
|
struct mcs_channel_item *channel_item;
|
|
|
|
|
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
mcs = rdp->sec_layer->mcs_layer;
|
|
|
|
if (mcs->channel_list == NULL)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "Channel list is NULL");
|
2018-10-12 08:09:20 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
channel_item = (struct mcs_channel_item *)
|
|
|
|
list_get_item(mcs->channel_list, channel_id);
|
|
|
|
if (channel_item == NULL)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "Channel item is NULL");
|
2018-10-12 08:09:20 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
channel_item->disabled = is_disabled;
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_DEBUG, "%s channel %d (%s)",
|
|
|
|
(is_disabled ? "Disabling" : "Enabling"), channel_item->chanid,
|
|
|
|
channel_item->name);
|
2018-10-12 08:09:20 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2024-03-11 14:00:53 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
int
|
|
|
|
libxrdp_drdynvc_start(struct xrdp_session *session)
|
|
|
|
{
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
struct xrdp_sec *sec;
|
|
|
|
struct xrdp_channel *chan;
|
|
|
|
|
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_drdynvc_start:");
|
|
|
|
|
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
sec = rdp->sec_layer;
|
|
|
|
chan = sec->chan_layer;
|
|
|
|
return xrdp_channel_drdynvc_start(chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-10-12 08:09:20 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
int
|
|
|
|
libxrdp_drdynvc_open(struct xrdp_session *session, const char *name,
|
|
|
|
int flags, struct xrdp_drdynvc_procs *procs,
|
|
|
|
int *chan_id)
|
|
|
|
{
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
struct xrdp_sec *sec;
|
|
|
|
struct xrdp_channel *chan;
|
|
|
|
|
2023-03-14 08:53:22 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_drdynvc_open:");
|
|
|
|
|
2018-10-12 08:09:20 +03:00
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
sec = rdp->sec_layer;
|
|
|
|
chan = sec->chan_layer;
|
|
|
|
return xrdp_channel_drdynvc_open(chan, name, flags, procs, chan_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int
|
|
|
|
libxrdp_drdynvc_close(struct xrdp_session *session, int chan_id)
|
|
|
|
{
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
struct xrdp_sec *sec;
|
|
|
|
struct xrdp_channel *chan;
|
|
|
|
|
2023-03-14 08:53:22 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_drdynvc_close:");
|
|
|
|
|
2018-10-12 08:09:20 +03:00
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
sec = rdp->sec_layer;
|
|
|
|
chan = sec->chan_layer;
|
|
|
|
return xrdp_channel_drdynvc_close(chan, chan_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int
|
|
|
|
libxrdp_drdynvc_data_first(struct xrdp_session *session, int chan_id,
|
|
|
|
const char *data, int data_bytes,
|
|
|
|
int total_data_bytes)
|
|
|
|
{
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
struct xrdp_sec *sec;
|
|
|
|
struct xrdp_channel *chan;
|
|
|
|
|
2023-03-14 08:53:22 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_drdynvc_data_first:");
|
|
|
|
|
2018-10-12 08:09:20 +03:00
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
sec = rdp->sec_layer;
|
|
|
|
chan = sec->chan_layer;
|
|
|
|
return xrdp_channel_drdynvc_data_first(chan, chan_id, data, data_bytes,
|
|
|
|
total_data_bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int
|
|
|
|
libxrdp_drdynvc_data(struct xrdp_session *session, int chan_id,
|
|
|
|
const char *data, int data_bytes)
|
|
|
|
{
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
struct xrdp_sec *sec;
|
|
|
|
struct xrdp_channel *chan;
|
|
|
|
|
2023-03-14 08:53:22 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_drdynvc_data:");
|
|
|
|
|
2018-10-12 08:09:20 +03:00
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
sec = rdp->sec_layer;
|
|
|
|
chan = sec->chan_layer;
|
|
|
|
return xrdp_channel_drdynvc_data(chan, chan_id, data, data_bytes);
|
|
|
|
}
|
|
|
|
|
2008-06-24 09:43:10 +04:00
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_brush(struct xrdp_session *session,
|
2008-06-24 09:43:10 +04:00
|
|
|
int width, int height, int bpp, int type,
|
2012-09-20 07:51:34 +04:00
|
|
|
int size, char *data, int cache_id)
|
2008-06-24 09:43:10 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_brush((struct xrdp_orders *)session->orders,
|
|
|
|
width, height, bpp, type, size, data,
|
|
|
|
cache_id);
|
2008-06-24 09:43:10 +04:00
|
|
|
}
|
2012-05-18 05:48:28 +04:00
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_create_os_surface(struct xrdp_session *session, int id,
|
2012-05-22 19:27:09 +04:00
|
|
|
int width, int height,
|
2012-09-20 07:51:34 +04:00
|
|
|
struct list *del_list)
|
2012-05-18 05:48:28 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_create_os_surface
|
|
|
|
((struct xrdp_orders *)(session->orders), id,
|
|
|
|
width, height, del_list);
|
2012-05-18 05:48:28 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_orders_send_switch_os_surface(struct xrdp_session *session, int id)
|
2012-05-18 05:48:28 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
return xrdp_orders_send_switch_os_surface
|
|
|
|
((struct xrdp_orders *)(session->orders), id);
|
2012-05-18 05:48:28 +04:00
|
|
|
}
|
2012-06-25 05:10:49 +04:00
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_window_new_update(struct xrdp_session *session, int window_id,
|
|
|
|
struct rail_window_state_order *window_state,
|
2012-06-25 05:10:49 +04:00
|
|
|
int flags)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_orders *orders;
|
2012-06-25 05:10:49 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
orders = (struct xrdp_orders *)(session->orders);
|
|
|
|
return xrdp_orders_send_window_new_update(orders, window_id,
|
|
|
|
window_state, flags);
|
2012-06-25 05:10:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_window_delete(struct xrdp_session *session, int window_id)
|
2012-06-25 05:10:49 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_orders *orders;
|
2012-06-25 05:10:49 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
orders = (struct xrdp_orders *)(session->orders);
|
|
|
|
return xrdp_orders_send_window_delete(orders, window_id);
|
2012-06-25 05:10:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_window_icon(struct xrdp_session *session, int window_id,
|
2012-06-25 05:10:49 +04:00
|
|
|
int cache_entry, int cache_id,
|
2012-09-20 07:51:34 +04:00
|
|
|
struct rail_icon_info *icon_info, int flags)
|
2012-06-25 05:10:49 +04:00
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_orders *orders;
|
2012-06-25 05:10:49 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
orders = (struct xrdp_orders *)(session->orders);
|
|
|
|
return xrdp_orders_send_window_icon(orders, window_id, cache_entry,
|
|
|
|
cache_id, icon_info, flags);
|
2012-06-25 05:10:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_window_cached_icon(struct xrdp_session *session, int window_id,
|
2012-06-25 05:10:49 +04:00
|
|
|
int cache_entry, int cache_id,
|
|
|
|
int flags)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_orders *orders;
|
2012-06-25 05:10:49 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
orders = (struct xrdp_orders *)(session->orders);
|
|
|
|
return xrdp_orders_send_window_cached_icon(orders, window_id, cache_entry,
|
|
|
|
cache_id, flags);
|
2012-06-25 05:10:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_notify_new_update(struct xrdp_session *session,
|
2012-06-25 05:10:49 +04:00
|
|
|
int window_id, int notify_id,
|
2012-09-20 07:51:34 +04:00
|
|
|
struct rail_notify_state_order *notify_state,
|
2012-06-25 05:10:49 +04:00
|
|
|
int flags)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_orders *orders;
|
2012-06-25 05:10:49 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
orders = (struct xrdp_orders *)(session->orders);
|
|
|
|
return xrdp_orders_send_notify_new_update(orders, window_id, notify_id,
|
|
|
|
notify_state, flags);
|
2012-06-25 05:10:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
2017-03-12 19:35:00 +03:00
|
|
|
int
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_notify_delete(struct xrdp_session *session,
|
2012-06-25 05:10:49 +04:00
|
|
|
int window_id, int notify_id)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_orders *orders;
|
2012-06-25 05:10:49 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
orders = (struct xrdp_orders *)(session->orders);
|
|
|
|
return xrdp_orders_send_notify_delete(orders, window_id, notify_id);
|
2012-06-25 05:10:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
2017-03-12 19:35:00 +03:00
|
|
|
int
|
2012-09-20 07:51:34 +04:00
|
|
|
libxrdp_monitored_desktop(struct xrdp_session *session,
|
|
|
|
struct rail_monitored_desktop_order *mdo,
|
2012-06-25 05:10:49 +04:00
|
|
|
int flags)
|
|
|
|
{
|
2012-09-20 07:51:34 +04:00
|
|
|
struct xrdp_orders *orders;
|
2012-06-25 05:10:49 +04:00
|
|
|
|
2012-09-20 07:51:34 +04:00
|
|
|
orders = (struct xrdp_orders *)(session->orders);
|
|
|
|
return xrdp_orders_send_monitored_desktop(orders, mdo, flags);
|
2012-06-25 05:10:49 +04:00
|
|
|
}
|
2014-03-17 02:54:13 +04:00
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
|
|
|
libxrdp_codec_jpeg_compress(struct xrdp_session *session,
|
|
|
|
int format, char *inp_data,
|
|
|
|
int width, int height,
|
|
|
|
int stride, int x, int y,
|
|
|
|
int cx, int cy, int quality,
|
|
|
|
char *out_data, int *io_len)
|
|
|
|
{
|
|
|
|
struct xrdp_orders *orders;
|
2020-11-30 06:29:57 +03:00
|
|
|
void *jpeg_han;
|
2014-03-17 02:54:13 +04:00
|
|
|
|
|
|
|
orders = (struct xrdp_orders *)(session->orders);
|
|
|
|
jpeg_han = orders->jpeg_han;
|
|
|
|
return xrdp_codec_jpeg_compress(jpeg_han, format, inp_data,
|
|
|
|
width, height, stride, x, y,
|
|
|
|
cx, cy, quality, out_data, io_len);
|
|
|
|
}
|
2014-03-18 11:07:11 +04:00
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
|
|
|
libxrdp_fastpath_send_surface(struct xrdp_session *session,
|
2020-11-30 06:29:57 +03:00
|
|
|
char *data_pad, int pad_bytes,
|
2014-03-18 11:07:11 +04:00
|
|
|
int data_bytes,
|
|
|
|
int destLeft, int destTop,
|
|
|
|
int destRight, int destBottom, int bpp,
|
|
|
|
int codecID, int width, int height)
|
|
|
|
{
|
|
|
|
struct stream ls;
|
|
|
|
struct stream *s;
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
int sec_bytes;
|
|
|
|
int rdp_bytes;
|
|
|
|
int max_bytes;
|
|
|
|
int cmd_bytes;
|
|
|
|
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_fastpath_send_surface:");
|
2014-03-18 11:07:11 +04:00
|
|
|
if ((session->client_info->use_fast_path & 1) == 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "Sending data via fastpath is disabled");
|
2014-03-18 11:07:11 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
max_bytes = session->client_info->max_fastpath_frag_bytes;
|
|
|
|
if (max_bytes < 32 * 1024)
|
|
|
|
{
|
|
|
|
max_bytes = 32 * 1024;
|
|
|
|
}
|
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
rdp_bytes = xrdp_rdp_get_fastpath_bytes(rdp);
|
|
|
|
sec_bytes = xrdp_sec_get_fastpath_bytes(rdp->sec_layer);
|
|
|
|
cmd_bytes = 10 + 12;
|
|
|
|
if (data_bytes + rdp_bytes + sec_bytes + cmd_bytes > max_bytes)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "Too much data to send via fastpath. "
|
|
|
|
"Max fastpath bytes %d, received bytes %d",
|
|
|
|
max_bytes, (data_bytes + rdp_bytes + sec_bytes + cmd_bytes));
|
2014-03-18 11:07:11 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (sec_bytes + rdp_bytes + cmd_bytes > pad_bytes)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "Too much header to send via fastpath. "
|
|
|
|
"Max fastpath header bytes %d, received bytes %d",
|
|
|
|
pad_bytes, (rdp_bytes + sec_bytes + cmd_bytes));
|
2014-03-18 11:07:11 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
g_memset(&ls, 0, sizeof(ls));
|
|
|
|
s = &ls;
|
|
|
|
s->data = (data_pad + pad_bytes) - (rdp_bytes + sec_bytes + cmd_bytes);
|
|
|
|
s->sec_hdr = s->data;
|
|
|
|
s->rdp_hdr = s->sec_hdr + sec_bytes;
|
|
|
|
s->end = data_pad + pad_bytes + data_bytes;
|
2021-11-30 14:04:57 +03:00
|
|
|
s->size = s->end - s->data;
|
2014-03-18 11:07:11 +04:00
|
|
|
s->p = s->data + (rdp_bytes + sec_bytes);
|
2016-12-02 14:55:53 +03:00
|
|
|
/* TS_SURFCMD_STREAM_SURF_BITS */
|
2016-12-13 22:31:27 +03:00
|
|
|
out_uint16_le(s, CMDTYPE_STREAM_SURFACE_BITS);
|
2014-03-18 11:07:11 +04:00
|
|
|
out_uint16_le(s, destLeft);
|
|
|
|
out_uint16_le(s, destTop);
|
|
|
|
out_uint16_le(s, destRight);
|
|
|
|
out_uint16_le(s, destBottom);
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_SURFCMD_STREAM_SURF_BITS "
|
|
|
|
"cmdType 0x%4.4x (CMDTYPE_STREAM_SURFACE_BITS), destLeft %d, "
|
|
|
|
"destTop %d, destRight %d, destBottom %d, "
|
|
|
|
"bitmapData <see TS_BITMAP_DATA_EX>",
|
|
|
|
CMDTYPE_STREAM_SURFACE_BITS, destLeft, destTop, destRight,
|
|
|
|
destBottom);
|
|
|
|
|
2016-12-02 14:55:53 +03:00
|
|
|
/* TS_BITMAP_DATA_EX */
|
2014-03-18 11:07:11 +04:00
|
|
|
out_uint8(s, bpp);
|
|
|
|
out_uint8(s, 0);
|
|
|
|
out_uint8(s, 0);
|
|
|
|
out_uint8(s, codecID);
|
|
|
|
out_uint16_le(s, width);
|
|
|
|
out_uint16_le(s, height);
|
|
|
|
out_uint32_le(s, data_bytes);
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Adding field bitmapData [MS-RDPBCGR] TS_BITMAP_DATA_EX "
|
|
|
|
"bpp %d, flags 0x00, reserved 0, codecID %d, width %d, "
|
|
|
|
"height %d, bitmapDataLength %d, exBitmapDataHeader <not present>, "
|
|
|
|
"bitmapData <omitted from log>",
|
|
|
|
bpp, codecID, width, height, data_bytes);
|
|
|
|
|
2022-11-11 05:37:27 +03:00
|
|
|
if (xrdp_rdp_send_fastpath(rdp, s, FASTPATH_UPDATETYPE_SURFCMDS) != 0)
|
2014-03-18 11:07:11 +04:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR,
|
|
|
|
"libxrdp_fastpath_send_surface: xrdp_rdp_send_fastpath failed");
|
2014-03-18 11:07:11 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2015-03-29 04:34:25 +03:00
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
|
|
|
libxrdp_fastpath_send_frame_marker(struct xrdp_session *session,
|
|
|
|
int frame_action, int frame_id)
|
|
|
|
{
|
|
|
|
struct stream *s;
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
|
2020-08-02 07:04:12 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_fastpath_send_frame_marker:");
|
2015-03-29 04:34:25 +03:00
|
|
|
if ((session->client_info->use_fast_path & 1) == 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "Sending data via fastpath is disabled");
|
2015-03-29 04:34:25 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (session->client_info->use_frame_acks == 0)
|
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "Fastpath frame acks is disabled");
|
2015-03-29 04:34:25 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
make_stream(s);
|
|
|
|
init_stream(s, 8192);
|
|
|
|
xrdp_rdp_init_fastpath(rdp, s);
|
2022-11-11 05:37:27 +03:00
|
|
|
out_uint16_le(s, CMDTYPE_FRAME_MARKER);
|
2015-03-29 04:34:25 +03:00
|
|
|
out_uint16_le(s, frame_action);
|
|
|
|
out_uint32_le(s, frame_id);
|
|
|
|
s_mark_end(s);
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "Sending [MS-RDPBCGR] TS_FRAME_MARKER "
|
2022-11-11 05:37:27 +03:00
|
|
|
"cmdType 0x%4.4x (CMDTYPE_FRAME_MARKER), frameAction 0x%4.4x, "
|
|
|
|
"frameId %d",
|
|
|
|
CMDTYPE_FRAME_MARKER, frame_action, frame_id);
|
2021-02-04 13:11:54 +03:00
|
|
|
|
2022-11-11 05:37:27 +03:00
|
|
|
if (xrdp_rdp_send_fastpath(rdp, s, FASTPATH_UPDATETYPE_SURFCMDS) != 0)
|
2015-03-29 04:34:25 +03:00
|
|
|
{
|
2021-02-04 13:11:54 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR,
|
|
|
|
"libxrdp_fastpath_send_frame_marker: xrdp_rdp_send_fastpath failed");
|
2015-03-29 04:34:25 +03:00
|
|
|
free_stream(s);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
free_stream(s);
|
|
|
|
return 0;
|
2016-07-18 09:28:37 +03:00
|
|
|
}
|
2015-03-29 04:34:25 +03:00
|
|
|
|
2016-07-18 09:28:37 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
|
|
|
libxrdp_send_session_info(struct xrdp_session *session, const char *data,
|
|
|
|
int data_bytes)
|
|
|
|
{
|
|
|
|
struct xrdp_rdp *rdp;
|
|
|
|
|
|
|
|
rdp = (struct xrdp_rdp *) (session->rdp);
|
|
|
|
return xrdp_rdp_send_session_info(rdp, data, data_bytes);
|
2015-03-29 04:34:25 +03:00
|
|
|
}
|
|
|
|
|
2022-07-06 13:04:44 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
/*
|
|
|
|
Sanitise extended monitor attributes
|
|
|
|
|
|
|
|
The extended attributes are received from either
|
|
|
|
[MS-RDPEDISP] 2.2.2.2.1 (DISPLAYCONTROL_MONITOR_LAYOUT), or
|
|
|
|
[MS-RDPBCGR] 2.2.1.3.9.1 (TS_MONITOR_ATTRIBUTES)
|
|
|
|
|
|
|
|
@param monitor_layout struct containing extended attributes
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
sanitise_extended_monitor_attributes(struct monitor_info *monitor_layout)
|
|
|
|
{
|
2024-02-15 19:20:04 +03:00
|
|
|
if (monitor_layout->physical_width == 0
|
|
|
|
&& monitor_layout->physical_width == 0
|
|
|
|
&& monitor_layout->orientation == 0
|
|
|
|
&& monitor_layout->desktop_scale_factor == 0
|
|
|
|
&& monitor_layout->device_scale_factor == 0)
|
|
|
|
{
|
|
|
|
/* Module expects us to provide defaults */
|
|
|
|
monitor_layout->orientation = ORIENTATION_LANDSCAPE;
|
|
|
|
monitor_layout->desktop_scale_factor = 100;
|
|
|
|
monitor_layout->device_scale_factor = 100;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-07-06 13:04:44 +03:00
|
|
|
/* if EITHER physical_width or physical_height are
|
|
|
|
* out of range, BOTH must be ignored.
|
|
|
|
*/
|
|
|
|
if (monitor_layout->physical_width > 10000
|
|
|
|
|| monitor_layout->physical_width < 10)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_WARNING, "sanitise_extended_monitor_attributes:"
|
|
|
|
" physical_width is not within valid range."
|
|
|
|
" Setting physical_width to 0mm,"
|
|
|
|
" Setting physical_height to 0mm,"
|
|
|
|
" physical_width was: %d",
|
|
|
|
monitor_layout->physical_width);
|
|
|
|
monitor_layout->physical_width = 0;
|
|
|
|
monitor_layout->physical_height = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (monitor_layout->physical_height > 10000
|
|
|
|
|| monitor_layout->physical_height < 10)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_WARNING, "sanitise_extended_monitor_attributes:"
|
|
|
|
" physical_height is not within valid range."
|
|
|
|
" Setting physical_width to 0mm,"
|
|
|
|
" Setting physical_height to 0mm,"
|
|
|
|
" physical_height was: %d",
|
|
|
|
monitor_layout->physical_height);
|
|
|
|
monitor_layout->physical_width = 0;
|
|
|
|
monitor_layout->physical_height = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (monitor_layout->orientation)
|
|
|
|
{
|
|
|
|
case ORIENTATION_LANDSCAPE:
|
|
|
|
case ORIENTATION_PORTRAIT:
|
|
|
|
case ORIENTATION_LANDSCAPE_FLIPPED:
|
|
|
|
case ORIENTATION_PORTRAIT_FLIPPED:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
LOG(LOG_LEVEL_WARNING, "sanitise_extended_monitor_attributes:"
|
|
|
|
" Orientation is not one of %d, %d, %d, or %d."
|
|
|
|
" Value was %d and ignored and set to default value of LANDSCAPE.",
|
|
|
|
ORIENTATION_LANDSCAPE,
|
|
|
|
ORIENTATION_PORTRAIT,
|
|
|
|
ORIENTATION_LANDSCAPE_FLIPPED,
|
|
|
|
ORIENTATION_PORTRAIT_FLIPPED,
|
|
|
|
monitor_layout->orientation);
|
|
|
|
monitor_layout->orientation = ORIENTATION_LANDSCAPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
int check_desktop_scale_factor
|
|
|
|
= monitor_layout->desktop_scale_factor < 100
|
|
|
|
|| monitor_layout->desktop_scale_factor > 500;
|
|
|
|
if (check_desktop_scale_factor)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_WARNING, "sanitise_extended_monitor_attributes:"
|
|
|
|
" desktop_scale_factor is not within valid range"
|
|
|
|
" of [100, 500]. Assuming 100. Value was: %d",
|
|
|
|
monitor_layout->desktop_scale_factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
int check_device_scale_factor
|
|
|
|
= monitor_layout->device_scale_factor != 100
|
|
|
|
&& monitor_layout->device_scale_factor != 140
|
|
|
|
&& monitor_layout->device_scale_factor != 180;
|
|
|
|
if (check_device_scale_factor)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_WARNING, "sanitise_extended_monitor_attributes:"
|
|
|
|
" device_scale_factor a valid value (One of 100, 140, 180)."
|
|
|
|
" Assuming 100. Value was: %d",
|
|
|
|
monitor_layout->device_scale_factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (check_desktop_scale_factor || check_device_scale_factor)
|
|
|
|
{
|
|
|
|
monitor_layout->desktop_scale_factor = 100;
|
|
|
|
monitor_layout->device_scale_factor = 100;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-25 07:05:54 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
/*
|
|
|
|
Process a [MS-RDPBCGR] TS_UD_CS_MONITOR message.
|
|
|
|
reads the client monitors data
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
libxrdp_process_monitor_stream(struct stream *s,
|
|
|
|
struct display_size_description *description,
|
|
|
|
int full_parameters)
|
|
|
|
{
|
|
|
|
uint32_t num_monitor;
|
|
|
|
uint32_t monitor_index;
|
2024-02-15 19:20:04 +03:00
|
|
|
struct monitor_info monitors[CLIENT_MONITOR_DATA_MAXIMUM_MONITORS];
|
2021-05-25 07:05:54 +03:00
|
|
|
struct monitor_info *monitor_layout;
|
|
|
|
int monitor_struct_stream_check_bytes;
|
|
|
|
const char *monitor_struct_stream_check_message;
|
|
|
|
|
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_process_monitor_stream:");
|
|
|
|
if (description == NULL)
|
|
|
|
{
|
2024-02-15 19:20:04 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_ERROR,
|
|
|
|
"libxrdp_process_monitor_stream: description was"
|
2021-05-25 07:05:54 +03:00
|
|
|
" null. Valid pointer to allocated description expected.");
|
|
|
|
return SEC_PROCESS_MONITORS_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!s_check_rem_and_log(s, 4,
|
|
|
|
"libxrdp_process_monitor_stream:"
|
|
|
|
" Parsing [MS-RDPBCGR] TS_UD_CS_MONITOR"))
|
|
|
|
{
|
|
|
|
return SEC_PROCESS_MONITORS_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
in_uint32_le(s, num_monitor);
|
|
|
|
LOG(LOG_LEVEL_DEBUG, "libxrdp_process_monitor_stream:"
|
|
|
|
" The number of monitors received is: %d",
|
|
|
|
num_monitor);
|
|
|
|
|
|
|
|
if (num_monitor >= CLIENT_MONITOR_DATA_MAXIMUM_MONITORS)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_ERROR,
|
|
|
|
"libxrdp_process_monitor_stream: [MS-RDPBCGR] Protocol"
|
|
|
|
" error: TS_UD_CS_MONITOR monitorCount"
|
|
|
|
" MUST be less than %d, received: %d",
|
|
|
|
CLIENT_MONITOR_DATA_MAXIMUM_MONITORS, num_monitor);
|
|
|
|
return SEC_PROCESS_MONITORS_ERR_TOO_MANY_MONITORS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unfortunately the structure length values aren't directly defined in the
|
|
|
|
* Microsoft specifications. They are derived from the lengths of the
|
|
|
|
* specific structures referenced below.
|
|
|
|
*/
|
|
|
|
if (full_parameters == 0)
|
|
|
|
{
|
|
|
|
monitor_struct_stream_check_bytes = 20;
|
|
|
|
monitor_struct_stream_check_message =
|
|
|
|
"libxrdp_process_monitor_stream: Parsing monitor definitions"
|
|
|
|
" from [MS-RDPBCGR] 2.2.1.3.6.1 Monitor Definition"
|
|
|
|
" (TS_MONITOR_DEF).";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
monitor_struct_stream_check_bytes = 40;
|
|
|
|
monitor_struct_stream_check_message =
|
|
|
|
"libxrdp_process_monitor_stream: Parsing monitor definitions"
|
|
|
|
" from [MS-RDPEDISP] 2.2.2.2.1 DISPLAYCONTROL_MONITOR_LAYOUT.";
|
|
|
|
}
|
|
|
|
|
2024-02-15 19:20:04 +03:00
|
|
|
memset(monitors, 0, sizeof(monitors[0]) * num_monitor);
|
2021-05-25 07:05:54 +03:00
|
|
|
|
|
|
|
for (monitor_index = 0; monitor_index < num_monitor; ++monitor_index)
|
|
|
|
{
|
|
|
|
if (!s_check_rem_and_log(
|
|
|
|
s,
|
|
|
|
monitor_struct_stream_check_bytes,
|
|
|
|
monitor_struct_stream_check_message))
|
|
|
|
{
|
|
|
|
return SEC_PROCESS_MONITORS_ERR;
|
|
|
|
}
|
|
|
|
|
2024-02-15 19:20:04 +03:00
|
|
|
monitor_layout = &monitors[monitor_index];
|
|
|
|
|
2021-05-25 07:05:54 +03:00
|
|
|
if (full_parameters != 0)
|
|
|
|
{
|
|
|
|
in_uint32_le(s, monitor_layout->flags);
|
|
|
|
}
|
|
|
|
in_uint32_le(s, monitor_layout->left);
|
|
|
|
in_uint32_le(s, monitor_layout->top);
|
|
|
|
|
|
|
|
if (full_parameters == 0)
|
|
|
|
{
|
|
|
|
in_uint32_le(s, monitor_layout->right);
|
|
|
|
in_uint32_le(s, monitor_layout->bottom);
|
|
|
|
in_uint32_le(s, monitor_layout->is_primary);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 2.2.1.3.6.1 Monitor Definition (TS_MONITOR_DEF)
|
|
|
|
*/
|
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_process_monitor_stream:"
|
|
|
|
" Received [MS-RDPBCGR] 2.2.1.3.6.1"
|
|
|
|
" TS_UD_CS_MONITOR.TS_MONITOR_DEF"
|
|
|
|
" Index: %d, Left %d, Top %d, Right %d, Bottom %d,"
|
|
|
|
" Flags 0x%8.8x",
|
|
|
|
monitor_index,
|
|
|
|
monitor_layout->left,
|
|
|
|
monitor_layout->top,
|
|
|
|
monitor_layout->right,
|
|
|
|
monitor_layout->bottom,
|
|
|
|
monitor_layout->is_primary);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Per spec (2.2.2.2.1 DISPLAYCONTROL_MONITOR_LAYOUT),
|
|
|
|
* this is the width.
|
|
|
|
* 200 <= width <= 8192 and must not be odd.
|
|
|
|
* Ex: in_uint32_le(s, monitor_layout->width);
|
|
|
|
*/
|
2022-04-07 17:43:50 +03:00
|
|
|
int width;
|
|
|
|
in_uint32_le(s, width);
|
|
|
|
if (width > CLIENT_MONITOR_DATA_MAXIMUM_VIRTUAL_MONITOR_WIDTH ||
|
|
|
|
width < CLIENT_MONITOR_DATA_MINIMUM_VIRTUAL_MONITOR_WIDTH ||
|
|
|
|
width % 2 != 0)
|
2021-05-25 07:05:54 +03:00
|
|
|
{
|
|
|
|
return SEC_PROCESS_MONITORS_ERR_INVALID_MONITOR;
|
|
|
|
}
|
2022-04-07 17:43:50 +03:00
|
|
|
monitor_layout->right = monitor_layout->left + width - 1;
|
2021-05-25 07:05:54 +03:00
|
|
|
|
|
|
|
/* Per spec (2.2.2.2.1 DISPLAYCONTROL_MONITOR_LAYOUT),
|
|
|
|
* this is the height.
|
|
|
|
* 200 <= height <= 8192
|
|
|
|
* Ex: in_uint32_le(s, monitor_layout->height);
|
|
|
|
*/
|
2022-04-07 17:43:50 +03:00
|
|
|
int height;
|
|
|
|
in_uint32_le(s, height);
|
|
|
|
if (height > CLIENT_MONITOR_DATA_MAXIMUM_VIRTUAL_MONITOR_HEIGHT ||
|
|
|
|
height < CLIENT_MONITOR_DATA_MINIMUM_VIRTUAL_MONITOR_HEIGHT)
|
2021-05-25 07:05:54 +03:00
|
|
|
{
|
|
|
|
return SEC_PROCESS_MONITORS_ERR_INVALID_MONITOR;
|
|
|
|
}
|
2022-04-07 17:43:50 +03:00
|
|
|
monitor_layout->bottom = monitor_layout->top + height - 1;
|
2021-05-25 07:05:54 +03:00
|
|
|
|
|
|
|
in_uint32_le(s, monitor_layout->physical_width);
|
|
|
|
in_uint32_le(s, monitor_layout->physical_height);
|
|
|
|
in_uint32_le(s, monitor_layout->orientation);
|
|
|
|
in_uint32_le(s, monitor_layout->desktop_scale_factor);
|
|
|
|
in_uint32_le(s, monitor_layout->device_scale_factor);
|
2022-07-03 00:43:08 +03:00
|
|
|
|
2021-05-25 07:05:54 +03:00
|
|
|
/*
|
|
|
|
* 2.2.2.2.1 DISPLAYCONTROL_MONITOR_LAYOUT
|
|
|
|
*/
|
2022-03-20 09:55:09 +03:00
|
|
|
LOG_DEVEL(LOG_LEVEL_INFO, "libxrdp_process_monitor_stream:"
|
2021-05-25 07:05:54 +03:00
|
|
|
" Received [MS-RDPEDISP] 2.2.2.2.1"
|
|
|
|
" DISPLAYCONTROL_MONITOR_LAYOUT_PDU"
|
|
|
|
".DISPLAYCONTROL_MONITOR_LAYOUT"
|
|
|
|
" Index: %d, Flags 0x%8.8x, Left %d, Top %d, Width %d,"
|
|
|
|
" Height %d, PhysicalWidth %d, PhysicalHeight %d,"
|
|
|
|
" Orientation %d, DesktopScaleFactor %d,"
|
|
|
|
" DeviceScaleFactor %d",
|
|
|
|
monitor_index,
|
|
|
|
monitor_layout->flags,
|
|
|
|
monitor_layout->left,
|
|
|
|
monitor_layout->top,
|
2022-04-07 17:43:50 +03:00
|
|
|
width,
|
|
|
|
height,
|
2021-05-25 07:05:54 +03:00
|
|
|
monitor_layout->physical_width,
|
|
|
|
monitor_layout->physical_height,
|
|
|
|
monitor_layout->orientation,
|
|
|
|
monitor_layout->desktop_scale_factor,
|
|
|
|
monitor_layout->device_scale_factor);
|
|
|
|
|
|
|
|
if (monitor_layout->flags == DISPLAYCONTROL_MONITOR_PRIMARY)
|
|
|
|
{
|
|
|
|
monitor_layout->is_primary = TS_MONITOR_PRIMARY;
|
|
|
|
}
|
|
|
|
}
|
2024-02-15 19:20:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return libxrdp_init_display_size_description(
|
|
|
|
num_monitor, monitors, description);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int
|
|
|
|
libxrdp_process_monitor_ex_stream(struct stream *s,
|
|
|
|
struct display_size_description *description)
|
|
|
|
{
|
|
|
|
uint32_t num_monitor;
|
|
|
|
uint32_t monitor_index;
|
|
|
|
uint32_t attribute_size;
|
|
|
|
struct monitor_info *monitor_layout;
|
|
|
|
|
|
|
|
LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_process_monitor_ex_stream:");
|
|
|
|
if (description == NULL)
|
|
|
|
{
|
|
|
|
LOG_DEVEL(LOG_LEVEL_ERROR, "libxrdp_process_monitor_ex_stream: "
|
|
|
|
"description was null. "
|
|
|
|
" Valid pointer to allocated description expected.");
|
|
|
|
return SEC_PROCESS_MONITORS_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!s_check_rem_and_log(s, 4,
|
|
|
|
"libxrdp_process_monitor_ex_stream:"
|
|
|
|
" Parsing [MS-RDPBCGR] TS_UD_CS_MONITOR_EX"))
|
|
|
|
{
|
|
|
|
return SEC_PROCESS_MONITORS_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
in_uint32_le(s, attribute_size);
|
|
|
|
if (attribute_size != TS_MONITOR_ATTRIBUTES_SIZE)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_ERROR,
|
|
|
|
"libxrdp_process_monitor_ex_stream: [MS-RDPBCGR] Protocol"
|
|
|
|
" error: TS_UD_CS_MONITOR_EX monitorAttributeSize"
|
|
|
|
" MUST be %d, received: %d",
|
|
|
|
TS_MONITOR_ATTRIBUTES_SIZE, attribute_size);
|
|
|
|
return SEC_PROCESS_MONITORS_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
in_uint32_le(s, num_monitor);
|
|
|
|
LOG(LOG_LEVEL_DEBUG, "libxrdp_process_monitor_ex_stream:"
|
|
|
|
" The number of monitors received is: %d",
|
|
|
|
num_monitor);
|
|
|
|
|
|
|
|
if (num_monitor != description->monitorCount)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_ERROR,
|
|
|
|
"libxrdp_process_monitor_ex_stream: [MS-RDPBCGR] Protocol"
|
|
|
|
" error: TS_UD_CS_MONITOR monitorCount"
|
|
|
|
" MUST be %d, received: %d",
|
|
|
|
description->monitorCount, num_monitor);
|
|
|
|
return SEC_PROCESS_MONITORS_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (monitor_index = 0; monitor_index < num_monitor; ++monitor_index)
|
|
|
|
{
|
|
|
|
if (!s_check_rem_and_log(s, attribute_size,
|
|
|
|
"libxrdp_process_monitor_ex_stream:"
|
|
|
|
" Parsing TS_UD_CS_MONITOR_EX"))
|
|
|
|
{
|
|
|
|
return SEC_PROCESS_MONITORS_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
monitor_layout = description->minfo + monitor_index;
|
|
|
|
|
|
|
|
in_uint32_le(s, monitor_layout->physical_width);
|
|
|
|
in_uint32_le(s, monitor_layout->physical_height);
|
|
|
|
in_uint32_le(s, monitor_layout->orientation);
|
|
|
|
in_uint32_le(s, monitor_layout->desktop_scale_factor);
|
|
|
|
in_uint32_le(s, monitor_layout->device_scale_factor);
|
|
|
|
|
|
|
|
sanitise_extended_monitor_attributes(monitor_layout);
|
|
|
|
|
|
|
|
LOG_DEVEL(LOG_LEVEL_INFO, "libxrdp_process_monitor_ex_stream:"
|
|
|
|
" Received [MS-RDPBCGR] 2.2.1.3.9.1 "
|
|
|
|
" TS_MONITOR_ATTRIBUTES"
|
|
|
|
" Index: %d, PhysicalWidth %d, PhysicalHeight %d,"
|
|
|
|
" Orientation %d, DesktopScaleFactor %d,"
|
|
|
|
" DeviceScaleFactor %d",
|
|
|
|
monitor_index,
|
|
|
|
monitor_layout->physical_width,
|
|
|
|
monitor_layout->physical_height,
|
|
|
|
monitor_layout->orientation,
|
|
|
|
monitor_layout->desktop_scale_factor,
|
|
|
|
monitor_layout->device_scale_factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update non negative monitor info values */
|
|
|
|
const struct monitor_info *src = description->minfo;
|
|
|
|
struct monitor_info *dst = description->minfo_wm;
|
|
|
|
for (monitor_index = 0; monitor_index < num_monitor; ++monitor_index)
|
|
|
|
{
|
|
|
|
dst->physical_width = src->physical_width;
|
|
|
|
dst->physical_height = src->physical_height;
|
|
|
|
dst->orientation = src->orientation;
|
|
|
|
dst->desktop_scale_factor = src->desktop_scale_factor;
|
|
|
|
dst->device_scale_factor = src->device_scale_factor;
|
|
|
|
++src;
|
|
|
|
++dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
int
|
|
|
|
libxrdp_init_display_size_description(
|
|
|
|
unsigned int num_monitor,
|
|
|
|
const struct monitor_info *monitors,
|
|
|
|
struct display_size_description *description)
|
|
|
|
{
|
|
|
|
unsigned int monitor_index;
|
|
|
|
struct monitor_info *monitor_layout;
|
|
|
|
struct xrdp_rect all_monitors_encompassing_bounds = {0};
|
|
|
|
int got_primary = 0;
|
|
|
|
|
|
|
|
/* Caller should have checked this, so don't log an error */
|
|
|
|
if (num_monitor > CLIENT_MONITOR_DATA_MAXIMUM_MONITORS)
|
|
|
|
{
|
|
|
|
return SEC_PROCESS_MONITORS_ERR_TOO_MANY_MONITORS;
|
|
|
|
}
|
|
|
|
|
|
|
|
description->monitorCount = num_monitor;
|
|
|
|
for (monitor_index = 0 ; monitor_index < num_monitor; ++monitor_index)
|
|
|
|
{
|
|
|
|
monitor_layout = &description->minfo[monitor_index];
|
|
|
|
*monitor_layout = monitors[monitor_index];
|
|
|
|
sanitise_extended_monitor_attributes(monitor_layout);
|
2021-05-25 07:05:54 +03:00
|
|
|
|
|
|
|
if (monitor_index == 0)
|
|
|
|
{
|
|
|
|
all_monitors_encompassing_bounds.left = monitor_layout->left;
|
|
|
|
all_monitors_encompassing_bounds.top = monitor_layout->top;
|
|
|
|
all_monitors_encompassing_bounds.right = monitor_layout->right;
|
|
|
|
all_monitors_encompassing_bounds.bottom = monitor_layout->bottom;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
all_monitors_encompassing_bounds.left =
|
|
|
|
MIN(monitor_layout->left,
|
|
|
|
all_monitors_encompassing_bounds.left);
|
|
|
|
all_monitors_encompassing_bounds.top =
|
|
|
|
MIN(monitor_layout->top,
|
|
|
|
all_monitors_encompassing_bounds.top);
|
|
|
|
all_monitors_encompassing_bounds.right =
|
|
|
|
MAX(all_monitors_encompassing_bounds.right,
|
|
|
|
monitor_layout->right);
|
|
|
|
all_monitors_encompassing_bounds.bottom =
|
|
|
|
MAX(all_monitors_encompassing_bounds.bottom,
|
|
|
|
monitor_layout->bottom);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (monitor_layout->is_primary == TS_MONITOR_PRIMARY)
|
|
|
|
{
|
2024-02-15 19:20:04 +03:00
|
|
|
if (got_primary)
|
|
|
|
{
|
|
|
|
// Already got one - don't have two
|
|
|
|
monitor_layout->is_primary = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
got_primary = 1;
|
|
|
|
}
|
2021-05-25 07:05:54 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!got_primary)
|
|
|
|
{
|
|
|
|
/* no primary monitor was set,
|
|
|
|
* choose the leftmost monitor as primary.
|
|
|
|
*/
|
|
|
|
for (monitor_index = 0; monitor_index < num_monitor; ++monitor_index)
|
|
|
|
{
|
|
|
|
monitor_layout = description->minfo + monitor_index;
|
|
|
|
if (monitor_layout->left
|
|
|
|
== all_monitors_encompassing_bounds.left
|
|
|
|
&& monitor_layout->top
|
|
|
|
== all_monitors_encompassing_bounds.top)
|
|
|
|
{
|
|
|
|
monitor_layout->is_primary = TS_MONITOR_PRIMARY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-16 05:17:05 +03:00
|
|
|
/* set wm geometry if the encompassing area is well formed.
|
|
|
|
Otherwise, log and return an error.
|
|
|
|
*/
|
2021-05-25 07:05:54 +03:00
|
|
|
if (all_monitors_encompassing_bounds.right
|
|
|
|
> all_monitors_encompassing_bounds.left
|
|
|
|
&& all_monitors_encompassing_bounds.bottom
|
|
|
|
> all_monitors_encompassing_bounds.top)
|
|
|
|
{
|
|
|
|
description->session_width =
|
|
|
|
all_monitors_encompassing_bounds.right
|
|
|
|
- all_monitors_encompassing_bounds.left + 1;
|
|
|
|
description->session_height =
|
|
|
|
all_monitors_encompassing_bounds.bottom
|
|
|
|
- all_monitors_encompassing_bounds.top + 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2024-02-15 19:20:04 +03:00
|
|
|
LOG(LOG_LEVEL_ERROR, "libxrdp_init_display_size_description:"
|
2021-05-25 07:05:54 +03:00
|
|
|
" The area encompassing the monitors is not a"
|
|
|
|
" well-formed rectangle. Received"
|
|
|
|
" (top: %d, left: %d, right: %d, bottom: %d)."
|
|
|
|
" This will prevent initialization.",
|
|
|
|
all_monitors_encompassing_bounds.top,
|
|
|
|
all_monitors_encompassing_bounds.left,
|
|
|
|
all_monitors_encompassing_bounds.right,
|
|
|
|
all_monitors_encompassing_bounds.bottom);
|
|
|
|
return SEC_PROCESS_MONITORS_ERR_INVALID_DESKTOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure virtual desktop size is OK
|
|
|
|
* 2.2.1.3.6 Client Monitor Data (TS_UD_CS_MONITOR)
|
|
|
|
*/
|
|
|
|
if (description->session_width
|
|
|
|
> CLIENT_MONITOR_DATA_MAXIMUM_VIRTUAL_DESKTOP_WIDTH
|
|
|
|
|| description->session_width
|
|
|
|
< CLIENT_MONITOR_DATA_MINIMUM_VIRTUAL_DESKTOP_WIDTH
|
|
|
|
|| description->session_height
|
|
|
|
> CLIENT_MONITOR_DATA_MAXIMUM_VIRTUAL_DESKTOP_HEIGHT
|
|
|
|
|| description->session_height
|
|
|
|
< CLIENT_MONITOR_DATA_MINIMUM_VIRTUAL_DESKTOP_HEIGHT)
|
|
|
|
{
|
|
|
|
LOG(LOG_LEVEL_ERROR,
|
2024-02-15 19:20:04 +03:00
|
|
|
"libxrdp_init_display_size_description: Calculated virtual"
|
2021-05-25 07:05:54 +03:00
|
|
|
" desktop width or height is invalid."
|
|
|
|
" Allowed width range: min %d, max %d. Width received: %d."
|
|
|
|
" Allowed height range: min %d, max %d. Height received: %d",
|
|
|
|
CLIENT_MONITOR_DATA_MINIMUM_VIRTUAL_DESKTOP_WIDTH,
|
|
|
|
CLIENT_MONITOR_DATA_MAXIMUM_VIRTUAL_DESKTOP_WIDTH,
|
|
|
|
description->session_width,
|
|
|
|
CLIENT_MONITOR_DATA_MINIMUM_VIRTUAL_DESKTOP_HEIGHT,
|
|
|
|
CLIENT_MONITOR_DATA_MAXIMUM_VIRTUAL_DESKTOP_HEIGHT,
|
|
|
|
description->session_width);
|
|
|
|
return SEC_PROCESS_MONITORS_ERR_INVALID_DESKTOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* keep a copy of non negative monitor info values for xrdp_wm usage */
|
|
|
|
for (monitor_index = 0; monitor_index < num_monitor; ++monitor_index)
|
|
|
|
{
|
|
|
|
monitor_layout = description->minfo_wm + monitor_index;
|
|
|
|
|
2024-02-15 19:20:04 +03:00
|
|
|
*monitor_layout = description->minfo[monitor_index];
|
2021-05-25 07:05:54 +03:00
|
|
|
|
|
|
|
monitor_layout->left =
|
|
|
|
monitor_layout->left - all_monitors_encompassing_bounds.left;
|
|
|
|
monitor_layout->top =
|
|
|
|
monitor_layout->top - all_monitors_encompassing_bounds.top;
|
|
|
|
monitor_layout->right =
|
|
|
|
monitor_layout->right - all_monitors_encompassing_bounds.left;
|
|
|
|
monitor_layout->bottom =
|
|
|
|
monitor_layout->bottom - all_monitors_encompassing_bounds.top;
|
|
|
|
}
|
2022-07-06 13:04:44 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-03-16 05:17:05 +03:00
|
|
|
/*****************************************************************************/
|
|
|
|
int EXPORT_CC
|
|
|
|
libxrdp_planar_compress(char *in_data, int width, int height,
|
|
|
|
struct stream *s, int bpp, int byte_limit,
|
|
|
|
int start_line, struct stream *temp_s,
|
|
|
|
int e, int flags)
|
|
|
|
{
|
|
|
|
return xrdp_bitmap32_compress(in_data, width, height,
|
|
|
|
s, bpp, byte_limit,
|
|
|
|
start_line, temp_s,
|
|
|
|
e, flags);
|
|
|
|
}
|