jh163888/xrdp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #1738 from aquesnel/unify_logging_libxrdp

Browse Source 
Unify logging in libxrdp
This commit is contained in:
metalefty 2020-12-23 09:59:21 +09:00 committed by GitHub
commit bba65b3592
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 1022 additions and 1053 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
common/defines.h
View File

@ -40,6 +40,9 @@
#define LOWORD(in) ((in) & 0x0000ffff) #define LOWORD(in) ((in) & 0x0000ffff)
#undef MAKELONG #undef MAKELONG
#define MAKELONG(lo, hi) ((((hi) & 0xffff) << 16) | ((lo) & 0xffff)) #define MAKELONG(lo, hi) ((((hi) & 0xffff) << 16) | ((lo) & 0xffff))
#define UNUSED_VAR(x) ((void) (x))
/* graphics macros */
#define MAKERECT(r, x, y, cx, cy) \ #define MAKERECT(r, x, y, cx, cy) \
{ (r).left = x; (r).top = y; (r).right = (x) + (cx); (r).bottom = (y) + (cy); } { (r).left = x; (r).top = y; (r).right = (x) + (cx); (r).bottom = (y) + (cy); }
#define ISRECTEMPTY(r) (((r).right <= (r).left) || ((r).bottom <= (r).top)) #define ISRECTEMPTY(r) (((r).right <= (r).left) || ((r).bottom <= (r).top))

217
libxrdp/libxrdp.c
View File

@ -28,11 +28,7 @@
#include "ms-rdpbcgr.h" #include "ms-rdpbcgr.h"
#define LOG_LEVEL 1
#define LLOG(_level, _args) \
do { if (_level < LOG_LEVEL) { g_write _args ; } } while (0)
#define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { g_writeln _args ; } } while (0)
#define MAX_BITMAP_BUF_SIZE (16 * 1024) /* 16K */ #define MAX_BITMAP_BUF_SIZE (16 * 1024) /* 16K */
@ -126,7 +122,7 @@ libxrdp_get_pdu_bytes(const char *aheader)
/******************************************************************************/ /******************************************************************************/
/* only used during connection */ /* only used during connection */
struct stream * struct stream *
libxrdp_force_read(struct trans* trans) libxrdp_force_read(struct trans *trans)
{ {
int bytes; int bytes;
struct stream *s; struct stream *s;
@ -136,18 +132,18 @@ libxrdp_force_read(struct trans* trans)
if (trans_force_read(trans, 4) != 0) if (trans_force_read(trans, 4) != 0)
{ {
g_writeln("libxrdp_force_read: header read error"); LOG(LOG_LEVEL_WARNING, "libxrdp_force_read: header read error");
return 0; return 0;
} }
bytes = libxrdp_get_pdu_bytes(s->data); bytes = libxrdp_get_pdu_bytes(s->data);
if (bytes < 4 || bytes > s->size) if (bytes < 4 || bytes > s->size)
{ {
g_writeln("libxrdp_force_read: bad header length %d", bytes); LOG(LOG_LEVEL_WARNING, "libxrdp_force_read: bad header length %d", bytes);
return 0; return 0;
} }
if (trans_force_read(trans, bytes - 4) != 0) if (trans_force_read(trans, bytes - 4) != 0)
{ {
g_writeln("libxrdp_force_read: Can't read PDU"); LOG(LOG_LEVEL_WARNING, "libxrdp_force_read: Can't read PDU");
return 0; return 0;
} }
return s; return s;
@ -168,12 +164,12 @@ libxrdp_process_data(struct xrdp_session *session, struct stream *s)
do_read = s == 0; do_read = s == 0;
if (do_read && session->up_and_running) if (do_read && session->up_and_running)
{ {
g_writeln("libxrdp_process_data: error logic"); LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: error logic");
return 1; return 1;
} }
if (session->in_process_data != 0) if (session->in_process_data != 0)
{ {
g_writeln("libxrdp_process_data: error reentry"); LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: error reentry");
return 1; return 1;
} }
session->in_process_data++; session->in_process_data++;
@ -213,7 +209,7 @@ libxrdp_process_data(struct xrdp_session *session, struct stream *s)
} }
if (s == 0) if (s == 0)
{ {
g_writeln("libxrdp_process_data: libxrdp_force_read failed"); LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: libxrdp_force_read failed");
rv = 1; rv = 1;
break; break;
} }
@ -221,12 +217,12 @@ libxrdp_process_data(struct xrdp_session *session, struct stream *s)
if (xrdp_rdp_recv(rdp, s, &code) != 0) if (xrdp_rdp_recv(rdp, s, &code) != 0)
{ {
g_writeln("libxrdp_process_data: xrdp_rdp_recv failed"); LOG(LOG_LEVEL_ERROR, "libxrdp_process_data: xrdp_rdp_recv failed");
rv = 1; rv = 1;
break; break;
} }
DEBUG(("libxrdp_process_data code %d", code)); LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_process_data code %d", code);
switch (code) switch (code)
{ {
@ -243,7 +239,7 @@ libxrdp_process_data(struct xrdp_session *session, struct stream *s)
case PDUTYPE_DATAPDU: case PDUTYPE_DATAPDU:
if (xrdp_rdp_process_data(rdp, s) != 0) if (xrdp_rdp_process_data(rdp, s) != 0)
{ {
DEBUG(("libxrdp_process_data returned non zero")); LOG(LOG_LEVEL_ERROR, "libxrdp_process_data returned non zero");
cont = 0; cont = 0;
term = 1; term = 1;
} }
@ -251,13 +247,13 @@ libxrdp_process_data(struct xrdp_session *session, struct stream *s)
case 2: /* FASTPATH_INPUT_EVENT */ case 2: /* FASTPATH_INPUT_EVENT */
if (xrdp_fastpath_process_input_event(rdp->sec_layer->fastpath_layer, s) != 0) if (xrdp_fastpath_process_input_event(rdp->sec_layer->fastpath_layer, s) != 0)
{ {
DEBUG(("libxrdp_process_data returned non zero")); LOG(LOG_LEVEL_ERROR, "libxrdp_process_data returned non zero");
cont = 0; cont = 0;
term = 1; term = 1;
} }
break; break;
default: default:
g_writeln("unknown in libxrdp_process_data: code= %d", code); LOG(LOG_LEVEL_ERROR, "unknown in libxrdp_process_data: code= %d", code);
dead_lock_counter++; dead_lock_counter++;
break; break;
} }
@ -266,8 +262,8 @@ libxrdp_process_data(struct xrdp_session *session, struct stream *s)
{ {
/*This situation can happen and this is a workaround*/ /*This situation can happen and this is a workaround*/
cont = 0; cont = 0;
g_writeln("Serious programming error: we were locked in a deadly loop"); LOG(LOG_LEVEL_ERROR, "Serious programming error: we were locked in a deadly loop");
g_writeln("Remaining: %d", (int) (s->end - s->next_packet)); LOG(LOG_LEVEL_ERROR, "Remaining: %d", (int) (s->end - s->next_packet));
s->next_packet = 0; s->next_packet = 0;
} }
@ -296,7 +292,7 @@ libxrdp_send_palette(struct xrdp_session *session, int *palette)
return 0; return 0;
} }
DEBUG(("libxrdp_send_palette sending palette")); LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_send_palette sending palette");
/* clear orders */ /* clear orders */
libxrdp_orders_force_send(session); libxrdp_orders_force_send(session);
@ -305,15 +301,16 @@ libxrdp_send_palette(struct xrdp_session *session, int *palette)
if (session->client_info->use_fast_path & 1) /* fastpath output supported */ if (session->client_info->use_fast_path & 1) /* fastpath output supported */
{ {
LLOGLN(10, ("libxrdp_send_palette: fastpath")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_palette: fastpath");
if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0) if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0)
{ {
free_stream(s); free_stream(s);
return 1; return 1;
} }
} }
else { else
LLOGLN(10, ("libxrdp_send_palette: slowpath")); {
LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_palette: slowpath");
xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s); xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s);
} }
@ -334,16 +331,16 @@ libxrdp_send_palette(struct xrdp_session *session, int *palette)
s_mark_end(s); s_mark_end(s);
if (session->client_info->use_fast_path & 1) /* fastpath output supported */ if (session->client_info->use_fast_path & 1) /* fastpath output supported */
{ {
if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s, if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s,
FASTPATH_UPDATETYPE_PALETTE) != 0) FASTPATH_UPDATETYPE_PALETTE) != 0)
{ {
free_stream(s); free_stream(s);
return 1; return 1;
} }
} }
else else
{ {
xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s, xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s,
RDP_DATA_PDU_UPDATE); RDP_DATA_PDU_UPDATE);
} }
free_stream(s); free_stream(s);
@ -367,7 +364,7 @@ libxrdp_send_bell(struct xrdp_session *session)
{ {
struct stream *s = (struct stream *)NULL; struct stream *s = (struct stream *)NULL;
DEBUG(("libxrdp_send_bell sending bell signal")); LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_send_bell sending bell signal");
/* see MS documentation: Server play sound PDU, TS_PLAY_SOUND_PDU_DATA */ /* see MS documentation: Server play sound PDU, TS_PLAY_SOUND_PDU_DATA */
make_stream(s); make_stream(s);
@ -418,7 +415,7 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
struct stream *temp_s = (struct stream *)NULL; struct stream *temp_s = (struct stream *)NULL;
tui32 pixel; tui32 pixel;
LLOGLN(10, ("libxrdp_send_bitmap: sending bitmap")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: sending bitmap");
Bpp = (bpp + 7) / 8; Bpp = (bpp + 7) / 8;
e = (4 - width) & 3; e = (4 - width) & 3;
switch (bpp) switch (bpp)
@ -438,14 +435,14 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
line_bytes = width * Bpp; line_bytes = width * Bpp;
line_pad_bytes = line_bytes + e * Bpp; line_pad_bytes = line_bytes + e * Bpp;
LLOGLN(10, ("libxrdp_send_bitmap: bpp %d Bpp %d line_bytes %d " LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: bpp %d Bpp %d line_bytes %d "
"server_line_bytes %d", bpp, Bpp, line_bytes, server_line_bytes)); "server_line_bytes %d", bpp, Bpp, line_bytes, server_line_bytes);
make_stream(s); make_stream(s);
init_stream(s, MAX_BITMAP_BUF_SIZE); init_stream(s, MAX_BITMAP_BUF_SIZE);
if (session->client_info->use_bitmap_comp) if (session->client_info->use_bitmap_comp)
{ {
LLOGLN(10, ("libxrdp_send_bitmap: compression")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: compression");
make_stream(temp_s); make_stream(temp_s);
init_stream(temp_s, 65536); init_stream(temp_s, 65536);
i = 0; i = 0;
@ -457,7 +454,7 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
while (i > 0) while (i > 0)
{ {
LLOGLN(10, ("libxrdp_send_bitmap: i %d", i)); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: i %d", i);
total_bufsize = 0; total_bufsize = 0;
num_updates = 0; num_updates = 0;
@ -481,22 +478,22 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
if (bpp > 24) if (bpp > 24)
{ {
LLOGLN(10, ("libxrdp_send_bitmap: 32 bpp")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: 32 bpp");
lines_sending = xrdp_bitmap32_compress(data, width, height, lines_sending = xrdp_bitmap32_compress(data, width, height,
s, 32, s, 32,
(MAX_BITMAP_BUF_SIZE - 100) - total_bufsize, (MAX_BITMAP_BUF_SIZE - 100) - total_bufsize,
i - 1, temp_s, e, 0x10); i - 1, temp_s, e, 0x10);
LLOGLN(10, ("libxrdp_send_bitmap: i %d lines_sending %d", LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: i %d lines_sending %d",
i, lines_sending)); i, lines_sending);
} }
else else
{ {
lines_sending = xrdp_bitmap_compress(data, width, height, lines_sending = xrdp_bitmap_compress(data, width, height,
s, bpp, s, bpp,
(MAX_BITMAP_BUF_SIZE - 100) - total_bufsize, (MAX_BITMAP_BUF_SIZE - 100) - total_bufsize,
i - 1, temp_s, e); i - 1, temp_s, e);
LLOGLN(10, ("libxrdp_send_bitmap: i %d lines_sending %d", LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: i %d lines_sending %d",
i, lines_sending)); i, lines_sending);
} }
if (lines_sending == 0) if (lines_sending == 0)
@ -539,29 +536,29 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
total_bufsize += 26; /* bytes since pop layer */ total_bufsize += 26; /* bytes since pop layer */
} }
LLOGLN(10, ("libxrdp_send_bitmap: decompressed pixels %d " LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: decompressed pixels %d "
"decompressed bytes %d compressed bytes %d", "decompressed bytes %d compressed bytes %d",
lines_sending * (width + e), lines_sending * (width + e),
line_pad_bytes * lines_sending, bufsize)); line_pad_bytes * lines_sending, bufsize);
if (j > MAX_BITMAP_BUF_SIZE) if (j > MAX_BITMAP_BUF_SIZE)
{ {
LLOGLN(0, ("libxrdp_send_bitmap: error, decompressed " LOG(LOG_LEVEL_WARNING, "libxrdp_send_bitmap: error, decompressed "
"size too big: %d bytes", j)); "size too big: %d bytes", j);
} }
if (bufsize > MAX_BITMAP_BUF_SIZE) if (bufsize > MAX_BITMAP_BUF_SIZE)
{ {
LLOGLN(0, ("libxrdp_send_bitmap: error, compressed size " LOG(LOG_LEVEL_WARNING, "libxrdp_send_bitmap: error, compressed size "
"too big: %d bytes", bufsize)); "too big: %d bytes", bufsize);
} }
s->p = s->end; s->p = s->end;
} }
while (total_bufsize < MAX_BITMAP_BUF_SIZE && i > 0); while (total_bufsize < MAX_BITMAP_BUF_SIZE && i > 0);
LLOGLN(10, ("libxrdp_send_bitmap: num_updates %d total_bufsize %d", LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: num_updates %d total_bufsize %d",
num_updates, total_bufsize)); num_updates, total_bufsize);
p_num_updates[0] = num_updates; p_num_updates[0] = num_updates;
p_num_updates[1] = num_updates >> 8; p_num_updates[1] = num_updates >> 8;
@ -570,8 +567,8 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
if (total_bufsize > MAX_BITMAP_BUF_SIZE) if (total_bufsize > MAX_BITMAP_BUF_SIZE)
{ {
LLOGLN(0, ("libxrdp_send_bitmap: error, total compressed " LOG(LOG_LEVEL_WARNING, "libxrdp_send_bitmap: error, total compressed "
"size too big: %d bytes", total_bufsize)); "size too big: %d bytes", total_bufsize);
} }
} }
@ -579,7 +576,7 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
} }
else else
{ {
LLOGLN(10, ("libxrdp_send_bitmap: no compression")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_bitmap: no compression");
total_lines = height; total_lines = height;
i = 0; i = 0;
p = data; p = data;
@ -598,7 +595,7 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
if (lines_sending == 0) if (lines_sending == 0)
{ {
LLOGLN(0, ("libxrdp_send_bitmap: error, lines_sending == zero")); LOG(LOG_LEVEL_WARNING, "libxrdp_send_bitmap: error, lines_sending == zero");
break; break;
} }
@ -634,7 +631,7 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
q = q - server_line_bytes; q = q - server_line_bytes;
for (k = 0; k < width; k++) for (k = 0; k < width; k++)
{ {
pixel = *((tui16*)(q + k * 2)); pixel = *((tui16 *)(q + k * 2));
out_uint16_le(s, pixel); out_uint16_le(s, pixel);
} }
out_uint8s(s, e * 2); out_uint8s(s, e * 2);
@ -646,7 +643,7 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
q = q - server_line_bytes; q = q - server_line_bytes;
for (k = 0; k < width; k++) for (k = 0; k < width; k++)
{ {
pixel = *((tui32*)(q + k * 4)); pixel = *((tui32 *)(q + k * 4));
out_uint8(s, pixel); out_uint8(s, pixel);
out_uint8(s, pixel >> 8); out_uint8(s, pixel >> 8);
out_uint8(s, pixel >> 16); out_uint8(s, pixel >> 16);
@ -660,7 +657,7 @@ libxrdp_send_bitmap(struct xrdp_session *session, int width, int height,
q = q - server_line_bytes; q = q - server_line_bytes;
for (k = 0; k < width; k++) for (k = 0; k < width; k++)
{ {
pixel = *((int*)(q + k * 4)); pixel = *((int *)(q + k * 4));
out_uint32_le(s, pixel); out_uint32_le(s, pixel);
} }
out_uint8s(s, e * 4); out_uint8s(s, e * 4);
@ -693,7 +690,7 @@ libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
int j; int j;
int data_bytes; int data_bytes;
DEBUG(("libxrdp_send_pointer sending cursor")); LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_send_pointer sending cursor");
if (bpp == 0) if (bpp == 0)
{ {
bpp = 24; bpp = 24;
@ -703,14 +700,14 @@ libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
{ {
if (bpp != 24) if (bpp != 24)
{ {
g_writeln("libxrdp_send_pointer: error client does not support " LOG(LOG_LEVEL_ERROR, "libxrdp_send_pointer: error client does not support "
"new cursors and bpp is %d", bpp); "new cursors and bpp is %d", bpp);
return 1; return 1;
} }
} }
if ((bpp == 15) && (bpp != 16) && (bpp != 24) && (bpp != 32)) if ((bpp == 15) && (bpp != 16) && (bpp != 24) && (bpp != 32))
{ {
g_writeln("libxrdp_send_pointer: error"); LOG(LOG_LEVEL_ERROR, "libxrdp_send_pointer: error");
return 1; return 1;
} }
make_stream(s); make_stream(s);
@ -718,7 +715,7 @@ libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
if (session->client_info->use_fast_path & 1) /* fastpath output supported */ if (session->client_info->use_fast_path & 1) /* fastpath output supported */
{ {
LLOGLN(10, ("libxrdp_send_pointer: fastpath")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_pointer: fastpath");
if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0) if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0)
{ {
free_stream(s); free_stream(s);
@ -737,21 +734,21 @@ libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
} }
else /* slowpath */ else /* slowpath */
{ {
LLOGLN(10, ("libxrdp_send_pointer: slowpath")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_pointer: slowpath");
xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s); xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s);
if ((session->client_info->pointer_flags & 1) == 0) if ((session->client_info->pointer_flags & 1) == 0)
{ {
out_uint16_le(s, RDP_POINTER_COLOR); out_uint16_le(s, RDP_POINTER_COLOR);
out_uint16_le(s, 0); /* pad */ out_uint16_le(s, 0); /* pad */
data_bytes = 3072; data_bytes = 3072;
} }
else else
{ {
out_uint16_le(s, RDP_POINTER_POINTER); out_uint16_le(s, RDP_POINTER_POINTER);
out_uint16_le(s, 0); /* pad */ out_uint16_le(s, 0); /* pad */
out_uint16_le(s, bpp); out_uint16_le(s, bpp);
data_bytes = ((bpp + 7) / 8) * 32 * 32; data_bytes = ((bpp + 7) / 8) * 32 * 32;
} }
} }
@ -813,7 +810,7 @@ libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
if ((session->client_info->pointer_flags & 1) == 0) if ((session->client_info->pointer_flags & 1) == 0)
{ {
if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s, if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s,
FASTPATH_UPDATETYPE_COLOR) != 0) FASTPATH_UPDATETYPE_COLOR) != 0)
{ {
free_stream(s); free_stream(s);
return 1; return 1;
@ -822,7 +819,7 @@ libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
else else
{ {
if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s, if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s,
FASTPATH_UPDATETYPE_POINTER) != 0) FASTPATH_UPDATETYPE_POINTER) != 0)
{ {
free_stream(s); free_stream(s);
return 1; return 1;
@ -832,7 +829,7 @@ libxrdp_send_pointer(struct xrdp_session *session, int cache_idx,
else else
{ {
xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s, xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s,
RDP_DATA_PDU_POINTER); RDP_DATA_PDU_POINTER);
} }
free_stream(s); free_stream(s);
return 0; return 0;
@ -844,14 +841,14 @@ libxrdp_set_pointer(struct xrdp_session *session, int cache_idx)
{ {
struct stream *s; struct stream *s;
DEBUG(("libxrdp_set_pointer sending cursor index")); LOG_DEVEL(LOG_LEVEL_TRACE, "libxrdp_set_pointer sending cursor index");
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
if (session->client_info->use_fast_path & 1) /* fastpath output supported */ if (session->client_info->use_fast_path & 1) /* fastpath output supported */
{ {
LLOGLN(10, ("libxrdp_send_pointer: fastpath")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_pointer: fastpath");
if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0) if (xrdp_rdp_init_fastpath((struct xrdp_rdp *)session->rdp, s) != 0)
{ {
free_stream(s); free_stream(s);
@ -860,7 +857,7 @@ libxrdp_set_pointer(struct xrdp_session *session, int cache_idx)
} }
else else
{ {
LLOGLN(10, ("libxrdp_send_pointer: slowpath")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_pointer: slowpath");
xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s); xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s);
out_uint16_le(s, RDP_POINTER_CACHED); out_uint16_le(s, RDP_POINTER_CACHED);
out_uint16_le(s, 0); /* pad */ out_uint16_le(s, 0); /* pad */
@ -872,7 +869,7 @@ libxrdp_set_pointer(struct xrdp_session *session, int cache_idx)
if (session->client_info->use_fast_path & 1) /* fastpath output supported */ if (session->client_info->use_fast_path & 1) /* fastpath output supported */
{ {
if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s, if (xrdp_rdp_send_fastpath((struct xrdp_rdp *)session->rdp, s,
FASTPATH_UPDATETYPE_CACHED) != 0) FASTPATH_UPDATETYPE_CACHED) != 0)
{ {
free_stream(s); free_stream(s);
return 1; return 1;
@ -881,7 +878,7 @@ libxrdp_set_pointer(struct xrdp_session *session, int cache_idx)
else else
{ {
xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s, xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s,
RDP_DATA_PDU_POINTER); RDP_DATA_PDU_POINTER);
} }
free_stream(s); free_stream(s);
return 0; return 0;
@ -976,21 +973,21 @@ libxrdp_orders_mem_blt(struct xrdp_session *session, int cache_id,
/******************************************************************************/ /******************************************************************************/
int int
libxrdp_orders_composite_blt(struct xrdp_session* session, int srcidx, libxrdp_orders_composite_blt(struct xrdp_session *session, int srcidx,
int srcformat, int srcwidth, int srcrepeat, int srcformat, int srcwidth, int srcrepeat,
int* srctransform, int mskflags, int *srctransform, int mskflags,
int mskidx, int mskformat, int mskwidth, int mskidx, int mskformat, int mskwidth,
int mskrepeat, int op, int srcx, int srcy, int mskrepeat, int op, int srcx, int srcy,
int mskx, int msky, int dstx, int dsty, int mskx, int msky, int dstx, int dsty,
int width, int height, int dstformat, int width, int height, int dstformat,
struct xrdp_rect* rect) struct xrdp_rect *rect)
{ {
return xrdp_orders_composite_blt((struct xrdp_orders*)session->orders, return xrdp_orders_composite_blt((struct xrdp_orders *)session->orders,
srcidx, srcformat, srcwidth, srcrepeat, srcidx, srcformat, srcwidth, srcrepeat,
srctransform, mskflags, srctransform, mskflags,
mskidx, mskformat, mskwidth, mskrepeat, mskidx, mskformat, mskwidth, mskrepeat,
op, srcx, srcy, mskx, msky, dstx, dsty, op, srcx, srcy, mskx, msky, dstx, dsty,
width, height, dstformat, rect); width, height, dstformat, rect);
} }
/******************************************************************************/ /******************************************************************************/
@ -1072,9 +1069,9 @@ libxrdp_reset(struct xrdp_session *session,
/* if same (and only one monitor on client) don't need to do anything */ /* if same (and only one monitor on client) don't need to do anything */
if (client_info->width == width && if (client_info->width == width &&
client_info->height == height && client_info->height == height &&
client_info->bpp == bpp && client_info->bpp == bpp &&
(client_info->monitorCount == 0 || client_info->multimon == 0)) (client_info->monitorCount == 0 || client_info->multimon == 0))
{ {
return 0; return 0;
} }
@ -1171,7 +1168,7 @@ libxrdp_query_channel(struct xrdp_session *session, int index,
if (mcs->channel_list == NULL) if (mcs->channel_list == NULL)
{ {
g_writeln("libxrdp_query_channel - No channel initialized"); LOG(LOG_LEVEL_ERROR, "libxrdp_query_channel - No channel initialized");
return 1 ; return 1 ;
} }
@ -1179,7 +1176,7 @@ libxrdp_query_channel(struct xrdp_session *session, int index,
if (index < 0 || index >= count) if (index < 0 || index >= count)
{ {
DEBUG(("libxrdp_query_channel - Channel out of range %d", index)); LOG(LOG_LEVEL_ERROR, "libxrdp_query_channel - Channel out of range %d", index);
return 1; return 1;
} }
@ -1189,14 +1186,14 @@ libxrdp_query_channel(struct xrdp_session *session, int index,
if (channel_item == 0) if (channel_item == 0)
{ {
/* this should not happen */ /* this should not happen */
g_writeln("libxrdp_query_channel - channel item is 0"); LOG(LOG_LEVEL_ERROR, "libxrdp_query_channel - channel item is 0");
return 1; return 1;
} }
if (channel_name != 0) if (channel_name != 0)
{ {
g_strncpy(channel_name, channel_item->name, 8); g_strncpy(channel_name, channel_item->name, 8);
DEBUG(("libxrdp_query_channel - Channel %d name %s", index, channel_name)); LOG(LOG_LEVEL_ERROR, "libxrdp_query_channel - Channel %d name %s", index, channel_name);
} }
if (channel_flags != 0) if (channel_flags != 0)
@ -1224,7 +1221,7 @@ libxrdp_get_channel_id(struct xrdp_session *session, const char *name)
if (mcs->channel_list == NULL) if (mcs->channel_list == NULL)
{ {
g_writeln("libxrdp_get_channel_id No channel initialized"); LOG(LOG_LEVEL_ERROR, "libxrdp_get_channel_id No channel initialized");
return -1 ; return -1 ;
} }
@ -1276,7 +1273,7 @@ libxrdp_send_to_channel(struct xrdp_session *session, int channel_id,
if (xrdp_channel_send(chan, s, channel_id, total_data_len, flags) != 0) if (xrdp_channel_send(chan, s, channel_id, total_data_len, flags) != 0)
{ {
g_writeln("libxrdp_send_to_channel: error, server channel data NOT sent to client channel"); LOG(LOG_LEVEL_ERROR, "libxrdp_send_to_channel: error, server channel data NOT sent to client channel");
free_stream(s); free_stream(s);
return 1; return 1;
} }
@ -1498,7 +1495,7 @@ libxrdp_codec_jpeg_compress(struct xrdp_session *session,
char *out_data, int *io_len) char *out_data, int *io_len)
{ {
struct xrdp_orders *orders; struct xrdp_orders *orders;
void* jpeg_han; void *jpeg_han;
orders = (struct xrdp_orders *)(session->orders); orders = (struct xrdp_orders *)(session->orders);
jpeg_han = orders->jpeg_han; jpeg_han = orders->jpeg_han;
@ -1510,7 +1507,7 @@ libxrdp_codec_jpeg_compress(struct xrdp_session *session,
/*****************************************************************************/ /*****************************************************************************/
int EXPORT_CC int EXPORT_CC
libxrdp_fastpath_send_surface(struct xrdp_session *session, libxrdp_fastpath_send_surface(struct xrdp_session *session,
char* data_pad, int pad_bytes, char *data_pad, int pad_bytes,
int data_bytes, int data_bytes,
int destLeft, int destTop, int destLeft, int destTop,
int destRight, int destBottom, int bpp, int destRight, int destBottom, int bpp,
@ -1524,7 +1521,7 @@ libxrdp_fastpath_send_surface(struct xrdp_session *session,
int max_bytes; int max_bytes;
int cmd_bytes; int cmd_bytes;
LLOGLN(10, ("libxrdp_fastpath_send_surface:")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_fastpath_send_surface:");
if ((session->client_info->use_fast_path & 1) == 0) if ((session->client_info->use_fast_path & 1) == 0)
{ {
return 1; return 1;
@ -1583,7 +1580,7 @@ libxrdp_fastpath_send_frame_marker(struct xrdp_session *session,
struct stream *s; struct stream *s;
struct xrdp_rdp *rdp; struct xrdp_rdp *rdp;
LLOGLN(10, ("libxrdp_fastpath_send_frame_marker:")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_fastpath_send_frame_marker:");
if ((session->client_info->use_fast_path & 1) == 0) if ((session->client_info->use_fast_path & 1) == 0)
{ {
return 1; return 1;
@ -1617,7 +1614,7 @@ libxrdp_send_session_info(struct xrdp_session *session, const char *data,
{ {
struct xrdp_rdp *rdp; struct xrdp_rdp *rdp;
LLOGLN(10, ("libxrdp_send_session_info:")); LOG_DEVEL(LOG_LEVEL_DEBUG, "libxrdp_send_session_info:");
rdp = (struct xrdp_rdp *) (session->rdp); rdp = (struct xrdp_rdp *) (session->rdp);
return xrdp_rdp_send_session_info(rdp, data, data_bytes); return xrdp_rdp_send_session_info(rdp, data, data_bytes);
} }

1
libxrdp/libxrdp.h
View File

@ -29,6 +29,7 @@
#include "os_calls.h" #include "os_calls.h"
#include "ssl_calls.h" #include "ssl_calls.h"
#include "list.h" #include "list.h"
#include "log.h"
#include "file.h" #include "file.h"
#include "libxrdpinc.h" #include "libxrdpinc.h"
#include "xrdp_client_info.h" #include "xrdp_client_info.h"

46
libxrdp/xrdp_bitmap32_compress.c
View File

@ -33,11 +33,7 @@ http://msdn.microsoft.com/en-us/library/cc241877.aspx
#define FLAGS_RLE 0x10 #define FLAGS_RLE 0x10
#define FLAGS_NOALPHA 0x20 #define FLAGS_NOALPHA 0x20
#define LLOG_LEVEL 1
#define LLOGLN(_level, _args) \
do { if (_level < LLOG_LEVEL) { g_writeln _args ; } } while (0)
#define LHEXDUMP(_level, _args) \
do { if (_level < LLOG_LEVEL) { g_hexdump _args ; } } while (0)
/*****************************************************************************/ /*****************************************************************************/
/* split RGB */ /* split RGB */
@ -85,9 +81,9 @@ fsplit3(char *in_data, int start_line, int width, int e,
rp |= (pixel << 8) & 0xff000000; rp |= (pixel << 8) & 0xff000000;
gp |= (pixel << 16) & 0xff000000; gp |= (pixel << 16) & 0xff000000;
bp |= (pixel << 24) & 0xff000000; bp |= (pixel << 24) & 0xff000000;
*((int*)(r_data + out_index)) = rp; *((int *)(r_data + out_index)) = rp;
*((int*)(g_data + out_index)) = gp; *((int *)(g_data + out_index)) = gp;
*((int*)(b_data + out_index)) = bp; *((int *)(b_data + out_index)) = bp;
out_index += 4; out_index += 4;
index += 4; index += 4;
} }
@ -170,10 +166,10 @@ fsplit4(char *in_data, int start_line, int width, int e,
rp |= (pixel << 8) & 0xff000000; rp |= (pixel << 8) & 0xff000000;
gp |= (pixel << 16) & 0xff000000; gp |= (pixel << 16) & 0xff000000;
bp |= (pixel << 24) & 0xff000000; bp |= (pixel << 24) & 0xff000000;
*((int*)(a_data + out_index)) = ap; *((int *)(a_data + out_index)) = ap;
*((int*)(r_data + out_index)) = rp; *((int *)(r_data + out_index)) = rp;
*((int*)(g_data + out_index)) = gp; *((int *)(g_data + out_index)) = gp;
*((int*)(b_data + out_index)) = bp; *((int *)(b_data + out_index)) = bp;
out_index += 4; out_index += 4;
index += 4; index += 4;
} }
@ -209,13 +205,13 @@ fsplit4(char *in_data, int start_line, int width, int e,
/*****************************************************************************/ /*****************************************************************************/
#define DELTA_ONE \ #define DELTA_ONE \
do { \ do { \
delta = src8[cx] - src8[0]; \ delta = src8[cx] - src8[0]; \
is_neg = (delta >> 7) & 1; \ is_neg = (delta >> 7) & 1; \
dst8[cx] = (((delta ^ -is_neg) + is_neg) << 1) - is_neg; \ dst8[cx] = (((delta ^ -is_neg) + is_neg) << 1) - is_neg; \
src8++; \ src8++; \
dst8++; \ dst8++; \
} while (0) } while (0)
/*****************************************************************************/ /*****************************************************************************/
static int static int
@ -258,7 +254,7 @@ fout(int collen, int replen, char *colptr, struct stream *s)
int lreplen; int lreplen;
int cont; int cont;
LLOGLN(10, ("fout: collen %d replen %d", collen, replen)); LOG_DEVEL(LOG_LEVEL_DEBUG, "fout: collen %d replen %d", collen, replen);
cont = collen > 13; cont = collen > 13;
while (cont) while (cont)
{ {
@ -285,7 +281,7 @@ fout(int collen, int replen, char *colptr, struct stream *s)
{ {
lreplen = 47; lreplen = 47;
} }
LLOGLN(10, ("fout: big run lreplen %d", lreplen)); LOG_DEVEL(LOG_LEVEL_DEBUG, "fout: big run lreplen %d", lreplen);
replen -= lreplen; replen -= lreplen;
code = ((lreplen & 0xF) << 4) | ((lreplen & 0xF0) >> 4); code = ((lreplen & 0xF) << 4) | ((lreplen & 0xF0) >> 4);
out_uint8(s, code); out_uint8(s, code);
@ -326,13 +322,13 @@ fpack(char *plane, int cx, int cy, struct stream *s)
int collen; int collen;
int replen; int replen;
LLOGLN(10, ("fpack:")); LOG_DEVEL(LOG_LEVEL_DEBUG, "fpack:");
holdp = s->p; holdp = s->p;
for (jndex = 0; jndex < cy; jndex++) for (jndex = 0; jndex < cy; jndex++)
{ {
LLOGLN(10, ("line start line %d cx %d cy %d", jndex, cx, cy)); LOG_DEVEL(LOG_LEVEL_DEBUG, "line start line %d cx %d cy %d", jndex, cx, cy);
ptr8 = plane + jndex * cx; ptr8 = plane + jndex * cx;
LHEXDUMP(10, (ptr8, cx)); LOG_DEVEL_HEXDUMP(LOG_LEVEL_TRACE, "line content", ptr8, cx);
lend = ptr8 + (cx - 1); lend = ptr8 + (cx - 1);
colptr = ptr8; colptr = ptr8;
if (colptr[0] == 0) if (colptr[0] == 0)
@ -437,7 +433,7 @@ xrdp_bitmap32_compress(char *in_data, int width, int height,
int total_bytes; int total_bytes;
int header; int header;
LLOGLN(10, ("xrdp_bitmap32_compress:")); LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_bitmap32_compress:");
max_bytes = 4 * 1024; max_bytes = 4 * 1024;
/* need max 8, 4K planes for work */ /* need max 8, 4K planes for work */
if (max_bytes * 8 > temp_s->size) if (max_bytes * 8 > temp_s->size)

245
libxrdp/xrdp_caps.c
View File

@ -77,7 +77,7 @@ xrdp_caps_process_general(struct xrdp_rdp *self, struct stream *s,
if (len < 10 + 2) if (len < 10 + 2)
{ {
g_writeln("xrdp_caps_process_general: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_general: error");
return 1; return 1;
} }
@ -112,10 +112,10 @@ xrdp_caps_process_order(struct xrdp_rdp *self, struct stream *s,
int ex_flags; int ex_flags;
int cap_flags; int cap_flags;
DEBUG(("order capabilities")); LOG_DEVEL(LOG_LEVEL_TRACE, "order capabilities");
if (len < 20 + 2 + 2 + 2 + 2 + 2 + 2 + 32 + 2 + 2 + 4 + 4 + 4 + 4) if (len < 20 + 2 + 2 + 2 + 2 + 2 + 2 + 32 + 2 + 2 + 4 + 4 + 4 + 4)
{ {
g_writeln("xrdp_caps_process_order: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_order: error");
return 1; return 1;
} }
in_uint8s(s, 20); /* Terminal desc, pad */ in_uint8s(s, 20); /* Terminal desc, pad */
@ -127,25 +127,23 @@ xrdp_caps_process_order(struct xrdp_rdp *self, struct stream *s,
in_uint16_le(s, cap_flags); /* Capability flags */ in_uint16_le(s, cap_flags); /* Capability flags */
in_uint8a(s, order_caps, 32); /* Orders supported */ in_uint8a(s, order_caps, 32); /* Orders supported */
g_memcpy(self->client_info.orders, order_caps, 32); g_memcpy(self->client_info.orders, order_caps, 32);
DEBUG(("dest blt-0 %d", order_caps[0])); LOG_DEVEL(LOG_LEVEL_TRACE, "dest blt-0 %d", order_caps[0]);
DEBUG(("pat blt-1 %d", order_caps[1])); LOG_DEVEL(LOG_LEVEL_TRACE, "pat blt-1 %d", order_caps[1]);
DEBUG(("screen blt-2 %d", order_caps[2])); LOG_DEVEL(LOG_LEVEL_TRACE, "screen blt-2 %d", order_caps[2]);
DEBUG(("memblt-3-13 %d %d", order_caps[3], order_caps[13])); LOG_DEVEL(LOG_LEVEL_TRACE, "memblt-3-13 %d %d", order_caps[3], order_caps[13]);
DEBUG(("triblt-4-14 %d %d", order_caps[4], order_caps[14])); LOG_DEVEL(LOG_LEVEL_TRACE, "triblt-4-14 %d %d", order_caps[4], order_caps[14]);
DEBUG(("line-8 %d", order_caps[8])); LOG_DEVEL(LOG_LEVEL_TRACE, "line-8 %d", order_caps[8]);
DEBUG(("line-9 %d", order_caps[9])); LOG_DEVEL(LOG_LEVEL_TRACE, "line-9 %d", order_caps[9]);
DEBUG(("rect-10 %d", order_caps[10])); LOG_DEVEL(LOG_LEVEL_TRACE, "rect-10 %d", order_caps[10]);
DEBUG(("desksave-11 %d", order_caps[11])); LOG_DEVEL(LOG_LEVEL_TRACE, "desksave-11 %d", order_caps[11]);
DEBUG(("polygon-20 %d", order_caps[20])); LOG_DEVEL(LOG_LEVEL_TRACE, "polygon-20 %d", order_caps[20]);
DEBUG(("polygon2-21 %d", order_caps[21])); LOG_DEVEL(LOG_LEVEL_TRACE, "polygon2-21 %d", order_caps[21]);
DEBUG(("polyline-22 %d", order_caps[22])); LOG_DEVEL(LOG_LEVEL_TRACE, "polyline-22 %d", order_caps[22]);
DEBUG(("ellipse-25 %d", order_caps[25])); LOG_DEVEL(LOG_LEVEL_TRACE, "ellipse-25 %d", order_caps[25]);
DEBUG(("ellipse2-26 %d", order_caps[26])); LOG_DEVEL(LOG_LEVEL_TRACE, "ellipse2-26 %d", order_caps[26]);
DEBUG(("text2-27 %d", order_caps[27])); LOG_DEVEL(LOG_LEVEL_TRACE, "text2-27 %d", order_caps[27]);
DEBUG(("order_caps dump")); LOG_DEVEL_HEXDUMP(LOG_LEVEL_TRACE, "order_caps dump", order_caps, 32);
#if defined(XRDP_DEBUG)
g_hexdump(order_caps, 32);
#endif
in_uint8s(s, 2); /* Text capability flags */ in_uint8s(s, 2); /* Text capability flags */
/* read extended order support flags */ /* read extended order support flags */
in_uint16_le(s, ex_flags); /* Ex flags */ in_uint16_le(s, ex_flags); /* Ex flags */
@ -155,7 +153,7 @@ xrdp_caps_process_order(struct xrdp_rdp *self, struct stream *s,
self->client_info.order_flags_ex = ex_flags; self->client_info.order_flags_ex = ex_flags;
if (ex_flags & XR_ORDERFLAGS_EX_CACHE_BITMAP_REV3_SUPPORT) if (ex_flags & XR_ORDERFLAGS_EX_CACHE_BITMAP_REV3_SUPPORT)
{ {
g_writeln("xrdp_caps_process_order: bitmap cache v3 supported"); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_caps_process_order: bitmap cache v3 supported");
self->client_info.bitmap_cache_version |= 4; self->client_info.bitmap_cache_version |= 4;
} }
} }
@ -163,15 +161,15 @@ xrdp_caps_process_order(struct xrdp_rdp *self, struct stream *s,
in_uint32_le(s, i); /* desktop cache size, usually 0x38400 */ in_uint32_le(s, i); /* desktop cache size, usually 0x38400 */
self->client_info.desktop_cache = i; self->client_info.desktop_cache = i;
DEBUG(("desktop cache size %d", i)); LOG_DEVEL(LOG_LEVEL_TRACE, "desktop cache size %d", i);
in_uint8s(s, 4); /* Unknown */ in_uint8s(s, 4); /* Unknown */
in_uint8s(s, 4); /* Unknown */ in_uint8s(s, 4); /* Unknown */
/* check if libpainter should be used for drawing, instead of orders */ /* check if libpainter should be used for drawing, instead of orders */
if (!(order_caps[TS_NEG_DSTBLT_INDEX] && order_caps[TS_NEG_PATBLT_INDEX] && if (!(order_caps[TS_NEG_DSTBLT_INDEX] && order_caps[TS_NEG_PATBLT_INDEX] &&
order_caps[TS_NEG_SCRBLT_INDEX] && order_caps[TS_NEG_MEMBLT_INDEX])) order_caps[TS_NEG_SCRBLT_INDEX] && order_caps[TS_NEG_MEMBLT_INDEX]))
{ {
g_writeln("xrdp_caps_process_order: not enough orders supported by client, using painter."); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_caps_process_order: not enough orders supported by client, using painter.");
self->client_info.no_orders_supported = 1; self->client_info.no_orders_supported = 1;
} }
@ -188,7 +186,7 @@ xrdp_caps_process_bmpcache(struct xrdp_rdp *self, struct stream *s,
if (len < 24 + 2 + 2 + 2 + 2 + 2 + 2) if (len < 24 + 2 + 2 + 2 + 2 + 2 + 2)
{ {
g_writeln("xrdp_caps_process_bmpcache: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_bmpcache: error");
return 1; return 1;
} }
self->client_info.bitmap_cache_version |= 1; self->client_info.bitmap_cache_version |= 1;
@ -211,12 +209,12 @@ xrdp_caps_process_bmpcache(struct xrdp_rdp *self, struct stream *s,
i = MAX(i, 0); i = MAX(i, 0);
self->client_info.cache3_entries = i; self->client_info.cache3_entries = i;
in_uint16_le(s, self->client_info.cache3_size); in_uint16_le(s, self->client_info.cache3_size);
DEBUG(("cache1 entries %d size %d", self->client_info.cache1_entries, LOG_DEVEL(LOG_LEVEL_TRACE, "cache1 entries %d size %d", self->client_info.cache1_entries,
self->client_info.cache1_size)); self->client_info.cache1_size);
DEBUG(("cache2 entries %d size %d", self->client_info.cache2_entries, LOG_DEVEL(LOG_LEVEL_TRACE, "cache2 entries %d size %d", self->client_info.cache2_entries,
self->client_info.cache2_size)); self->client_info.cache2_size);
DEBUG(("cache3 entries %d size %d", self->client_info.cache3_entries, LOG_DEVEL(LOG_LEVEL_TRACE, "cache3 entries %d size %d", self->client_info.cache3_entries,
self->client_info.cache3_size)); self->client_info.cache3_size);
return 0; return 0;
} }
@ -231,7 +229,7 @@ xrdp_caps_process_bmpcache2(struct xrdp_rdp *self, struct stream *s,
if (len < 2 + 2 + 4 + 4 + 4) if (len < 2 + 2 + 4 + 4 + 4)
{ {
g_writeln("xrdp_caps_process_bmpcache2: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_bmpcache2: error");
return 1; return 1;
} }
self->client_info.bitmap_cache_version |= 2; self->client_info.bitmap_cache_version |= 2;
@ -255,12 +253,12 @@ xrdp_caps_process_bmpcache2(struct xrdp_rdp *self, struct stream *s,
i = MAX(i, 0); i = MAX(i, 0);
self->client_info.cache3_entries = i; self->client_info.cache3_entries = i;
self->client_info.cache3_size = 4096 * Bpp; self->client_info.cache3_size = 4096 * Bpp;
DEBUG(("cache1 entries %d size %d", self->client_info.cache1_entries, LOG_DEVEL(LOG_LEVEL_TRACE, "cache1 entries %d size %d", self->client_info.cache1_entries,
self->client_info.cache1_size)); self->client_info.cache1_size);
DEBUG(("cache2 entries %d size %d", self->client_info.cache2_entries, LOG_DEVEL(LOG_LEVEL_TRACE, "cache2 entries %d size %d", self->client_info.cache2_entries,
self->client_info.cache2_size)); self->client_info.cache2_size);
DEBUG(("cache3 entries %d size %d", self->client_info.cache3_entries, LOG_DEVEL(LOG_LEVEL_TRACE, "cache3 entries %d size %d", self->client_info.cache3_entries,
self->client_info.cache3_size)); self->client_info.cache3_size);
return 0; return 0;
} }
@ -273,11 +271,11 @@ xrdp_caps_process_cache_v3_codec_id(struct xrdp_rdp *self, struct stream *s,
if (len < 1) if (len < 1)
{ {
g_writeln("xrdp_caps_process_cache_v3_codec_id: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_cache_v3_codec_id: error");
return 1; return 1;
} }
in_uint8(s, codec_id); in_uint8(s, codec_id);
g_writeln("xrdp_caps_process_cache_v3_codec_id: cache_v3_codec_id %d", LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_caps_process_cache_v3_codec_id: cache_v3_codec_id %d",
codec_id); codec_id);
self->client_info.v3_codec_id = codec_id; self->client_info.v3_codec_id = codec_id;
return 0; return 0;
@ -295,7 +293,7 @@ xrdp_caps_process_pointer(struct xrdp_rdp *self, struct stream *s,
if (len < 2 + 2 + 2) if (len < 2 + 2 + 2)
{ {
g_writeln("xrdp_caps_process_pointer: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_pointer: error");
return 1; return 1;
} }
no_new_cursor = self->client_info.pointer_flags & 2; no_new_cursor = self->client_info.pointer_flags & 2;
@ -306,21 +304,21 @@ xrdp_caps_process_pointer(struct xrdp_rdp *self, struct stream *s,
self->client_info.pointer_cache_entries = i; self->client_info.pointer_cache_entries = i;
if (colorPointerFlag & 1) if (colorPointerFlag & 1)
{ {
g_writeln("xrdp_caps_process_pointer: client supports " LOG(LOG_LEVEL_INFO, "xrdp_caps_process_pointer: client supports "
"new(color) cursor"); "new(color) cursor");
in_uint16_le(s, i); in_uint16_le(s, i);
i = MIN(i, 32); i = MIN(i, 32);
self->client_info.pointer_cache_entries = i; self->client_info.pointer_cache_entries = i;
} }
else else
{ {
g_writeln("xrdp_caps_process_pointer: client does not support " LOG(LOG_LEVEL_INFO, "xrdp_caps_process_pointer: client does not support "
"new(color) cursor"); "new(color) cursor");
} }
if (no_new_cursor) if (no_new_cursor)
{ {
g_writeln("xrdp_caps_process_pointer: new(color) cursor is " LOG(LOG_LEVEL_INFO, "xrdp_caps_process_pointer: new(color) cursor is "
"disabled by config"); "disabled by config");
self->client_info.pointer_flags = 0; self->client_info.pointer_flags = 0;
} }
return 0; return 0;
@ -354,7 +352,7 @@ xrdp_caps_process_brushcache(struct xrdp_rdp *self, struct stream *s,
if (len < 4) if (len < 4)
{ {
g_writeln("xrdp_caps_process_brushcache: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_brushcache: error");
return 1; return 1;
} }
in_uint32_le(s, code); in_uint32_le(s, code);
@ -371,7 +369,7 @@ xrdp_caps_process_glyphcache(struct xrdp_rdp *self, struct stream *s,
if (len < 40 + 4 + 2 + 2) /* MS-RDPBCGR 2.2.7.1.8 */ if (len < 40 + 4 + 2 + 2) /* MS-RDPBCGR 2.2.7.1.8 */
{ {
g_writeln("xrdp_caps_process_glyphcache: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_glyphcache: error");
return 1; return 1;
} }
@ -384,7 +382,7 @@ xrdp_caps_process_glyphcache(struct xrdp_rdp *self, struct stream *s,
{ {
self->client_info.use_cache_glyph_v2 = 1; self->client_info.use_cache_glyph_v2 = 1;
} }
g_writeln("xrdp_caps_process_glyphcache: support level %d ", LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_caps_process_glyphcache: support level %d ",
glyph_support_level); glyph_support_level);
return 0; return 0;
} }
@ -398,7 +396,7 @@ xrdp_caps_process_offscreen_bmpcache(struct xrdp_rdp *self, struct stream *s,
if (len < 4 + 2 + 2) if (len < 4 + 2 + 2)
{ {
g_writeln("xrdp_caps_process_offscreen_bmpcache: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_offscreen_bmpcache: error");
return 1; return 1;
} }
in_uint32_le(s, i32); in_uint32_le(s, i32);
@ -407,11 +405,11 @@ xrdp_caps_process_offscreen_bmpcache(struct xrdp_rdp *self, struct stream *s,
self->client_info.offscreen_cache_size = i32 * 1024; self->client_info.offscreen_cache_size = i32 * 1024;
in_uint16_le(s, i32); in_uint16_le(s, i32);
self->client_info.offscreen_cache_entries = i32; self->client_info.offscreen_cache_entries = i32;
g_writeln("xrdp_process_offscreen_bmpcache: support level %d " LOG(LOG_LEVEL_INFO, "xrdp_process_offscreen_bmpcache: support level %d "
"cache size %d MB cache entries %d", "cache size %d MB cache entries %d",
self->client_info.offscreen_support_level, self->client_info.offscreen_support_level,
self->client_info.offscreen_cache_size, self->client_info.offscreen_cache_size,
self->client_info.offscreen_cache_entries); self->client_info.offscreen_cache_entries);
return 0; return 0;
} }
@ -423,13 +421,13 @@ xrdp_caps_process_rail(struct xrdp_rdp *self, struct stream *s, int len)
if (len < 4) if (len < 4)
{ {
g_writeln("xrdp_caps_process_rail: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_rail: error");
return 1; return 1;
} }
in_uint32_le(s, i32); in_uint32_le(s, i32);
self->client_info.rail_support_level = i32; self->client_info.rail_support_level = i32;
g_writeln("xrdp_process_capset_rail: rail_support_level %d", LOG(LOG_LEVEL_INFO, "xrdp_process_capset_rail: rail_support_level %d",
self->client_info.rail_support_level); self->client_info.rail_support_level);
return 0; return 0;
} }
@ -441,7 +439,7 @@ xrdp_caps_process_window(struct xrdp_rdp *self, struct stream *s, int len)
if (len < 4 + 1 + 2) if (len < 4 + 1 + 2)
{ {
g_writeln("xrdp_caps_process_window: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_window: error");
return 1; return 1;
} }
in_uint32_le(s, i32); in_uint32_le(s, i32);
@ -450,11 +448,11 @@ xrdp_caps_process_window(struct xrdp_rdp *self, struct stream *s, int len)
self->client_info.wnd_num_icon_caches = i32; self->client_info.wnd_num_icon_caches = i32;
in_uint16_le(s, i32); in_uint16_le(s, i32);
self->client_info.wnd_num_icon_cache_entries = i32; self->client_info.wnd_num_icon_cache_entries = i32;
g_writeln("xrdp_process_capset_window wnd_support_level %d " LOG(LOG_LEVEL_INFO, "xrdp_process_capset_window wnd_support_level %d "
"wnd_num_icon_caches %d wnd_num_icon_cache_entries %d", "wnd_num_icon_caches %d wnd_num_icon_cache_entries %d",
self->client_info.wnd_support_level, self->client_info.wnd_support_level,
self->client_info.wnd_num_icon_caches, self->client_info.wnd_num_icon_caches,
self->client_info.wnd_num_icon_cache_entries); self->client_info.wnd_num_icon_cache_entries);
return 0; return 0;
} }
@ -472,7 +470,7 @@ xrdp_caps_process_codecs(struct xrdp_rdp *self, struct stream *s, int len)
if (len < 1) if (len < 1)
{ {
g_writeln("xrdp_caps_process_codecs: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_codecs: error");
return 1; return 1;
} }
in_uint8(s, codec_count); in_uint8(s, codec_count);
@ -483,7 +481,7 @@ xrdp_caps_process_codecs(struct xrdp_rdp *self, struct stream *s, int len)
codec_guid = s->p; codec_guid = s->p;
if (len < 16 + 1 + 2) if (len < 16 + 1 + 2)
{ {
g_writeln("xrdp_caps_process_codecs: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_codecs: error");
return 1; return 1;
} }
in_uint8s(s, 16); in_uint8s(s, 16);
@ -492,7 +490,7 @@ xrdp_caps_process_codecs(struct xrdp_rdp *self, struct stream *s, int len)
len -= 16 + 1 + 2; len -= 16 + 1 + 2;
if (len < codec_properties_length) if (len < codec_properties_length)
{ {
g_writeln("xrdp_caps_process_codecs: error"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_codecs: error");
return 1; return 1;
} }
len -= codec_properties_length; len -= codec_properties_length;
@ -500,8 +498,8 @@ xrdp_caps_process_codecs(struct xrdp_rdp *self, struct stream *s, int len)
if (g_memcmp(codec_guid, XR_CODEC_GUID_NSCODEC, 16) == 0) if (g_memcmp(codec_guid, XR_CODEC_GUID_NSCODEC, 16) == 0)
{ {
g_writeln("xrdp_caps_process_codecs: nscodec, codec id %d, properties len %d", LOG(LOG_LEVEL_INFO, "xrdp_caps_process_codecs: nscodec, codec id %d, properties len %d",
codec_id, codec_properties_length); codec_id, codec_properties_length);
self->client_info.ns_codec_id = codec_id; self->client_info.ns_codec_id = codec_id;
i1 = MIN(64, codec_properties_length); i1 = MIN(64, codec_properties_length);
g_memcpy(self->client_info.ns_prop, s->p, i1); g_memcpy(self->client_info.ns_prop, s->p, i1);
@ -509,8 +507,8 @@ xrdp_caps_process_codecs(struct xrdp_rdp *self, struct stream *s, int len)
} }
else if (g_memcmp(codec_guid, XR_CODEC_GUID_REMOTEFX, 16) == 0) else if (g_memcmp(codec_guid, XR_CODEC_GUID_REMOTEFX, 16) == 0)
{ {
g_writeln("xrdp_caps_process_codecs: RemoteFX, codec id %d, properties len %d", LOG(LOG_LEVEL_INFO, "xrdp_caps_process_codecs: RemoteFX, codec id %d, properties len %d",
codec_id, codec_properties_length); codec_id, codec_properties_length);
self->client_info.rfx_codec_id = codec_id; self->client_info.rfx_codec_id = codec_id;
i1 = MIN(64, codec_properties_length); i1 = MIN(64, codec_properties_length);
g_memcpy(self->client_info.rfx_prop, s->p, i1); g_memcpy(self->client_info.rfx_prop, s->p, i1);
@ -518,8 +516,8 @@ xrdp_caps_process_codecs(struct xrdp_rdp *self, struct stream *s, int len)
} }
else if (g_memcmp(codec_guid, XR_CODEC_GUID_JPEG, 16) == 0) else if (g_memcmp(codec_guid, XR_CODEC_GUID_JPEG, 16) == 0)
{ {
g_writeln("xrdp_caps_process_codecs: jpeg, codec id %d, properties len %d", LOG(LOG_LEVEL_INFO, "xrdp_caps_process_codecs: jpeg, codec id %d, properties len %d",
codec_id, codec_properties_length); codec_id, codec_properties_length);
self->client_info.jpeg_codec_id = codec_id; self->client_info.jpeg_codec_id = codec_id;
i1 = MIN(64, codec_properties_length); i1 = MIN(64, codec_properties_length);
g_memcpy(self->client_info.jpeg_prop, s->p, i1); g_memcpy(self->client_info.jpeg_prop, s->p, i1);
@ -527,16 +525,16 @@ xrdp_caps_process_codecs(struct xrdp_rdp *self, struct stream *s, int len)
/* make sure that requested quality is between 0 to 100 */ /* make sure that requested quality is between 0 to 100 */
if (self->client_info.jpeg_prop[0] < 0 || self->client_info.jpeg_prop[0] > 100) if (self->client_info.jpeg_prop[0] < 0 || self->client_info.jpeg_prop[0] > 100)
{ {
g_writeln(" Warning: the requested jpeg quality (%d) is invalid," LOG(LOG_LEVEL_WARNING, " Warning: the requested jpeg quality (%d) is invalid, "
" falling back to default", self->client_info.jpeg_prop[0]); "falling back to default", self->client_info.jpeg_prop[0]);
self->client_info.jpeg_prop[0] = 75; /* use default */ self->client_info.jpeg_prop[0] = 75; /* use default */
} }
g_writeln(" jpeg quality set to %d", self->client_info.jpeg_prop[0]); LOG(LOG_LEVEL_INFO, " jpeg quality set to %d", self->client_info.jpeg_prop[0]);
} }
else if (g_memcmp(codec_guid, XR_CODEC_GUID_H264, 16) == 0) else if (g_memcmp(codec_guid, XR_CODEC_GUID_H264, 16) == 0)
{ {
g_writeln("xrdp_caps_process_codecs: h264, codec id %d, properties len %d", LOG(LOG_LEVEL_INFO, "xrdp_caps_process_codecs: h264, codec id %d, properties len %d",
codec_id, codec_properties_length); codec_id, codec_properties_length);
self->client_info.h264_codec_id = codec_id; self->client_info.h264_codec_id = codec_id;
i1 = MIN(64, codec_properties_length); i1 = MIN(64, codec_properties_length);
g_memcpy(self->client_info.h264_prop, s->p, i1); g_memcpy(self->client_info.h264_prop, s->p, i1);
@ -544,7 +542,7 @@ xrdp_caps_process_codecs(struct xrdp_rdp *self, struct stream *s, int len)
} }
else else
{ {
g_writeln("xrdp_caps_process_codecs: unknown codec id %d", codec_id); LOG(LOG_LEVEL_WARNING, "xrdp_caps_process_codecs: unknown codec id %d", codec_id);
} }
s->p = next_guid; s->p = next_guid;
@ -568,20 +566,20 @@ xrdp_caps_process_multifragmentupdate(struct xrdp_rdp *self, struct stream *s,
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
static int static int
xrdp_caps_process_frame_ack(struct xrdp_rdp *self, struct stream *s, int len) xrdp_caps_process_frame_ack(struct xrdp_rdp *self, struct stream *s, int len)
{ {
g_writeln("xrdp_caps_process_frame_ack:"); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_caps_process_frame_ack:");
self->client_info.use_frame_acks = 1; self->client_info.use_frame_acks = 1;
in_uint32_le(s, self->client_info.max_unacknowledged_frame_count); in_uint32_le(s, self->client_info.max_unacknowledged_frame_count);
if (self->client_info.max_unacknowledged_frame_count < 0) if (self->client_info.max_unacknowledged_frame_count < 0)
{ {
g_writeln(" invalid max_unacknowledged_frame_count value (%d), setting to 0", LOG(LOG_LEVEL_WARNING, " invalid max_unacknowledged_frame_count value (%d), setting to 0",
self->client_info.max_unacknowledged_frame_count); self->client_info.max_unacknowledged_frame_count);
self->client_info.max_unacknowledged_frame_count = 0; self->client_info.max_unacknowledged_frame_count = 0;
} }
g_writeln(" max_unacknowledged_frame_count %d", self->client_info.max_unacknowledged_frame_count); LOG_DEVEL(LOG_LEVEL_TRACE, " max_unacknowledged_frame_count %d", self->client_info.max_unacknowledged_frame_count);
return 0; return 0;
} }
@ -590,10 +588,15 @@ static int
xrdp_caps_process_surface_cmds(struct xrdp_rdp *self, struct stream *s, int len) xrdp_caps_process_surface_cmds(struct xrdp_rdp *self, struct stream *s, int len)
{ {
int cmdFlags; int cmdFlags;
g_writeln("xrdp_caps_process_surface_cmds:"); #ifndef XRDP_DEBUG
/* TODO: remove UNUSED_VAR once the `cmdFlags` variable is used for more than
logging in debug mode */
UNUSED_VAR(cmdFlags);
#endif
LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_caps_process_surface_cmds:");
in_uint32_le(s, cmdFlags); in_uint32_le(s, cmdFlags);
in_uint8s(s, 4); /* reserved */ in_uint8s(s, 4); /* reserved */
g_writeln(" cmdFlags 0x%08x", cmdFlags); LOG_DEVEL(LOG_LEVEL_TRACE, " cmdFlags 0x%08x", cmdFlags);
return 0; return 0;
} }
@ -609,7 +612,7 @@ xrdp_caps_process_confirm_active(struct xrdp_rdp *self, struct stream *s)
int len; int len;
char *p; char *p;
DEBUG(("in xrdp_caps_process_confirm_active")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_caps_process_confirm_active");
in_uint8s(s, 4); /* rdp_shareid */ in_uint8s(s, 4); /* rdp_shareid */
in_uint8s(s, 2); /* userid */ in_uint8s(s, 2); /* userid */
in_uint16_le(s, source_len); /* sizeof RDP_SOURCE */ in_uint16_le(s, source_len); /* sizeof RDP_SOURCE */
@ -628,86 +631,86 @@ xrdp_caps_process_confirm_active(struct xrdp_rdp *self, struct stream *s)
p = s->p; p = s->p;
if (!s_check_rem(s, 4)) if (!s_check_rem(s, 4))
{ {
g_writeln("xrdp_caps_process_confirm_active: error 1"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_confirm_active: error 1");
return 1; return 1;
} }
in_uint16_le(s, type); in_uint16_le(s, type);
in_uint16_le(s, len); in_uint16_le(s, len);
if ((len < 4) || !s_check_rem(s, len - 4)) if ((len < 4) || !s_check_rem(s, len - 4))
{ {
g_writeln("xrdp_caps_process_confirm_active: error: len %d, " LOG(LOG_LEVEL_ERROR, "xrdp_caps_process_confirm_active: error: len %d, "
"remaining %d", len, (int) (s->end - s->p)); "remaining %d", len, (int) (s->end - s->p));
return 1; return 1;
} }
len -= 4; len -= 4;
switch (type) switch (type)
{ {
case CAPSTYPE_GENERAL: case CAPSTYPE_GENERAL:
DEBUG(("CAPSTYPE_GENERAL")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_GENERAL");
xrdp_caps_process_general(self, s, len); xrdp_caps_process_general(self, s, len);
break; break;
case CAPSTYPE_BITMAP: case CAPSTYPE_BITMAP:
DEBUG(("CAPSTYPE_BITMAP")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_BITMAP");
break; break;
case CAPSTYPE_ORDER: case CAPSTYPE_ORDER:
DEBUG(("CAPSTYPE_ORDER")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_ORDER");
xrdp_caps_process_order(self, s, len); xrdp_caps_process_order(self, s, len);
break; break;
case CAPSTYPE_BITMAPCACHE: case CAPSTYPE_BITMAPCACHE:
DEBUG(("CAPSTYPE_BMPCACHE")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_BMPCACHE");
xrdp_caps_process_bmpcache(self, s, len); xrdp_caps_process_bmpcache(self, s, len);
break; break;
case CAPSTYPE_CONTROL: case CAPSTYPE_CONTROL:
DEBUG(("CAPSTYPE_CONTROL")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_CONTROL");
break; break;
case 6: case 6:
xrdp_caps_process_cache_v3_codec_id(self, s, len); xrdp_caps_process_cache_v3_codec_id(self, s, len);
break; break;
case CAPSTYPE_ACTIVATION: case CAPSTYPE_ACTIVATION:
DEBUG(("CAPSTYPE_ACTIVAION")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_ACTIVAION");
break; break;
case CAPSTYPE_POINTER: case CAPSTYPE_POINTER:
DEBUG(("CAPSTYPE_POINTER")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_POINTER");
xrdp_caps_process_pointer(self, s, len); xrdp_caps_process_pointer(self, s, len);
break; break;
case CAPSTYPE_SHARE: case CAPSTYPE_SHARE:
DEBUG(("CAPSTYPE_SHARE")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_SHARE");
break; break;
case CAPSTYPE_COLORCACHE: case CAPSTYPE_COLORCACHE:
DEBUG(("CAPSTYPE_COLORCACHE")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_COLORCACHE");
break; break;
case CAPSTYPE_SOUND: case CAPSTYPE_SOUND:
DEBUG(("CAPSTYPE_SOUND")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_SOUND");
break; break;
case CAPSTYPE_INPUT: case CAPSTYPE_INPUT:
xrdp_caps_process_input(self, s, len); xrdp_caps_process_input(self, s, len);
break; break;
case CAPSTYPE_FONT: case CAPSTYPE_FONT:
DEBUG(("CAPSTYPE_FONT")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_FONT");
break; break;
case CAPSTYPE_BRUSH: case CAPSTYPE_BRUSH:
xrdp_caps_process_brushcache(self, s, len); xrdp_caps_process_brushcache(self, s, len);
break; break;
case CAPSTYPE_GLYPHCACHE: case CAPSTYPE_GLYPHCACHE:
DEBUG(("CAPSTYPE_GLYPHCACHE")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_GLYPHCACHE");
xrdp_caps_process_glyphcache(self, s, len); xrdp_caps_process_glyphcache(self, s, len);
break; break;
case CAPSTYPE_OFFSCREENCACHE: case CAPSTYPE_OFFSCREENCACHE:
DEBUG(("CAPSTYPE_OFFSCREENCACHE")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_OFFSCREENCACHE");
xrdp_caps_process_offscreen_bmpcache(self, s, len); xrdp_caps_process_offscreen_bmpcache(self, s, len);
break; break;
case CAPSTYPE_BITMAPCACHE_REV2: case CAPSTYPE_BITMAPCACHE_REV2:
DEBUG(("CAPSTYPE_BITMAPCACHE_REV2")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_BITMAPCACHE_REV2");
xrdp_caps_process_bmpcache2(self, s, len); xrdp_caps_process_bmpcache2(self, s, len);
break; break;
case CAPSTYPE_VIRTUALCHANNEL: case CAPSTYPE_VIRTUALCHANNEL:
DEBUG(("CAPSTYPE_VIRTUALCHANNEL")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_VIRTUALCHANNEL");
break; break;
case CAPSTYPE_DRAWNINGRIDCACHE: case CAPSTYPE_DRAWNINGRIDCACHE:
DEBUG(("CAPSTYPE_DRAWNINGRIDCACHE")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_DRAWNINGRIDCACHE");
break; break;
case CAPSTYPE_DRAWGDIPLUS: case CAPSTYPE_DRAWGDIPLUS:
DEBUG(("CAPSTYPE_DRAWGDIPLUS")); LOG_DEVEL(LOG_LEVEL_TRACE, "CAPSTYPE_DRAWGDIPLUS");
break; break;
case CAPSTYPE_RAIL: case CAPSTYPE_RAIL:
xrdp_caps_process_rail(self, s, len); xrdp_caps_process_rail(self, s, len);
@ -728,7 +731,7 @@ xrdp_caps_process_confirm_active(struct xrdp_rdp *self, struct stream *s)
xrdp_caps_process_frame_ack(self, s, len); xrdp_caps_process_frame_ack(self, s, len);
break; break;
default: default:
g_writeln("unknown in xrdp_caps_process_confirm_active %d", type); LOG(LOG_LEVEL_WARNING, "unknown in xrdp_caps_process_confirm_active %d", type);
break; break;
} }
@ -736,17 +739,17 @@ xrdp_caps_process_confirm_active(struct xrdp_rdp *self, struct stream *s)
} }
if (self->client_info.no_orders_supported && if (self->client_info.no_orders_supported &&
(self->client_info.offscreen_support_level != 0)) (self->client_info.offscreen_support_level != 0))
{ {
g_writeln("xrdp_caps_process_confirm_active: not enough orders " LOG(LOG_LEVEL_WARNING, "xrdp_caps_process_confirm_active: not enough orders "
"supported by client, client wants off screen bitmap but " "supported by client, client wants off screen bitmap but "
"offscreen bitmaps disabled"); "offscreen bitmaps disabled");
self->client_info.offscreen_support_level = 0; self->client_info.offscreen_support_level = 0;
self->client_info.offscreen_cache_size = 0; self->client_info.offscreen_cache_size = 0;
self->client_info.offscreen_cache_entries = 0; self->client_info.offscreen_cache_entries = 0;
} }
DEBUG(("out xrdp_caps_process_confirm_active")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_caps_process_confirm_active");
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
@ -768,7 +771,7 @@ xrdp_caps_send_demand_active(struct xrdp_rdp *self)
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
DEBUG(("in xrdp_caps_send_demand_active")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_caps_send_demand_active");
if (xrdp_rdp_init(self, s) != 0) if (xrdp_rdp_init(self, s) != 0)
{ {
@ -1035,16 +1038,16 @@ xrdp_caps_send_demand_active(struct xrdp_rdp *self)
free_stream(s); free_stream(s);
return 1; return 1;
} }
DEBUG(("out (1) xrdp_caps_send_demand_active")); LOG_DEVEL(LOG_LEVEL_TRACE, "out (1) xrdp_caps_send_demand_active");
/* send Monitor Layout PDU for dual monitor */ /* send Monitor Layout PDU for dual monitor */
if (self->client_info.monitorCount > 0 && if (self->client_info.monitorCount > 0 &&
self->client_info.multimon == 1) self->client_info.multimon == 1)
{ {
DEBUG(("xrdp_caps_send_demand_active: sending monitor layout pdu")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_caps_send_demand_active: sending monitor layout pdu");
if (xrdp_caps_send_monitorlayout(self) != 0) if (xrdp_caps_send_monitorlayout(self) != 0)
{ {
g_writeln("xrdp_caps_send_demand_active: error sending monitor layout pdu"); LOG(LOG_LEVEL_ERROR, "xrdp_caps_send_demand_active: error sending monitor layout pdu");
} }
} }

58
libxrdp/xrdp_channel.c
View File

@ -52,7 +52,7 @@ xrdp_channel_get_item(struct xrdp_channel *self, int channel_id)
if (self->mcs_layer->channel_list == NULL) if (self->mcs_layer->channel_list == NULL)
{ {
g_writeln("xrdp_channel_get_item - No channel initialized"); LOG(LOG_LEVEL_ERROR, "xrdp_channel_get_item - No channel initialized");
return NULL ; return NULL ;
} }
@ -115,13 +115,13 @@ xrdp_channel_send(struct xrdp_channel *self, struct stream *s, int channel_id,
if (channel == NULL) if (channel == NULL)
{ {
g_writeln("xrdp_channel_send - no such channel"); LOG(LOG_LEVEL_ERROR, "xrdp_channel_send - no such channel");
return 1; return 1;
} }
if (channel->disabled) if (channel->disabled)
{ {
g_writeln("xrdp_channel_send, channel disabled"); LOG(LOG_LEVEL_WARNING, "xrdp_channel_send, channel disabled");
return 0; /* not an error */ return 0; /* not an error */
} }
@ -139,16 +139,16 @@ xrdp_channel_send(struct xrdp_channel *self, struct stream *s, int channel_id,
* *
* That's flag makes MSTSC crash when using RAIL channel. * That's flag makes MSTSC crash when using RAIL channel.
*/ */
// if (channel->flags & XR_CHANNEL_OPTION_SHOW_PROTOCOL) // if (channel->flags & XR_CHANNEL_OPTION_SHOW_PROTOCOL)
// { // {
// flags |= CHANNEL_FLAG_SHOW_PROTOCOL; // flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
// } // }
out_uint32_le(s, flags); out_uint32_le(s, flags);
if (xrdp_sec_send(self->sec_layer, s, channel->chanid) != 0) if (xrdp_sec_send(self->sec_layer, s, channel->chanid) != 0)
{ {
g_writeln("xrdp_channel_send - failure sending data"); LOG(LOG_LEVEL_ERROR, "xrdp_channel_send - failure sending data");
return 1; return 1;
} }
@ -183,12 +183,12 @@ xrdp_channel_call_callback(struct xrdp_channel *self, struct stream *s,
} }
else else
{ {
g_writeln("in xrdp_channel_call_callback, session->callback is nil"); LOG(LOG_LEVEL_TRACE, "in xrdp_channel_call_callback, session->callback is nil");
} }
} }
else else
{ {
g_writeln("in xrdp_channel_call_callback, session is nil"); LOG(LOG_LEVEL_TRACE, "in xrdp_channel_call_callback, session is nil");
} }
return rv; return rv;
@ -270,12 +270,12 @@ drdynvc_process_capability_response(struct xrdp_channel *self,
in_uint16_le(s, cap_version); in_uint16_le(s, cap_version);
if ((cap_version != 2) && (cap_version != 3)) if ((cap_version != 2) && (cap_version != 3))
{ {
g_writeln("drdynvc_process_capability_response: incompatible DVC " LOG(LOG_LEVEL_ERROR, "drdynvc_process_capability_response: incompatible DVC "
"version %d detected", cap_version); "version %d detected", cap_version);
return 1; return 1;
} }
g_writeln("drdynvc_process_capability_response: DVC version %d selected", LOG(LOG_LEVEL_INFO, "drdynvc_process_capability_response: DVC version %d selected",
cap_version); cap_version);
self->drdynvc_state = 1; self->drdynvc_state = 1;
session = self->sec_layer->rdp_layer->session; session = self->sec_layer->rdp_layer->session;
rv = session->callback(session->id, 0x5558, 0, 0, 0, 0); rv = session->callback(session->id, 0x5558, 0, 0, 0, 0);
@ -301,8 +301,8 @@ drdynvc_process_open_channel_response(struct xrdp_channel *self,
return 1; return 1;
} }
in_uint32_le(s, creation_status); in_uint32_le(s, creation_status);
//g_writeln("drdynvc_process_open_channel_response: chan_id 0x%x " LOG_DEVEL(LOG_LEVEL_TRACE, "drdynvc_process_open_channel_response: chan_id 0x%x "
// "creation_status %d", chan_id, creation_status); "creation_status %d", chan_id, creation_status);
session = self->sec_layer->rdp_layer->session; session = self->sec_layer->rdp_layer->session;
if (chan_id > 255) if (chan_id > 255)
{ {
@ -337,7 +337,7 @@ drdynvc_process_close_channel_response(struct xrdp_channel *self,
{ {
return 1; return 1;
} }
//g_writeln("drdynvc_process_close_channel_response: chan_id 0x%x", chan_id); LOG_DEVEL(LOG_LEVEL_TRACE, "drdynvc_process_close_channel_response: chan_id 0x%x", chan_id);
session = self->sec_layer->rdp_layer->session; session = self->sec_layer->rdp_layer->session;
if (chan_id > 255) if (chan_id > 255)
{ {
@ -394,7 +394,7 @@ drdynvc_process_data_first(struct xrdp_channel *self,
in_uint32_le(s, total_bytes); in_uint32_le(s, total_bytes);
} }
bytes = (int) (s->end - s->p); bytes = (int) (s->end - s->p);
//g_writeln("drdynvc_process_data_first: bytes %d total_bytes %d", bytes, total_bytes); LOG_DEVEL(LOG_LEVEL_TRACE, "drdynvc_process_data_first: bytes %d total_bytes %d", bytes, total_bytes);
session = self->sec_layer->rdp_layer->session; session = self->sec_layer->rdp_layer->session;
if (chan_id > 255) if (chan_id > 255)
{ {
@ -424,7 +424,7 @@ drdynvc_process_data(struct xrdp_channel *self,
return 1; return 1;
} }
bytes = (int) (s->end - s->p); bytes = (int) (s->end - s->p);
//g_writeln("drdynvc_process_data: bytes %d", bytes); LOG_DEVEL(LOG_LEVEL_TRACE, "drdynvc_process_data: bytes %d", bytes);
session = self->sec_layer->rdp_layer->session; session = self->sec_layer->rdp_layer->session;
if (chan_id > 255) if (chan_id > 255)
{ {
@ -457,8 +457,8 @@ xrdp_channel_process_drdynvc(struct xrdp_channel *self,
} }
in_uint32_le(s, total_length); in_uint32_le(s, total_length);
in_uint32_le(s, flags); in_uint32_le(s, flags);
//g_writeln("xrdp_channel_process_drdynvc: total_length %d flags 0x%8.8x", LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_channel_process_drdynvc: total_length %d flags 0x%8.8x",
// total_length, flags); total_length, flags);
ls = NULL; ls = NULL;
switch (flags & 3) switch (flags & 3)
{ {
@ -497,7 +497,7 @@ xrdp_channel_process_drdynvc(struct xrdp_channel *self,
ls = s; ls = s;
break; break;
default: default:
g_writeln("xrdp_channel_process_drdynvc: error"); LOG(LOG_LEVEL_ERROR, "xrdp_channel_process_drdynvc: error");
return 1; return 1;
} }
if (ls == NULL) if (ls == NULL)
@ -505,7 +505,7 @@ xrdp_channel_process_drdynvc(struct xrdp_channel *self,
return 1; return 1;
} }
in_uint8(ls, cmd); /* read command */ in_uint8(ls, cmd); /* read command */
//g_writeln("xrdp_channel_process_drdynvc: cmd 0x%x", cmd); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_channel_process_drdynvc: cmd 0x%x", cmd);
rv = 1; rv = 1;
switch (cmd & 0xf0) switch (cmd & 0xf0)
{ {
@ -525,11 +525,11 @@ xrdp_channel_process_drdynvc(struct xrdp_channel *self,
rv = drdynvc_process_data(self, cmd, s); rv = drdynvc_process_data(self, cmd, s);
break; break;
default: default:
g_writeln("xrdp_channel_process_drdynvc: got unknown " LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_channel_process_drdynvc: got unknown "
"command 0x%x", cmd); "command 0x%x", cmd);
break; break;
} }
//g_writeln("xrdp_channel_process_drdynvc: rv %d", rv); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_channel_process_drdynvc: rv %d", rv);
return rv; return rv;
} }
@ -557,12 +557,12 @@ xrdp_channel_process(struct xrdp_channel *self, struct stream *s,
channel = xrdp_channel_get_item(self, channel_id); channel = xrdp_channel_get_item(self, channel_id);
if (channel == NULL) if (channel == NULL)
{ {
g_writeln("xrdp_channel_process, channel not found"); LOG(LOG_LEVEL_ERROR, "xrdp_channel_process, channel not found");
return 1; return 1;
} }
if (channel->disabled) if (channel->disabled)
{ {
g_writeln("xrdp_channel_process, channel disabled"); LOG(LOG_LEVEL_WARNING, "xrdp_channel_process, channel disabled");
return 0; /* not an error */ return 0; /* not an error */
} }
if (channel_id == self->drdynvc_channel_id) if (channel_id == self->drdynvc_channel_id)
@ -627,7 +627,7 @@ xrdp_channel_drdynvc_start(struct xrdp_channel *self)
struct mcs_channel_item *ci; struct mcs_channel_item *ci;
struct mcs_channel_item *dci; struct mcs_channel_item *dci;
g_writeln("xrdp_channel_drdynvc_start:"); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_channel_drdynvc_start:");
dci = NULL; dci = NULL;
count = self->mcs_layer->channel_list->count; count = self->mcs_layer->channel_list->count;
for (index = 0; index < count; index++) for (index = 0; index < count; index++)
@ -727,7 +727,7 @@ xrdp_channel_drdynvc_close(struct xrdp_channel *self, int chan_id)
return 1; return 1;
} }
if ((self->drdynvcs[chan_id].status != XRDP_DRDYNVC_STATUS_OPEN) && if ((self->drdynvcs[chan_id].status != XRDP_DRDYNVC_STATUS_OPEN) &&
(self->drdynvcs[chan_id].status != XRDP_DRDYNVC_STATUS_OPEN_SENT)) (self->drdynvcs[chan_id].status != XRDP_DRDYNVC_STATUS_OPEN_SENT))
{ {
/* not open */ /* not open */
return 1; return 1;

32
libxrdp/xrdp_fastpath.c
View File

@ -30,12 +30,12 @@ xrdp_fastpath_create(struct xrdp_sec *owner, struct trans *trans)
{ {
struct xrdp_fastpath *self; struct xrdp_fastpath *self;
DEBUG((" in xrdp_fastpath_create")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_fastpath_create");
self = (struct xrdp_fastpath *)g_malloc(sizeof(struct xrdp_fastpath), 1); self = (struct xrdp_fastpath *)g_malloc(sizeof(struct xrdp_fastpath), 1);
self->sec_layer = owner; self->sec_layer = owner;
self->trans = trans; self->trans = trans;
self->session = owner->rdp_layer->session; self->session = owner->rdp_layer->session;
DEBUG((" out xrdp_fastpath_create")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_fastpath_create");
return self; return self;
} }
@ -67,7 +67,7 @@ xrdp_fastpath_recv(struct xrdp_fastpath *self, struct stream *s)
int byte; int byte;
char *holdp; char *holdp;
DEBUG((" in xrdp_fastpath_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_fastpath_recv");
holdp = s->p; holdp = s->p;
if (!s_check_rem(s, 2)) if (!s_check_rem(s, 2))
{ {
@ -97,7 +97,7 @@ xrdp_fastpath_recv(struct xrdp_fastpath *self, struct stream *s)
len = byte; len = byte;
} }
s->next_packet = holdp + len; s->next_packet = holdp + len;
DEBUG((" out xrdp_fastpath_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_fastpath_recv");
return 0; return 0;
} }
@ -179,7 +179,9 @@ xrdp_fastpath_process_EVENT_SCANCODE(struct xrdp_fastpath *self,
} }
if ((eventFlags & FASTPATH_INPUT_KBDFLAGS_EXTENDED)) if ((eventFlags & FASTPATH_INPUT_KBDFLAGS_EXTENDED))
{
flags |= KBD_FLAG_EXT; flags |= KBD_FLAG_EXT;
}
xrdp_fastpath_session_callback(self, RDP_INPUT_SCANCODE, xrdp_fastpath_session_callback(self, RDP_INPUT_SCANCODE,
code, 0, flags, 0); code, 0, flags, 0);
@ -253,13 +255,13 @@ static int
xrdp_fastpath_process_EVENT_SYNC(struct xrdp_fastpath *self, xrdp_fastpath_process_EVENT_SYNC(struct xrdp_fastpath *self,
int eventFlags, struct stream *s) int eventFlags, struct stream *s)
{ {
/* /*
* The eventCode bitfield (3 bits in size) MUST be set to * The eventCode bitfield (3 bits in size) MUST be set to
* FASTPATH_INPUT_EVENT_SYNC (3). * FASTPATH_INPUT_EVENT_SYNC (3).
* The eventFlags bitfield (5 bits in size) contains flags * The eventFlags bitfield (5 bits in size) contains flags
* indicating the "on" * indicating the "on"
* status of the keyboard toggle keys. * status of the keyboard toggle keys.
*/ */
xrdp_fastpath_session_callback(self, RDP_INPUT_SYNCHRONIZE, xrdp_fastpath_session_callback(self, RDP_INPUT_SYNCHRONIZE,
eventFlags, 0, 0, 0); eventFlags, 0, 0, 0);
@ -326,8 +328,8 @@ xrdp_fastpath_process_input_event(struct xrdp_fastpath *self,
{ {
case FASTPATH_INPUT_EVENT_SCANCODE: case FASTPATH_INPUT_EVENT_SCANCODE:
if (xrdp_fastpath_process_EVENT_SCANCODE(self, if (xrdp_fastpath_process_EVENT_SCANCODE(self,
eventFlags, eventFlags,
s) != 0) s) != 0)
{ {
return 1; return 1;
} }
@ -365,8 +367,8 @@ xrdp_fastpath_process_input_event(struct xrdp_fastpath *self,
} }
break; break;
default: default:
g_writeln("xrdp_fastpath_process_input_event: unknown " LOG(LOG_LEVEL_WARNING, "xrdp_fastpath_process_input_event: unknown "
"eventCode %d", eventCode); "eventCode %d", eventCode);
break; break;
} }
} }

82
libxrdp/xrdp_iso.c
View File

@ -27,13 +27,7 @@
#include "ms-rdpbcgr.h" #include "ms-rdpbcgr.h"
#include "log.h" #include "log.h"
#define LOG_LEVEL 1
#define LLOG(_level, _args) \
do { if (_level < LOG_LEVEL) { g_write _args ; } } while (0)
#define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { g_writeln _args ; } } while (0)
#define LHEXDUMP(_level, _args) \
do { if (_level < LOG_LEVEL) { g_hexdump _args ; } } while (0)
/*****************************************************************************/ /*****************************************************************************/
@ -42,11 +36,11 @@ xrdp_iso_create(struct xrdp_mcs *owner, struct trans *trans)
{ {
struct xrdp_iso *self; struct xrdp_iso *self;
LLOGLN(10, (" in xrdp_iso_create")); LOG_DEVEL(LOG_LEVEL_DEBUG, " in xrdp_iso_create");
self = (struct xrdp_iso *) g_malloc(sizeof(struct xrdp_iso), 1); self = (struct xrdp_iso *) g_malloc(sizeof(struct xrdp_iso), 1);
self->mcs_layer = owner; self->mcs_layer = owner;
self->trans = trans; self->trans = trans;
LLOGLN(10, (" out xrdp_iso_create")); LOG_DEVEL(LOG_LEVEL_DEBUG, " out xrdp_iso_create");
return self; return self;
} }
@ -80,11 +74,11 @@ xrdp_iso_negotiate_security(struct xrdp_iso *self)
if (self->requestedProtocol & PROTOCOL_SSL) if (self->requestedProtocol & PROTOCOL_SSL)
{ {
if (!g_file_readable(client_info->certificate) || if (!g_file_readable(client_info->certificate) ||
!g_file_readable(client_info->key_file)) !g_file_readable(client_info->key_file))
{ {
/* certificate or privkey is not readable */ /* certificate or privkey is not readable */
log_message(LOG_LEVEL_DEBUG, "No readable certificates or " LOG(LOG_LEVEL_WARNING, "No readable certificates or "
"private keys, cannot accept TLS connections"); "private keys, cannot accept TLS connections");
self->failureCode = SSL_CERT_NOT_ON_SERVER; self->failureCode = SSL_CERT_NOT_ON_SERVER;
rv = 1; /* error */ rv = 1; /* error */
} }
@ -103,8 +97,8 @@ xrdp_iso_negotiate_security(struct xrdp_iso *self)
case PROTOCOL_HYBRID_EX: case PROTOCOL_HYBRID_EX:
default: default:
if ((self->requestedProtocol & PROTOCOL_SSL) && if ((self->requestedProtocol & PROTOCOL_SSL) &&
g_file_readable(client_info->certificate) && g_file_readable(client_info->certificate) &&
g_file_readable(client_info->key_file)) g_file_readable(client_info->key_file))
{ {
/* that's a patch since we don't support CredSSP for now */ /* that's a patch since we don't support CredSSP for now */
self->selectedProtocol = PROTOCOL_SSL; self->selectedProtocol = PROTOCOL_SSL;
@ -116,8 +110,8 @@ xrdp_iso_negotiate_security(struct xrdp_iso *self)
break; break;
} }
log_message(LOG_LEVEL_DEBUG, "Security layer: requested %d, selected %d", LOG(LOG_LEVEL_DEBUG, "Security layer: requested %d, selected %d",
self->requestedProtocol, self->selectedProtocol); self->requestedProtocol, self->selectedProtocol);
return rv; return rv;
} }
@ -131,29 +125,29 @@ xrdp_iso_process_rdp_neg_req(struct xrdp_iso *self, struct stream *s)
if (!s_check_rem(s, 7)) if (!s_check_rem(s, 7))
{ {
LLOGLN(10, ("xrdp_iso_process_rdpNegReq: unexpected end-of-record")); LOG(LOG_LEVEL_ERROR, "xrdp_iso_process_rdpNegReq: unexpected end-of-record");
return 1; return 1;
} }
in_uint8(s, flags); in_uint8(s, flags);
if (flags != 0x0 && flags != 0x8 && flags != 0x1) if (flags != 0x0 && flags != 0x8 && flags != 0x1)
{ {
LLOGLN(10, ("xrdp_iso_process_rdpNegReq: error, flags: %x",flags)); LOG(LOG_LEVEL_ERROR, "xrdp_iso_process_rdpNegReq: error, flags: %x", flags);
return 1; return 1;
} }
in_uint16_le(s, len); in_uint16_le(s, len);
if (len != 8) if (len != 8)
{ {
LLOGLN(10, ("xrdp_iso_process_rdpNegReq: error, length: %x",len)); LOG(LOG_LEVEL_ERROR, "xrdp_iso_process_rdpNegReq: error, length: %x", len);
return 1; return 1;
} }
in_uint32_le(s, self->requestedProtocol); in_uint32_le(s, self->requestedProtocol);
if (self->requestedProtocol > 0xb) if (self->requestedProtocol > 0xb)
{ {
LLOGLN(10, ("xrdp_iso_process_rdpNegReq: error, requestedProtocol: %x", LOG(LOG_LEVEL_ERROR, "xrdp_iso_process_rdpNegReq: error, requestedProtocol: %x",
self->requestedProtocol)); self->requestedProtocol);
return 1; return 1;
} }
@ -181,7 +175,7 @@ xrdp_iso_recv_msg(struct xrdp_iso *self, struct stream *s, int *code, int *len)
if (s != self->trans->in_s) if (s != self->trans->in_s)
{ {
LLOGLN(10, ("xrdp_iso_recv_msg error logic")); LOG(LOG_LEVEL_WARNING, "xrdp_iso_recv_msg error logic");
} }
/* TPKT header is 4 bytes, then first 2 bytes of the X.224 CR-TPDU */ /* TPKT header is 4 bytes, then first 2 bytes of the X.224 CR-TPDU */
@ -197,16 +191,16 @@ xrdp_iso_recv_msg(struct xrdp_iso *self, struct stream *s, int *code, int *len)
if (ver != 3) if (ver != 3)
{ {
LLOGLN(10, ("xrdp_iso_recv_msg: bad ver")); LOG(LOG_LEVEL_ERROR, "xrdp_iso_recv_msg: bad ver");
LHEXDUMP(10, (s->data, 4)); LOG_DEVEL_HEXDUMP(LOG_LEVEL_ERROR, "header", s->data, 4);
return 1; return 1;
} }
if (*len == 255) if (*len == 255)
{ {
/* X.224 13.2.1 - reserved value */ /* X.224 13.2.1 - reserved value */
LLOGLN(10, ("xrdp_iso_recv_msg: reserved length encountered")); LOG(LOG_LEVEL_ERROR, "xrdp_iso_recv_msg: reserved length encountered");
LHEXDUMP(10, (s->data, 4)); LOG_DEVEL_HEXDUMP(LOG_LEVEL_ERROR, "header", s->data, 4);
return 1; return 1;
} }
@ -240,21 +234,21 @@ xrdp_iso_recv(struct xrdp_iso *self, struct stream *s)
int code; int code;
int len; int len;
LLOGLN(10, (" in xrdp_iso_recv")); LOG_DEVEL(LOG_LEVEL_DEBUG, " in xrdp_iso_recv");
if (xrdp_iso_recv_msg(self, s, &code, &len) != 0) if (xrdp_iso_recv_msg(self, s, &code, &len) != 0)
{ {
LLOGLN(10, (" out xrdp_iso_recv xrdp_iso_recv_msg return non zero")); LOG(LOG_LEVEL_ERROR, " out xrdp_iso_recv xrdp_iso_recv_msg return non zero");
return 1; return 1;
} }
if (code != ISO_PDU_DT || len != 2) if (code != ISO_PDU_DT || len != 2)
{ {
LLOGLN(10, (" out xrdp_iso_recv code != ISO_PDU_DT or length != 2")); LOG(LOG_LEVEL_ERROR, " out xrdp_iso_recv code != ISO_PDU_DT or length != 2");
return 1; return 1;
} }
LLOGLN(10, (" out xrdp_iso_recv")); LOG_DEVEL(LOG_LEVEL_DEBUG, " out xrdp_iso_recv");
return 0; return 0;
} }
/*****************************************************************************/ /*****************************************************************************/
@ -345,7 +339,7 @@ xrdp_iso_incoming(struct xrdp_iso *self)
struct stream *s; struct stream *s;
int expected_pdu_len; int expected_pdu_len;
LLOGLN(10, (" in xrdp_iso_incoming")); LOG_DEVEL(LOG_LEVEL_DEBUG, " in xrdp_iso_incoming");
s = libxrdp_force_read(self->trans); s = libxrdp_force_read(self->trans);
if (s == NULL) if (s == NULL)
@ -355,7 +349,7 @@ xrdp_iso_incoming(struct xrdp_iso *self)
if (xrdp_iso_recv_msg(self, s, &code, &len) != 0) if (xrdp_iso_recv_msg(self, s, &code, &len) != 0)
{ {
LLOGLN(0, ("xrdp_iso_incoming: xrdp_iso_recv_msg returned non zero")); LOG(LOG_LEVEL_ERROR, "xrdp_iso_incoming: xrdp_iso_recv_msg returned non zero");
return 1; return 1;
} }
@ -375,8 +369,8 @@ xrdp_iso_incoming(struct xrdp_iso *self)
expected_pdu_len = (s->end - s->p) + 6; expected_pdu_len = (s->end - s->p) + 6;
if (len != expected_pdu_len) if (len != expected_pdu_len)
{ {
LLOGLN(0, ("xrdp_iso_incoming: X.224 CR-TPDU length exp %d got %d", LOG(LOG_LEVEL_ERROR, "xrdp_iso_incoming: X.224 CR-TPDU length exp %d got %d",
expected_pdu_len, len)); expected_pdu_len, len);
return 1; return 1;
} }
@ -392,7 +386,7 @@ xrdp_iso_incoming(struct xrdp_iso *self)
self->rdpNegData = 1; self->rdpNegData = 1;
if (xrdp_iso_process_rdp_neg_req(self, s) != 0) if (xrdp_iso_process_rdp_neg_req(self, s) != 0)
{ {
LLOGLN(0, ("xrdp_iso_incoming: xrdp_iso_process_rdpNegReq returned non zero")); LOG(LOG_LEVEL_ERROR, "xrdp_iso_incoming: xrdp_iso_process_rdpNegReq returned non zero");
return 1; return 1;
} }
break; break;
@ -400,17 +394,17 @@ xrdp_iso_incoming(struct xrdp_iso *self)
// TODO // TODO
if (!s_check_rem(s, 1 + 2 + 16 + 16)) if (!s_check_rem(s, 1 + 2 + 16 + 16))
{ {
LLOGLN(0, ("xrdp_iso_incoming: short correlation info")); LOG(LOG_LEVEL_ERROR, "xrdp_iso_incoming: short correlation info");
return 1; return 1;
} }
in_uint8s(s, 1 + 2 + 16 + 16); in_uint8s(s, 1 + 2 + 16 + 16);
break; break;
case 'C': /* Cookie */ case 'C': /* Cookie */
/* The routingToken and cookie fields are both ASCII /* The routingToken and cookie fields are both ASCII
* strings starting with the word 'Cookie: ' and * strings starting with the word 'Cookie: ' and
* ending with CR+LF. We ignore both, so we do * ending with CR+LF. We ignore both, so we do
* not need to distinguish them */ * not need to distinguish them */
while (s_check_rem(s, 1)) while (s_check_rem(s, 1))
{ {
in_uint8(s, cc_type); in_uint8(s, cc_type);
@ -433,11 +427,11 @@ xrdp_iso_incoming(struct xrdp_iso *self)
/* send connection confirm back to client */ /* send connection confirm back to client */
if (xrdp_iso_send_cc(self) != 0) if (xrdp_iso_send_cc(self) != 0)
{ {
LLOGLN(0, ("xrdp_iso_incoming: xrdp_iso_send_cc returned non zero")); LOG(LOG_LEVEL_ERROR, "xrdp_iso_incoming: xrdp_iso_send_cc returned non zero");
return 1; return 1;
} }
LLOGLN(10, (" out xrdp_iso_incoming")); LOG_DEVEL(LOG_LEVEL_DEBUG, " out xrdp_iso_incoming");
return rv; return rv;
} }
@ -458,7 +452,7 @@ xrdp_iso_send(struct xrdp_iso *self, struct stream *s)
{ {
int len; int len;
LLOGLN(10, (" in xrdp_iso_send")); LOG_DEVEL(LOG_LEVEL_DEBUG, " in xrdp_iso_send");
s_pop_layer(s, iso_hdr); s_pop_layer(s, iso_hdr);
len = (int) (s->end - s->p); len = (int) (s->end - s->p);
out_uint8(s, 3); out_uint8(s, 3);
@ -473,6 +467,6 @@ xrdp_iso_send(struct xrdp_iso *self, struct stream *s)
return 1; return 1;
} }
LLOGLN(10, (" out xrdp_iso_send")); LOG_DEVEL(LOG_LEVEL_DEBUG, " out xrdp_iso_send");
return 0; return 0;
} }

32
libxrdp/xrdp_jpeg_compress.c
View File

@ -55,12 +55,12 @@ xrdp_jpeg_compress(void *handle, char *in_data, int width, int height,
if (bpp != 24) if (bpp != 24)
{ {
g_writeln("xrdp_jpeg_compress: bpp wrong %d", bpp); LOG(LOG_LEVEL_WARNING, "xrdp_jpeg_compress: bpp wrong %d", bpp);
return height; return height;
} }
if (handle == 0) if (handle == 0)
{ {
g_writeln("xrdp_jpeg_compress: handle is nil"); LOG(LOG_LEVEL_WARNING, "xrdp_jpeg_compress: handle is nil");
return height; return height;
} }
tj_han = (tjhandle) handle; tj_han = (tjhandle) handle;
@ -70,7 +70,7 @@ xrdp_jpeg_compress(void *handle, char *in_data, int width, int height,
temp_buf = 0; temp_buf = 0;
if (e == 0) if (e == 0)
{ {
src_buf = (unsigned char*)in_data; src_buf = (unsigned char *)in_data;
} }
else else
{ {
@ -97,15 +97,15 @@ xrdp_jpeg_compress(void *handle, char *in_data, int width, int height,
} }
src_buf = (unsigned char *) temp_buf; src_buf = (unsigned char *) temp_buf;
} }
dst_buf = (unsigned char*)(s->p); dst_buf = (unsigned char *)(s->p);
error = tjCompress(tj_han, src_buf, width + e, (width + e) * 4, height, error = tjCompress(tj_han, src_buf, width + e, (width + e) * 4, height,
TJPF_XBGR, dst_buf, &cdata_bytes, TJPF_XBGR, dst_buf, &cdata_bytes,
TJSAMP_420, quality, 0); TJSAMP_420, quality, 0);
if (error != 0) if (error != 0)
{ {
log_message(LOG_LEVEL_ERROR, LOG(LOG_LEVEL_ERROR,
"xrdp_jpeg_compress: tjCompress error: %s", "xrdp_jpeg_compress: tjCompress error: %s",
tjGetErrorStr()); tjGetErrorStr());
} }
s->p += cdata_bytes; s->p += cdata_bytes;
@ -132,8 +132,8 @@ xrdp_codec_jpeg_compress(void *handle,
int quality, /* higher numbers compress less */ int quality, /* higher numbers compress less */
char *out_data, /* dest for jpg image */ char *out_data, /* dest for jpg image */
int *io_len /* length of out_data and on return */ int *io_len /* length of out_data and on return */
/* len of compressed data */ /* len of compressed data */
) )
{ {
tjhandle tj_han; tjhandle tj_han;
int error; int error;
@ -147,7 +147,7 @@ xrdp_codec_jpeg_compress(void *handle,
if (handle == 0) if (handle == 0)
{ {
g_writeln("xrdp_codec_jpeg_compress: handle is nil"); LOG(LOG_LEVEL_WARNING, "xrdp_codec_jpeg_compress: handle is nil");
return height; return height;
} }
@ -185,12 +185,12 @@ xrdp_codec_jpeg_compress(void *handle,
TJSAMP_420, /* jpeg sub sample */ TJSAMP_420, /* jpeg sub sample */
quality, /* jpeg quality */ quality, /* jpeg quality */
0 /* flags */ 0 /* flags */
); );
if (error != 0) if (error != 0)
{ {
log_message(LOG_LEVEL_ERROR, LOG(LOG_LEVEL_ERROR,
"xrdp_codec_jpeg_compress: tjCompress error: %s", "xrdp_codec_jpeg_compress: tjCompress error: %s",
tjGetErrorStr()); tjGetErrorStr());
} }
*io_len = lio_len; *io_len = lio_len;
@ -303,7 +303,7 @@ jp_do_compress(JOCTET *data, int width, int height, int bpp, int quality,
jpeg_create_compress(&cinfo); jpeg_create_compress(&cinfo);
memset(&md, 0, sizeof(md)); memset(&md, 0, sizeof(md));
md.cb = comp_data, md.cb = comp_data,
md.cb_bytes = *comp_data_bytes; md.cb_bytes = *comp_data_bytes;
cinfo.client_data = &md; cinfo.client_data = &md;
memset(&dst_mgr, 0, sizeof(dst_mgr)); memset(&dst_mgr, 0, sizeof(dst_mgr));
dst_mgr.init_destination = my_init_destination; dst_mgr.init_destination = my_init_destination;
@ -400,7 +400,7 @@ jpeg_compress(char *in_data, int width, int height,
} }
else else
{ {
g_writeln("bpp wrong %d", bpp); LOG(LOG_LEVEL_WARNING, "bpp wrong %d", bpp);
} }
cdata_bytes = byte_limit; cdata_bytes = byte_limit;

106
libxrdp/xrdp_mcs.c
View File

@ -34,7 +34,7 @@ xrdp_mcs_create(struct xrdp_sec *owner, struct trans *trans,
{ {
struct xrdp_mcs *self; struct xrdp_mcs *self;
DEBUG((" in xrdp_mcs_create")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_create");
self = (struct xrdp_mcs *)g_malloc(sizeof(struct xrdp_mcs), 1); self = (struct xrdp_mcs *)g_malloc(sizeof(struct xrdp_mcs), 1);
self->sec_layer = owner; self->sec_layer = owner;
self->userid = 1; self->userid = 1;
@ -43,7 +43,7 @@ xrdp_mcs_create(struct xrdp_sec *owner, struct trans *trans,
self->server_mcs_data = server_mcs_data; self->server_mcs_data = server_mcs_data;
self->iso_layer = xrdp_iso_create(self, trans); self->iso_layer = xrdp_iso_create(self, trans);
self->channel_list = list_create(); self->channel_list = list_create();
DEBUG((" out xrdp_mcs_create")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_create");
return self; return self;
} }
@ -74,7 +74,7 @@ xrdp_mcs_delete(struct xrdp_mcs *self)
xrdp_iso_delete(self->iso_layer); xrdp_iso_delete(self->iso_layer);
/* make sure we get null pointer exception if struct is used again. */ /* make sure we get null pointer exception if struct is used again. */
DEBUG(("xrdp_mcs_delete processed")) LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_mcs_delete processed");
g_memset(self, 0, sizeof(struct xrdp_mcs)) ; g_memset(self, 0, sizeof(struct xrdp_mcs)) ;
g_free(self); g_free(self);
} }
@ -87,14 +87,14 @@ xrdp_mcs_send_cjcf(struct xrdp_mcs *self, int userid, int chanid)
{ {
struct stream *s; struct stream *s;
DEBUG((" in xrdp_mcs_send_cjcf")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_send_cjcf");
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
if (xrdp_iso_init(self->iso_layer, s) != 0) if (xrdp_iso_init(self->iso_layer, s) != 0)
{ {
free_stream(s); free_stream(s);
DEBUG((" out xrdp_mcs_send_cjcf error")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_send_cjcf error");
return 1; return 1;
} }
@ -108,12 +108,12 @@ xrdp_mcs_send_cjcf(struct xrdp_mcs *self, int userid, int chanid)
if (xrdp_iso_send(self->iso_layer, s) != 0) if (xrdp_iso_send(self->iso_layer, s) != 0)
{ {
free_stream(s); free_stream(s);
DEBUG((" out xrdp_mcs_send_cjcf error")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_send_cjcf error");
return 1; return 1;
} }
free_stream(s); free_stream(s);
DEBUG((" out xrdp_mcs_send_cjcf")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_send_cjcf");
return 0; return 0;
} }
@ -127,14 +127,14 @@ xrdp_mcs_recv(struct xrdp_mcs *self, struct stream *s, int *chan)
int len; int len;
int userid; int userid;
int chanid; int chanid;
DEBUG((" in xrdp_mcs_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_recv");
while (1) while (1)
{ {
if (xrdp_iso_recv(self->iso_layer, s) != 0) if (xrdp_iso_recv(self->iso_layer, s) != 0)
{ {
DEBUG((" out xrdp_mcs_recv, xrdp_iso_recv return non zero")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_recv, xrdp_iso_recv return non zero");
g_writeln("xrdp_mcs_recv: xrdp_iso_recv failed"); LOG(LOG_LEVEL_ERROR, "xrdp_mcs_recv: xrdp_iso_recv failed");
return 1; return 1;
} }
@ -148,8 +148,8 @@ xrdp_mcs_recv(struct xrdp_mcs *self, struct stream *s, int *chan)
if (appid == MCS_DPUM) /* Disconnect Provider Ultimatum */ if (appid == MCS_DPUM) /* Disconnect Provider Ultimatum */
{ {
g_writeln("received Disconnect Provider Ultimatum"); LOG(LOG_LEVEL_ERROR, "received Disconnect Provider Ultimatum");
DEBUG((" out xrdp_mcs_recv appid != MCS_DPUM")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_recv appid != MCS_DPUM");
return 1; return 1;
} }
@ -164,18 +164,18 @@ xrdp_mcs_recv(struct xrdp_mcs *self, struct stream *s, int *chan)
in_uint16_be(s, userid); in_uint16_be(s, userid);
in_uint16_be(s, chanid); in_uint16_be(s, chanid);
log_message(LOG_LEVEL_DEBUG,"MCS_CJRQ - channel join request received"); LOG(LOG_LEVEL_DEBUG, "MCS_CJRQ - channel join request received");
DEBUG(("xrdp_mcs_recv adding channel %4.4x", chanid)); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_mcs_recv adding channel %4.4x", chanid);
if (xrdp_mcs_send_cjcf(self, userid, chanid) != 0) if (xrdp_mcs_send_cjcf(self, userid, chanid) != 0)
{ {
log_message(LOG_LEVEL_ERROR,"Non handled error from xrdp_mcs_send_cjcf") ; LOG(LOG_LEVEL_ERROR, "Non handled error from xrdp_mcs_send_cjcf") ;
} }
s = libxrdp_force_read(self->iso_layer->trans); s = libxrdp_force_read(self->iso_layer->trans);
if (s == 0) if (s == 0)
{ {
g_writeln("xrdp_mcs_recv: libxrdp_force_read failed"); LOG(LOG_LEVEL_ERROR, "xrdp_mcs_recv: libxrdp_force_read failed");
return 1; return 1;
} }
@ -188,7 +188,7 @@ xrdp_mcs_recv(struct xrdp_mcs *self, struct stream *s, int *chan)
} }
else else
{ {
log_message(LOG_LEVEL_DEBUG,"Received an unhandled appid:%d",appid); LOG(LOG_LEVEL_DEBUG, "Received an unhandled appid:%d", appid);
} }
break; break;
@ -196,7 +196,7 @@ xrdp_mcs_recv(struct xrdp_mcs *self, struct stream *s, int *chan)
if (appid != MCS_SDRQ) if (appid != MCS_SDRQ)
{ {
DEBUG((" out xrdp_mcs_recv err got 0x%x need MCS_SDRQ", appid)); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_recv err got 0x%x need MCS_SDRQ", appid);
return 1; return 1;
} }
@ -219,7 +219,7 @@ xrdp_mcs_recv(struct xrdp_mcs *self, struct stream *s, int *chan)
in_uint8s(s, 1); in_uint8s(s, 1);
} }
DEBUG((" out xrdp_mcs_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_recv");
return 0; return 0;
} }
@ -437,7 +437,7 @@ xrdp_mcs_recv_edrq(struct xrdp_mcs *self)
int opcode; int opcode;
struct stream *s; struct stream *s;
DEBUG((" in xrdp_mcs_recv_edrq")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_recv_edrq");
s = libxrdp_force_read(self->iso_layer->trans); s = libxrdp_force_read(self->iso_layer->trans);
if (s == 0) if (s == 0)
@ -484,7 +484,7 @@ xrdp_mcs_recv_edrq(struct xrdp_mcs *self)
return 1; return 1;
} }
DEBUG((" out xrdp_mcs_recv_edrq")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_recv_edrq");
return 0; return 0;
} }
@ -496,7 +496,7 @@ xrdp_mcs_recv_aurq(struct xrdp_mcs *self)
int opcode; int opcode;
struct stream *s; struct stream *s;
DEBUG((" in xrdp_mcs_recv_aurq")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_recv_aurq");
s = libxrdp_force_read(self->iso_layer->trans); s = libxrdp_force_read(self->iso_layer->trans);
if (s == 0) if (s == 0)
@ -535,7 +535,7 @@ xrdp_mcs_recv_aurq(struct xrdp_mcs *self)
return 1; return 1;
} }
DEBUG((" out xrdp_mcs_recv_aurq")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_recv_aurq");
return 0; return 0;
} }
@ -546,14 +546,14 @@ xrdp_mcs_send_aucf(struct xrdp_mcs *self)
{ {
struct stream *s; struct stream *s;
DEBUG((" in xrdp_mcs_send_aucf")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_send_aucf");
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
if (xrdp_iso_init(self->iso_layer, s) != 0) if (xrdp_iso_init(self->iso_layer, s) != 0)
{ {
free_stream(s); free_stream(s);
DEBUG((" out xrdp_mcs_send_aucf error")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_send_aucf error");
return 1; return 1;
} }
@ -565,12 +565,12 @@ xrdp_mcs_send_aucf(struct xrdp_mcs *self)
if (xrdp_iso_send(self->iso_layer, s) != 0) if (xrdp_iso_send(self->iso_layer, s) != 0)
{ {
free_stream(s); free_stream(s);
DEBUG((" out xrdp_mcs_send_aucf error")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_send_aucf error");
return 1; return 1;
} }
free_stream(s); free_stream(s);
DEBUG((" out xrdp_mcs_send_aucf")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_send_aucf");
return 0; return 0;
} }
@ -722,8 +722,8 @@ xrdp_mcs_out_gcc_data(struct xrdp_sec *self)
int index; int index;
int channel; int channel;
int gcc_size; int gcc_size;
char* gcc_size_ptr; char *gcc_size_ptr;
char* ud_ptr; char *ud_ptr;
num_channels = self->mcs_layer->channel_list->count; num_channels = self->mcs_layer->channel_list->count;
num_channels_even = num_channels + (num_channels & 1); num_channels_even = num_channels + (num_channels & 1);
@ -766,7 +766,7 @@ xrdp_mcs_out_gcc_data(struct xrdp_sec *self)
out_uint8(s, 0); out_uint8(s, 0);
if (self->mcs_layer->iso_layer->rdpNegData) if (self->mcs_layer->iso_layer->rdpNegData)
{ {
/* RequestedProtocol */ /* RequestedProtocol */
out_uint32_le(s, self->mcs_layer->iso_layer->requestedProtocol); out_uint32_le(s, self->mcs_layer->iso_layer->requestedProtocol);
} }
out_uint16_le(s, SEC_TAG_SRV_CHANNELS); out_uint16_le(s, SEC_TAG_SRV_CHANNELS);
@ -789,7 +789,7 @@ xrdp_mcs_out_gcc_data(struct xrdp_sec *self)
if (self->rsa_key_bytes == 64) if (self->rsa_key_bytes == 64)
{ {
g_writeln("xrdp_sec_out_mcs_data: using 512 bit RSA key"); LOG(LOG_LEVEL_DEBUG, "xrdp_sec_out_mcs_data: using 512 bit RSA key");
out_uint16_le(s, SEC_TAG_SRV_CRYPT); out_uint16_le(s, SEC_TAG_SRV_CRYPT);
out_uint16_le(s, 0x00ec); /* len is 236 */ out_uint16_le(s, 0x00ec); /* len is 236 */
out_uint32_le(s, self->crypt_method); out_uint32_le(s, self->crypt_method);
@ -819,7 +819,7 @@ xrdp_mcs_out_gcc_data(struct xrdp_sec *self)
} }
else if (self->rsa_key_bytes == 256) else if (self->rsa_key_bytes == 256)
{ {
g_writeln("xrdp_sec_out_mcs_data: using 2048 bit RSA key"); LOG(LOG_LEVEL_DEBUG, "xrdp_sec_out_mcs_data: using 2048 bit RSA key");
out_uint16_le(s, SEC_TAG_SRV_CRYPT); out_uint16_le(s, SEC_TAG_SRV_CRYPT);
out_uint16_le(s, 0x01ac); /* len is 428 */ out_uint16_le(s, 0x01ac); /* len is 428 */
out_uint32_le(s, self->crypt_method); out_uint32_le(s, self->crypt_method);
@ -849,7 +849,7 @@ xrdp_mcs_out_gcc_data(struct xrdp_sec *self)
} }
else if (self->rsa_key_bytes == 0) /* no security */ else if (self->rsa_key_bytes == 0) /* no security */
{ {
g_writeln("xrdp_sec_out_mcs_data: using no security"); LOG(LOG_LEVEL_DEBUG, "xrdp_sec_out_mcs_data: using no security");
out_uint16_le(s, SEC_TAG_SRV_CRYPT); out_uint16_le(s, SEC_TAG_SRV_CRYPT);
out_uint16_le(s, 12); /* len is 12 */ out_uint16_le(s, 12); /* len is 12 */
out_uint32_le(s, self->crypt_method); out_uint32_le(s, self->crypt_method);
@ -857,7 +857,7 @@ xrdp_mcs_out_gcc_data(struct xrdp_sec *self)
} }
else else
{ {
g_writeln("xrdp_sec_out_mcs_data: error"); LOG(LOG_LEVEL_ERROR, "xrdp_sec_out_mcs_data: error");
} }
/* end certificate */ /* end certificate */
s_mark_end(s); s_mark_end(s);
@ -876,14 +876,14 @@ xrdp_mcs_send_connect_response(struct xrdp_mcs *self)
int data_len; int data_len;
struct stream *s; struct stream *s;
DEBUG((" in xrdp_mcs_send_connect_response")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_send_connect_response");
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
data_len = (int) (self->server_mcs_data->end - self->server_mcs_data->data); data_len = (int) (self->server_mcs_data->end - self->server_mcs_data->data);
xrdp_iso_init(self->iso_layer, s); xrdp_iso_init(self->iso_layer, s);
//TODO: we should calculate the whole length include MCS_CONNECT_RESPONSE //TODO: we should calculate the whole length include MCS_CONNECT_RESPONSE
xrdp_mcs_ber_out_header(self, s, MCS_CONNECT_RESPONSE, xrdp_mcs_ber_out_header(self, s, MCS_CONNECT_RESPONSE,
data_len > 0x80 ? data_len + 38 : data_len + 36); data_len > 0x80 ? data_len + 38 : data_len + 36);
xrdp_mcs_ber_out_header(self, s, BER_TAG_RESULT, 1); xrdp_mcs_ber_out_header(self, s, BER_TAG_RESULT, 1);
out_uint8(s, 0); out_uint8(s, 0);
xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 1); xrdp_mcs_ber_out_header(self, s, BER_TAG_INTEGER, 1);
@ -897,12 +897,12 @@ xrdp_mcs_send_connect_response(struct xrdp_mcs *self)
if (xrdp_iso_send(self->iso_layer, s) != 0) if (xrdp_iso_send(self->iso_layer, s) != 0)
{ {
free_stream(s); free_stream(s);
DEBUG((" out xrdp_mcs_send_connect_response error")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_send_connect_response error");
return 1; return 1;
} }
free_stream(s); free_stream(s);
DEBUG((" out xrdp_mcs_send_connect_response")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_send_connect_response");
return 0; return 0;
} }
@ -913,7 +913,7 @@ xrdp_mcs_incoming(struct xrdp_mcs *self)
{ {
int index; int index;
DEBUG((" in xrdp_mcs_incoming")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_incoming");
if (xrdp_mcs_recv_connect_initial(self) != 0) if (xrdp_mcs_recv_connect_initial(self) != 0)
{ {
@ -959,13 +959,13 @@ xrdp_mcs_incoming(struct xrdp_mcs *self)
} }
if (xrdp_mcs_send_cjcf(self, self->userid, if (xrdp_mcs_send_cjcf(self, self->userid,
self->userid + MCS_USERCHANNEL_BASE + index) != 0) self->userid + MCS_USERCHANNEL_BASE + index) != 0)
{ {
return 1; return 1;
} }
} }
DEBUG((" out xrdp_mcs_incoming")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_incoming");
return 0; return 0;
} }
@ -1005,12 +1005,12 @@ xrdp_mcs_call_callback(struct xrdp_mcs *self)
} }
else else
{ {
g_writeln("in xrdp_mcs_send, session->callback is nil"); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_mcs_send, session->callback is nil");
} }
} }
else else
{ {
g_writeln("in xrdp_mcs_send, session is nil"); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_mcs_send, session is nil");
} }
return rv; return rv;
@ -1025,13 +1025,13 @@ xrdp_mcs_send(struct xrdp_mcs *self, struct stream *s, int chan)
char *lp; char *lp;
//static int max_len = 0; //static int max_len = 0;
DEBUG((" in xrdp_mcs_send")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_send");
s_pop_layer(s, mcs_hdr); s_pop_layer(s, mcs_hdr);
len = (s->end - s->p) - 8; len = (s->end - s->p) - 8;
if (len > 8192 * 2) if (len > 8192 * 2)
{ {
g_writeln("error in xrdp_mcs_send, size too big: %d bytes", len); LOG(LOG_LEVEL_WARNING, "error in xrdp_mcs_send, size too big: %d bytes", len);
} }
//if (len > max_len) //if (len > max_len)
@ -1068,7 +1068,7 @@ xrdp_mcs_send(struct xrdp_mcs *self, struct stream *s, int chan)
if (xrdp_iso_send(self->iso_layer, s) != 0) if (xrdp_iso_send(self->iso_layer, s) != 0)
{ {
DEBUG((" out xrdp_mcs_send error")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_send error");
return 1; return 1;
} }
@ -1079,7 +1079,7 @@ xrdp_mcs_send(struct xrdp_mcs *self, struct stream *s, int chan)
xrdp_mcs_call_callback(self); xrdp_mcs_call_callback(self);
} }
DEBUG((" out xrdp_mcs_send")); LOG_DEVEL(LOG_LEVEL_TRACE, " out xrdp_mcs_send");
return 0; return 0;
} }
@ -1097,11 +1097,11 @@ close_rdp_socket(struct xrdp_mcs *self)
trans_shutdown_tls_mode(self->iso_layer->trans); trans_shutdown_tls_mode(self->iso_layer->trans);
g_tcp_close(self->iso_layer->trans->sck); g_tcp_close(self->iso_layer->trans->sck);
self->iso_layer->trans->sck = 0 ; self->iso_layer->trans->sck = 0 ;
g_writeln("xrdp_mcs_disconnect - socket closed"); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_mcs_disconnect - socket closed");
return; return;
} }
} }
g_writeln("Failed to close socket"); LOG_DEVEL(LOG_LEVEL_TRACE, "Failed to close socket");
} }
/*****************************************************************************/ /*****************************************************************************/
@ -1111,7 +1111,7 @@ xrdp_mcs_disconnect(struct xrdp_mcs *self)
{ {
struct stream *s; struct stream *s;
DEBUG((" in xrdp_mcs_disconnect")); LOG_DEVEL(LOG_LEVEL_TRACE, " in xrdp_mcs_disconnect");
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
@ -1119,7 +1119,7 @@ xrdp_mcs_disconnect(struct xrdp_mcs *self)
{ {
free_stream(s); free_stream(s);
close_rdp_socket(self); close_rdp_socket(self);
DEBUG((" out xrdp_mcs_disconnect error - 1")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_disconnect error - 1");
return 1; return 1;
} }
@ -1131,12 +1131,12 @@ xrdp_mcs_disconnect(struct xrdp_mcs *self)
{ {
free_stream(s); free_stream(s);
close_rdp_socket(self); close_rdp_socket(self);
DEBUG((" out xrdp_mcs_disconnect error - 2")); LOG(LOG_LEVEL_ERROR, " out xrdp_mcs_disconnect error - 2");
return 1; return 1;
} }
free_stream(s); free_stream(s);
close_rdp_socket(self); close_rdp_socket(self);
DEBUG(("xrdp_mcs_disconnect - close sent")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_mcs_disconnect - close sent");
return 0; return 0;
} }

516
libxrdp/xrdp_mppc_enc.c
View File

@ -24,14 +24,6 @@
#include "libxrdp.h" #include "libxrdp.h"
#define MPPC_ENC_DEBUG 0
#if MPPC_ENC_DEBUG
#define DLOG(_args) g_printf _args
#else
#define DLOG(_args) do { } while (0)
#endif
/* local defines */ /* local defines */
#define RDP_40_HIST_BUF_LEN (1024 * 8) /* RDP 4.0 uses 8K history buf */ #define RDP_40_HIST_BUF_LEN (1024 * 8) /* RDP 4.0 uses 8K history buf */
@ -49,7 +41,7 @@
#define CRC_INIT 0xFFFF #define CRC_INIT 0xFFFF
#define CRC(_crcval, _newchar) _crcval = \ #define CRC(_crcval, _newchar) _crcval = \
((_crcval) >> 8) ^ g_crc_table[((_crcval) ^ (_newchar)) & 0x00ff] ((_crcval) >> 8) ^ g_crc_table[((_crcval) ^ (_newchar)) & 0x00ff]
/* CRC16 defs */ /* CRC16 defs */
static const tui16 g_crc_table[256] = static const tui16 g_crc_table[256] =
@ -92,336 +84,336 @@ static const tui16 g_crc_table[256] =
insert 2 bits into outputBuffer insert 2 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_2_bits(_data) \ #define insert_2_bits(_data) \
do \ do \
{ \
if ((bits_left >= 3) && (bits_left <= 8)) \
{ \ { \
i = bits_left - 2; \ if ((bits_left >= 3) && (bits_left <= 8)) \
outputBuffer[opb_index] |= _data << i; \ { \
bits_left = i; \ i = bits_left - 2; \
} \ outputBuffer[opb_index] |= _data << i; \
else \ bits_left = i; \
{ \ } \
i = 2 - bits_left; \ else \
j = 8 - i; \ { \
outputBuffer[opb_index++] |= _data >> i; \ i = 2 - bits_left; \
outputBuffer[opb_index] |= _data << j; \ j = 8 - i; \
bits_left = j; \ outputBuffer[opb_index++] |= _data >> i; \
} \ outputBuffer[opb_index] |= _data << j; \
} while (0) bits_left = j; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 3 bits into outputBuffer insert 3 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_3_bits(_data) \ #define insert_3_bits(_data) \
do \ do \
{ \
if ((bits_left >= 4) && (bits_left <= 8)) \
{ \ { \
i = bits_left - 3; \ if ((bits_left >= 4) && (bits_left <= 8)) \
outputBuffer[opb_index] |= _data << i; \ { \
bits_left = i; \ i = bits_left - 3; \
} \ outputBuffer[opb_index] |= _data << i; \
else \ bits_left = i; \
{ \ } \
i = 3 - bits_left; \ else \
j = 8 - i; \ { \
outputBuffer[opb_index++] |= _data >> i; \ i = 3 - bits_left; \
outputBuffer[opb_index] |= _data << j; \ j = 8 - i; \
bits_left = j; \ outputBuffer[opb_index++] |= _data >> i; \
} \ outputBuffer[opb_index] |= _data << j; \
} while (0) bits_left = j; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 4 bits into outputBuffer insert 4 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_4_bits(_data) \ #define insert_4_bits(_data) \
do \ do \
{ \
if ((bits_left >= 5) && (bits_left <= 8)) \
{ \ { \
i = bits_left - 4; \ if ((bits_left >= 5) && (bits_left <= 8)) \
outputBuffer[opb_index] |= _data << i; \ { \
bits_left = i; \ i = bits_left - 4; \
} \ outputBuffer[opb_index] |= _data << i; \
else \ bits_left = i; \
{ \ } \
i = 4 - bits_left; \ else \
j = 8 - i; \ { \
outputBuffer[opb_index++] |= _data >> i; \ i = 4 - bits_left; \
outputBuffer[opb_index] |= _data << j; \ j = 8 - i; \
bits_left = j; \ outputBuffer[opb_index++] |= _data >> i; \
} \ outputBuffer[opb_index] |= _data << j; \
} while (0) bits_left = j; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 5 bits into outputBuffer insert 5 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_5_bits(_data) \ #define insert_5_bits(_data) \
do \ do \
{ \
if ((bits_left >= 6) && (bits_left <= 8)) \
{ \ { \
i = bits_left - 5; \ if ((bits_left >= 6) && (bits_left <= 8)) \
outputBuffer[opb_index] |= _data << i; \ { \
bits_left = i; \ i = bits_left - 5; \
} \ outputBuffer[opb_index] |= _data << i; \
else \ bits_left = i; \
{ \ } \
i = 5 - bits_left; \ else \
j = 8 - i; \ { \
outputBuffer[opb_index++] |= _data >> i; \ i = 5 - bits_left; \
outputBuffer[opb_index] |= _data << j; \ j = 8 - i; \
bits_left = j; \ outputBuffer[opb_index++] |= _data >> i; \
} \ outputBuffer[opb_index] |= _data << j; \
} while (0) bits_left = j; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 6 bits into outputBuffer insert 6 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_6_bits(_data) \ #define insert_6_bits(_data) \
do \ do \
{ \
if ((bits_left >= 7) && (bits_left <= 8)) \
{ \ { \
i = bits_left - 6; \ if ((bits_left >= 7) && (bits_left <= 8)) \
outputBuffer[opb_index] |= (_data << i); \ { \
bits_left = i; \ i = bits_left - 6; \
} \ outputBuffer[opb_index] |= (_data << i); \
else \ bits_left = i; \
{ \ } \
i = 6 - bits_left; \ else \
j = 8 - i; \ { \
outputBuffer[opb_index++] |= (_data >> i); \ i = 6 - bits_left; \
outputBuffer[opb_index] |= (_data << j); \ j = 8 - i; \
bits_left = j; \ outputBuffer[opb_index++] |= (_data >> i); \
} \ outputBuffer[opb_index] |= (_data << j); \
} while (0) bits_left = j; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 7 bits into outputBuffer insert 7 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_7_bits(_data) \ #define insert_7_bits(_data) \
do \ do \
{ \
if (bits_left == 8) \
{ \ { \
outputBuffer[opb_index] |= _data << 1; \ if (bits_left == 8) \
bits_left = 1; \ { \
} \ outputBuffer[opb_index] |= _data << 1; \
else \ bits_left = 1; \
{ \ } \
i = 7 - bits_left; \ else \
j = 8 - i; \ { \
outputBuffer[opb_index++] |= _data >> i; \ i = 7 - bits_left; \
outputBuffer[opb_index] |= _data << j; \ j = 8 - i; \
bits_left = j; \ outputBuffer[opb_index++] |= _data >> i; \
} \ outputBuffer[opb_index] |= _data << j; \
} while (0) bits_left = j; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 8 bits into outputBuffer insert 8 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_8_bits(_data) \ #define insert_8_bits(_data) \
do \ do \
{ \
if (bits_left == 8) \
{ \ { \
outputBuffer[opb_index++] |= _data; \ if (bits_left == 8) \
bits_left = 8; \ { \
} \ outputBuffer[opb_index++] |= _data; \
else \ bits_left = 8; \
{ \ } \
i = 8 - bits_left; \ else \
j = 8 - i; \ { \
outputBuffer[opb_index++] |= _data >> i; \ i = 8 - bits_left; \
outputBuffer[opb_index] |= _data << j; \ j = 8 - i; \
bits_left = j; \ outputBuffer[opb_index++] |= _data >> i; \
} \ outputBuffer[opb_index] |= _data << j; \
} while (0) bits_left = j; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 9 bits into outputBuffer insert 9 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_9_bits(_data16) \ #define insert_9_bits(_data16) \
do \ do \
{ \
i = 9 - bits_left; \
j = 8 - i; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \
outputBuffer[opb_index] |= (char) (_data16 << j); \
bits_left = j; \
if (bits_left == 0) \
{ \ { \
opb_index++; \ i = 9 - bits_left; \
bits_left = 8; \ j = 8 - i; \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
} while (0) outputBuffer[opb_index] |= (char) (_data16 << j); \
bits_left = j; \
if (bits_left == 0) \
{ \
opb_index++; \
bits_left = 8; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 10 bits into outputBuffer insert 10 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_10_bits(_data16) \ #define insert_10_bits(_data16) \
do \ do \
{ \
i = 10 - bits_left; \
if ((bits_left >= 3) && (bits_left <= 8)) \
{ \ { \
j = 8 - i; \ i = 10 - bits_left; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ if ((bits_left >= 3) && (bits_left <= 8)) \
outputBuffer[opb_index] |= (char) (_data16 << j); \ { \
bits_left = j; \ j = 8 - i; \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
else \ outputBuffer[opb_index] |= (char) (_data16 << j); \
{ \ bits_left = j; \
j = i - 8; \ } \
k = 8 - j; \ else \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ { \
outputBuffer[opb_index++] |= (char) (_data16 >> j); \ j = i - 8; \
outputBuffer[opb_index] |= (char) (_data16 << k); \ k = 8 - j; \
bits_left = k; \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> j); \
} while (0) outputBuffer[opb_index] |= (char) (_data16 << k); \
bits_left = k; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 11 bits into outputBuffer insert 11 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_11_bits(_data16) \ #define insert_11_bits(_data16) \
do \ do \
{ \
i = 11 - bits_left; \
if ((bits_left >= 4) && (bits_left <= 8)) \
{ \ { \
j = 8 - i; \ i = 11 - bits_left; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ if ((bits_left >= 4) && (bits_left <= 8)) \
outputBuffer[opb_index] |= (char) (_data16 << j); \ { \
bits_left = j; \ j = 8 - i; \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
else \ outputBuffer[opb_index] |= (char) (_data16 << j); \
{ \ bits_left = j; \
j = i - 8; \ } \
k = 8 - j; \ else \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ { \
outputBuffer[opb_index++] |= (char) (_data16 >> j); \ j = i - 8; \
outputBuffer[opb_index] |= (char) (_data16 << k); \ k = 8 - j; \
bits_left = k; \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> j); \
} while (0) outputBuffer[opb_index] |= (char) (_data16 << k); \
bits_left = k; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 12 bits into outputBuffer insert 12 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_12_bits(_data16) \ #define insert_12_bits(_data16) \
do \ do \
{ \
i = 12 - bits_left; \
if ((bits_left >= 5) && (bits_left <= 8)) \
{ \ { \
j = 8 - i; \ i = 12 - bits_left; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ if ((bits_left >= 5) && (bits_left <= 8)) \
outputBuffer[opb_index] |= (char) (_data16 << j); \ { \
bits_left = j; \ j = 8 - i; \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
else \ outputBuffer[opb_index] |= (char) (_data16 << j); \
{ \ bits_left = j; \
j = i - 8; \ } \
k = 8 - j; \ else \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ { \
outputBuffer[opb_index++] |= (char) (_data16 >> j); \ j = i - 8; \
outputBuffer[opb_index] |= (char) (_data16 << k); \ k = 8 - j; \
bits_left = k; \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> j); \
} while (0) outputBuffer[opb_index] |= (char) (_data16 << k); \
bits_left = k; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 13 bits into outputBuffer insert 13 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_13_bits(_data16) \ #define insert_13_bits(_data16) \
do \ do \
{ \
i = 13 - bits_left; \
if ((bits_left >= 6) && (bits_left <= 8)) \
{ \ { \
j = 8 - i; \ i = 13 - bits_left; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ if ((bits_left >= 6) && (bits_left <= 8)) \
outputBuffer[opb_index] |= (char) (_data16 << j); \ { \
bits_left = j; \ j = 8 - i; \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
else \ outputBuffer[opb_index] |= (char) (_data16 << j); \
{ \ bits_left = j; \
j = i - 8; \ } \
k = 8 - j; \ else \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ { \
outputBuffer[opb_index++] |= (char) (_data16 >> j); \ j = i - 8; \
outputBuffer[opb_index] |= (char) (_data16 << k); \ k = 8 - j; \
bits_left = k; \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> j); \
} while (0) outputBuffer[opb_index] |= (char) (_data16 << k); \
bits_left = k; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 14 bits into outputBuffer insert 14 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_14_bits(_data16) \ #define insert_14_bits(_data16) \
do \ do \
{ \
i = 14 - bits_left; \
if ((bits_left >= 7) && (bits_left <= 8)) \
{ \ { \
j = 8 - i; \ i = 14 - bits_left; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ if ((bits_left >= 7) && (bits_left <= 8)) \
outputBuffer[opb_index] |= (char) (_data16 << j); \ { \
bits_left = j; \ j = 8 - i; \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
else \ outputBuffer[opb_index] |= (char) (_data16 << j); \
{ \ bits_left = j; \
j = i - 8; \ } \
k = 8 - j; \ else \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ { \
outputBuffer[opb_index++] |= (char) (_data16 >> j); \ j = i - 8; \
outputBuffer[opb_index] |= (char) (_data16 << k); \ k = 8 - j; \
bits_left = k; \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> j); \
} while (0) outputBuffer[opb_index] |= (char) (_data16 << k); \
bits_left = k; \
} \
} while (0)
/***************************************************************************** /*****************************************************************************
insert 15 bits into outputBuffer insert 15 bits into outputBuffer
******************************************************************************/ ******************************************************************************/
#define insert_15_bits(_data16) \ #define insert_15_bits(_data16) \
do \ do \
{ \
i = 15 - bits_left; \
if (bits_left == 8) \
{ \ { \
j = 8 - i; \ i = 15 - bits_left; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ if (bits_left == 8) \
outputBuffer[opb_index] |= (char) (_data16 << j); \ { \
bits_left = j; \ j = 8 - i; \
} \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
else \ outputBuffer[opb_index] |= (char) (_data16 << j); \
bits_left = j; \
} \
else \
{ \
j = i - 8; \
k = 8 - j; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \
outputBuffer[opb_index++] |= (char) (_data16 >> j); \
outputBuffer[opb_index] |= (char) (_data16 << k); \
bits_left = k; \
} \
} while (0)
/*****************************************************************************
insert 16 bits into outputBuffer
******************************************************************************/
#define insert_16_bits(_data16) \
do \
{ \ { \
i = 16 - bits_left; \
j = i - 8; \ j = i - 8; \
k = 8 - j; \ k = 8 - j; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \ outputBuffer[opb_index++] |= (char) (_data16 >> i); \
outputBuffer[opb_index++] |= (char) (_data16 >> j); \ outputBuffer[opb_index++] |= (char) (_data16 >> j); \
outputBuffer[opb_index] |= (char) (_data16 << k); \ outputBuffer[opb_index] |= (char) (_data16 << k); \
bits_left = k; \ bits_left = k; \
} \ } while (0)
} while (0)
/*****************************************************************************
insert 16 bits into outputBuffer
******************************************************************************/
#define insert_16_bits(_data16) \
do \
{ \
i = 16 - bits_left; \
j = i - 8; \
k = 8 - j; \
outputBuffer[opb_index++] |= (char) (_data16 >> i); \
outputBuffer[opb_index++] |= (char) (_data16 >> j); \
outputBuffer[opb_index] |= (char) (_data16 << k); \
bits_left = k; \
} while (0)
/** /**
* Initialize mppc_enc structure * Initialize mppc_enc structure
@ -606,7 +598,7 @@ compress_rdp_5(struct xrdp_mppc_enc *enc, tui8 *srcData, int len)
for (x = 0; x < 2; x++) for (x = 0; x < 2; x++)
{ {
data = *(historyPointer + x); data = *(historyPointer + x);
DLOG(("%.2x ", (tui8) data)); LOG_DEVEL(LOG_LEVEL_TRACE, "%.2x ", (tui8) data);
if (data & 0x80) if (data & 0x80)
{ {
/* insert encoded literal */ /* insert encoded literal */
@ -678,13 +670,13 @@ compress_rdp_5(struct xrdp_mppc_enc *enc, tui8 *srcData, int len)
/* double check that we have a pattern match */ /* double check that we have a pattern match */
if ((*cptr1 != *cptr2) || if ((*cptr1 != *cptr2) ||
(*(cptr1 + 1) != *(cptr2 + 1)) || (*(cptr1 + 1) != *(cptr2 + 1)) ||
(*(cptr1 + 2) != *(cptr2 + 2))) (*(cptr1 + 2) != *(cptr2 + 2)))
{ {
/* no match found; encode literal byte */ /* no match found; encode literal byte */
data = *cptr1; data = *cptr1;
DLOG(("%.2x ", data)); LOG_DEVEL(LOG_LEVEL_TRACE, "%.2x ", data);
if (data < 0x80) if (data < 0x80)
{ {
/* literal byte < 0x80 */ /* literal byte < 0x80 */
@ -710,8 +702,8 @@ compress_rdp_5(struct xrdp_mppc_enc *enc, tui8 *srcData, int len)
lom++; lom++;
} }
saved_ctr = ctr + lom; saved_ctr = ctr + lom;
DLOG(("<%d: %ld,%d> ", (historyPointer + ctr) - hbuf_start, LOG_DEVEL(LOG_LEVEL_TRACE, "<%ld: %u,%d> ", (historyPointer + ctr) - hbuf_start,
copy_offset, lom)); copy_offset, lom);
/* compute CRC for matching segment and store in hash table */ /* compute CRC for matching segment and store in hash table */
@ -951,7 +943,7 @@ compress_rdp_5(struct xrdp_mppc_enc *enc, tui8 *srcData, int len)
while (len - ctr > 0) while (len - ctr > 0)
{ {
data = srcData[ctr]; data = srcData[ctr];
DLOG(("%.2x ", data)); LOG_DEVEL(LOG_LEVEL_TRACE, "%.2x ", data);
if (data < 0x80) if (data < 0x80)
{ {
/* literal byte < 0x80 */ /* literal byte < 0x80 */
@ -990,9 +982,9 @@ compress_rdp_5(struct xrdp_mppc_enc *enc, tui8 *srcData, int len)
enc->flags |= enc->flagsHold; enc->flags |= enc->flagsHold;
enc->flagsHold = 0; enc->flagsHold = 0;
DLOG(("\n")); LOG_DEVEL(LOG_LEVEL_TRACE, "\n");
//g_writeln("compression ratio: %f", (float) len / (float) enc->bytes_in_opb); LOG_DEVEL(LOG_LEVEL_TRACE, "compression ratio: %f", (float) len / (float) enc->bytes_in_opb);
return 1; return 1;
} }

76
libxrdp/xrdp_orders.c
View File

@ -30,15 +30,7 @@
#include <freerdp/codec/rfx.h> #include <freerdp/codec/rfx.h>
#endif #endif
#define LLOG_LEVEL 2
#define LLOGLN(_log_level, _params) \
{ \
if (_log_level < LLOG_LEVEL) \
{ \
g_write("xrdp_orders.c [%10.10u]: ", g_time3()); \
g_writeln _params ; \
} \
}
#define MAX_ORDERS_SIZE(_client_info) \ #define MAX_ORDERS_SIZE(_client_info) \
(MAX((_client_info)->max_fastpath_frag_bytes, 16 * 1024) - 256); (MAX((_client_info)->max_fastpath_frag_bytes, 16 * 1024) - 256);
@ -114,7 +106,7 @@ xrdp_orders_init(struct xrdp_orders *self)
self->order_count = 0; self->order_count = 0;
if (self->rdp_layer->client_info.use_fast_path & 1) if (self->rdp_layer->client_info.use_fast_path & 1)
{ {
LLOGLN(10, ("xrdp_orders_init: fastpath")); LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_orders_init: fastpath");
if (xrdp_rdp_init_fastpath(self->rdp_layer, self->out_s) != 0) if (xrdp_rdp_init_fastpath(self->rdp_layer, self->out_s) != 0)
{ {
return 1; return 1;
@ -124,7 +116,7 @@ xrdp_orders_init(struct xrdp_orders *self)
} }
else else
{ {
LLOGLN(10, ("xrdp_orders_init: slowpath")); LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_orders_init: slowpath");
if (xrdp_rdp_init_data(self->rdp_layer, self->out_s) != 0) if (xrdp_rdp_init_data(self->rdp_layer, self->out_s) != 0)
{ {
return 1; return 1;
@ -153,7 +145,7 @@ xrdp_orders_send(struct xrdp_orders *self)
if ((self->order_level == 0) && (self->order_count > 0)) if ((self->order_level == 0) && (self->order_count > 0))
{ {
s_mark_end(self->out_s); s_mark_end(self->out_s);
DEBUG(("xrdp_orders_send sending %d orders", self->order_count)); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_orders_send sending %d orders", self->order_count);
self->order_count_ptr[0] = self->order_count; self->order_count_ptr[0] = self->order_count;
self->order_count_ptr[1] = self->order_count >> 8; self->order_count_ptr[1] = self->order_count >> 8;
self->order_count = 0; self->order_count = 0;
@ -190,7 +182,7 @@ xrdp_orders_force_send(struct xrdp_orders *self)
if ((self->order_level > 0) && (self->order_count > 0)) if ((self->order_level > 0) && (self->order_count > 0))
{ {
s_mark_end(self->out_s); s_mark_end(self->out_s);
DEBUG(("xrdp_orders_force_send sending %d orders", self->order_count)); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_orders_force_send sending %d orders", self->order_count);
self->order_count_ptr[0] = self->order_count; self->order_count_ptr[0] = self->order_count;
self->order_count_ptr[1] = self->order_count >> 8; self->order_count_ptr[1] = self->order_count >> 8;
if (self->rdp_layer->client_info.use_fast_path & 1) if (self->rdp_layer->client_info.use_fast_path & 1)
@ -245,7 +237,7 @@ xrdp_orders_check(struct xrdp_orders *self, int max_size)
size = (int)(self->out_s->p - self->order_count_ptr); size = (int)(self->out_s->p - self->order_count_ptr);
if (size < 0) if (size < 0)
{ {
g_writeln("error in xrdp_orders_check, size too small: %d bytes", size); LOG(LOG_LEVEL_ERROR, "error in xrdp_orders_check, size too small: %d bytes", size);
return 1; return 1;
} }
if (size > max_order_size) if (size > max_order_size)
@ -253,7 +245,7 @@ xrdp_orders_check(struct xrdp_orders *self, int max_size)
/* this suggests someone calls this function without passing the /* this suggests someone calls this function without passing the
correct max_size so we end up putting more into the buffer correct max_size so we end up putting more into the buffer
than we indicate we can */ than we indicate we can */
g_writeln("error in xrdp_orders_check, size too big: %d bytes", size); LOG(LOG_LEVEL_WARNING, "error in xrdp_orders_check, size too big: %d bytes", size);
/* We where getting called with size already greater than /* We where getting called with size already greater than
max_order_size max_order_size
Which I suspect was because the sending of text did not include Which I suspect was because the sending of text did not include
@ -1648,20 +1640,20 @@ xrdp_orders_mem_blt(struct xrdp_orders *self, int cache_id,
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int int
xrdp_orders_composite_blt(struct xrdp_orders* self, int srcidx, int srcformat, xrdp_orders_composite_blt(struct xrdp_orders *self, int srcidx, int srcformat,
int srcwidth, int srcrepeat, int* srctransform, int srcwidth, int srcrepeat, int *srctransform,
int mskflags, int mskidx, int mskformat, int mskflags, int mskidx, int mskformat,
int mskwidth, int mskrepeat, int op, int mskwidth, int mskrepeat, int op,
int srcx, int srcy, int mskx, int msky, int srcx, int srcy, int mskx, int msky,
int dstx, int dsty, int width, int height, int dstx, int dsty, int width, int height,
int dstformat, int dstformat,
struct xrdp_rect* rect) struct xrdp_rect *rect)
{ {
int order_flags; int order_flags;
int vals[20]; int vals[20];
int present; int present;
char* present_ptr; char *present_ptr;
char* order_flags_ptr; char *order_flags_ptr;
if (xrdp_orders_check(self, 80) != 0) if (xrdp_orders_check(self, 80) != 0)
{ {
@ -1678,7 +1670,7 @@ xrdp_orders_composite_blt(struct xrdp_orders* self, int srcidx, int srcformat,
{ {
/* if clip is present, still check if it's needed */ /* if clip is present, still check if it's needed */
if (dstx < rect->left || dsty < rect->top || if (dstx < rect->left || dsty < rect->top ||
dstx + width > rect->right || dsty + height > rect->bottom) dstx + width > rect->right || dsty + height > rect->bottom)
{ {
order_flags |= TS_BOUNDS; order_flags |= TS_BOUNDS;
if (xrdp_orders_last_bounds(self, rect)) if (xrdp_orders_last_bounds(self, rect))
@ -1725,7 +1717,7 @@ xrdp_orders_composite_blt(struct xrdp_orders* self, int srcidx, int srcformat,
present_ptr = self->out_s->p; present_ptr = self->out_s->p;
out_uint8s(self->out_s, 3); out_uint8s(self->out_s, 3);
if ((order_flags & TS_BOUNDS) && if ((order_flags & TS_BOUNDS) &&
!(order_flags & TS_ZERO_BOUNDS_DELTAS)) !(order_flags & TS_ZERO_BOUNDS_DELTAS))
{ {
xrdp_orders_out_bounds(self, rect); xrdp_orders_out_bounds(self, rect);
} }
@ -2227,13 +2219,13 @@ xrdp_orders_send_raw_bitmap(struct xrdp_orders *self,
if (width > 64) if (width > 64)
{ {
g_writeln("error, width > 64"); LOG(LOG_LEVEL_ERROR, "error, width > 64");
return 1; return 1;
} }
if (height > 64) if (height > 64)
{ {
g_writeln("error, height > 64"); LOG(LOG_LEVEL_ERROR, "error, height > 64");
return 1; return 1;
} }
@ -2353,13 +2345,13 @@ xrdp_orders_send_bitmap(struct xrdp_orders *self,
if (width > 64) if (width > 64)
{ {
g_writeln("error, width > 64"); LOG(LOG_LEVEL_ERROR, "error, width > 64");
return 1; return 1;
} }
if (height > 64) if (height > 64)
{ {
g_writeln("error, height > 64"); LOG(LOG_LEVEL_ERROR, "error, height > 64");
return 1; return 1;
} }
@ -2490,7 +2482,7 @@ xrdp_orders_cache_glyph(struct xrdp_orders *self,
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
static int write_2byte_signed(struct stream * s, int value) static int write_2byte_signed(struct stream *s, int value)
{ {
unsigned char byte; unsigned char byte;
int negative = 0; int negative = 0;
@ -2536,7 +2528,7 @@ static int write_2byte_signed(struct stream * s, int value)
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
static int write_2byte_unsigned(struct stream * s, unsigned int value) static int write_2byte_unsigned(struct stream *s, unsigned int value)
{ {
unsigned char byte; unsigned char byte;
@ -2602,9 +2594,9 @@ xrdp_orders_cache_glyph_v2(struct xrdp_orders *self,
out_uint8(self->out_s, char_index); out_uint8(self->out_s, char_index);
if (write_2byte_signed(self->out_s, font_char->offset) || if (write_2byte_signed(self->out_s, font_char->offset) ||
write_2byte_signed(self->out_s, font_char->baseline) || write_2byte_signed(self->out_s, font_char->baseline) ||
write_2byte_unsigned(self->out_s, font_char->width) || write_2byte_unsigned(self->out_s, font_char->width) ||
write_2byte_unsigned(self->out_s, font_char->height)) write_2byte_unsigned(self->out_s, font_char->height))
{ {
return 1; return 1;
} }
@ -2653,13 +2645,13 @@ xrdp_orders_send_raw_bitmap2(struct xrdp_orders *self,
if (width > 64) if (width > 64)
{ {
g_writeln("error, width > 64"); LOG(LOG_LEVEL_ERROR, "error, width > 64");
return 1; return 1;
} }
if (height > 64) if (height > 64)
{ {
g_writeln("error, height > 64"); LOG(LOG_LEVEL_ERROR, "error, height > 64");
return 1; return 1;
} }
@ -2781,13 +2773,13 @@ xrdp_orders_send_bitmap2(struct xrdp_orders *self,
if (width > 64) if (width > 64)
{ {
g_writeln("error, width > 64"); LOG(LOG_LEVEL_ERROR, "error, width > 64");
return 1; return 1;
} }
if (height > 64) if (height > 64)
{ {
g_writeln("error, height > 64"); LOG(LOG_LEVEL_ERROR, "error, height > 64");
return 1; return 1;
} }
@ -2894,8 +2886,8 @@ xrdp_orders_send_as_rfx(struct xrdp_orders *self,
return 0; return 0;
} }
LLOGLN(10, ("width %d height %d rfx_min_pixel %d", width, height, LOG_DEVEL(LOG_LEVEL_DEBUG, "width %d height %d rfx_min_pixel %d", width, height,
self->rfx_min_pixel)); self->rfx_min_pixel);
if (width * height < self->rfx_min_pixel) if (width * height < self->rfx_min_pixel)
{ {
return 0; return 0;
@ -2987,7 +2979,7 @@ xrdp_orders_send_bitmap3(struct xrdp_orders *self,
return 2; return 2;
} }
LLOGLN(10, ("xrdp_orders_send_bitmap3: rfx")); LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_orders_send_bitmap3: rfx");
context = (RFX_CONTEXT *)(self->rdp_layer->rfx_enc); context = (RFX_CONTEXT *)(self->rdp_layer->rfx_enc);
make_stream(xr_s); make_stream(xr_s);
init_stream(xr_s, 16384); init_stream(xr_s, 16384);
@ -3016,11 +3008,11 @@ xrdp_orders_send_bitmap3(struct xrdp_orders *self,
if (!xrdp_orders_send_as_jpeg(self, width, height, bpp, hints)) if (!xrdp_orders_send_as_jpeg(self, width, height, bpp, hints))
{ {
LLOGLN(10, ("xrdp_orders_send_bitmap3: jpeg skipped")); LOG(LOG_LEVEL_ERROR, "xrdp_orders_send_bitmap3: jpeg skipped");
return 2; return 2;
} }
LLOGLN(10, ("xrdp_orders_send_bitmap3: jpeg")); LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_orders_send_bitmap3: jpeg");
e = width % 4; e = width % 4;
if (e != 0) if (e != 0)
@ -3048,7 +3040,7 @@ xrdp_orders_send_bitmap3(struct xrdp_orders *self,
} }
else else
{ {
g_writeln("xrdp_orders_send_bitmap3: todo unknown codec"); LOG(LOG_LEVEL_ERROR, "xrdp_orders_send_bitmap3: todo unknown codec");
return 1; return 1;
} }
@ -3119,7 +3111,7 @@ xrdp_orders_send_create_os_surface(struct xrdp_orders *self, int id,
order_flags |= 1 << 2; /* type RDP_ORDER_ALTSEC_CREATE_OFFSCR_BITMAP */ order_flags |= 1 << 2; /* type RDP_ORDER_ALTSEC_CREATE_OFFSCR_BITMAP */
out_uint8(self->out_s, order_flags); out_uint8(self->out_s, order_flags);
cache_id = id & 0x7fff; cache_id = id & 0x7fff;
LLOGLN(10, ("xrdp_orders_send_create_os_surface: cache_id %d", cache_id)); LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_orders_send_create_os_surface: cache_id %d", cache_id);
flags = cache_id; flags = cache_id;
if (num_del_list > 0) if (num_del_list > 0)

258
libxrdp/xrdp_rdp.c
View File

@ -33,11 +33,7 @@
#include <freerdp/constants.h> #include <freerdp/constants.h>
#endif #endif
#define LOG_LEVEL 1
#define LLOG(_level, _args) \
do { if (_level < LOG_LEVEL) { g_write _args ; } } while (0)
#define LLOGLN(_level, _args) \
do { if (_level < LOG_LEVEL) { g_writeln _args ; } } while (0)
#define FASTPATH_FRAG_SIZE (16 * 1024 - 128) #define FASTPATH_FRAG_SIZE (16 * 1024 - 128)
@ -59,14 +55,14 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
items->auto_free = 1; items->auto_free = 1;
values = list_create(); values = list_create();
values->auto_free = 1; values->auto_free = 1;
DEBUG(("xrdp_ini %s", xrdp_ini)); LOG_DEVEL(LOG_LEVEL_TRACE, "cfg_file %s", xrdp_ini);
file_by_name_read_section(xrdp_ini, "globals", items, values); file_by_name_read_section(xrdp_ini, "globals", items, values);
for (index = 0; index < items->count; index++) for (index = 0; index < items->count; index++)
{ {
item = (char *)list_get_item(items, index); item = (char *)list_get_item(items, index);
value = (char *)list_get_item(values, index); value = (char *)list_get_item(values, index);
DEBUG(("item %s value %s", item, value)); LOG_DEVEL(LOG_LEVEL_TRACE, "item %s value %s", item, value);
if (g_strcasecmp(item, "bitmap_cache") == 0) if (g_strcasecmp(item, "bitmap_cache") == 0)
{ {
@ -104,8 +100,8 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
} }
else else
{ {
log_message(LOG_LEVEL_ALWAYS,"Warning: Your configured crypt level is " LOG(LOG_LEVEL_ALWAYS, "Warning: Your configured crypt level is "
"undefined, 'high' will be used"); "undefined, 'high' will be used");
client_info->crypt_level = 3; client_info->crypt_level = 3;
} }
} }
@ -114,17 +110,17 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
client_info->channels_allowed = g_text2bool(value); client_info->channels_allowed = g_text2bool(value);
if (client_info->channels_allowed == 0) if (client_info->channels_allowed == 0)
{ {
log_message(LOG_LEVEL_DEBUG,"Info - All channels are disabled"); LOG(LOG_LEVEL_DEBUG, "Info - All channels are disabled");
} }
} }
else if (g_strcasecmp(item, "allow_multimon") == 0) else if (g_strcasecmp(item, "allow_multimon") == 0)
{ {
client_info->multimon = g_text2bool(value); client_info->multimon = g_text2bool(value);
if (client_info->multimon == 0) if (client_info->multimon == 0)
{ {
log_message(LOG_LEVEL_DEBUG,"Info - Multi monitor server support disabled"); LOG(LOG_LEVEL_DEBUG, "Info - Multi monitor server support disabled");
} }
} }
else if (g_strcasecmp(item, "max_bpp") == 0) else if (g_strcasecmp(item, "max_bpp") == 0)
{ {
client_info->max_bpp = g_atoi(value); client_info->max_bpp = g_atoi(value);
@ -165,8 +161,8 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
} }
else else
{ {
log_message(LOG_LEVEL_ALWAYS,"Warning: Your configured fastpath level is " LOG(LOG_LEVEL_ALWAYS, "Warning: Your configured fastpath level is "
"undefined, fastpath will not be used"); "undefined, fastpath will not be used");
client_info->use_fast_path = 0; client_info->use_fast_path = 0;
} }
} }
@ -209,9 +205,9 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
} }
else else
{ {
log_message(LOG_LEVEL_ERROR, "security_layer=%s is not " LOG(LOG_LEVEL_ERROR, "security_layer=%s is not "
"recognized, will use security_layer=negotiate", "recognized, will use security_layer=negotiate",
value); value);
client_info->security_layer = PROTOCOL_SSL | PROTOCOL_HYBRID | PROTOCOL_HYBRID_EX; client_info->security_layer = PROTOCOL_SSL | PROTOCOL_HYBRID | PROTOCOL_HYBRID_EX;
} }
} }
@ -222,18 +218,18 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
{ {
/* default certificate path */ /* default certificate path */
g_snprintf(client_info->certificate, 1023, "%s/cert.pem", XRDP_CFG_PATH); g_snprintf(client_info->certificate, 1023, "%s/cert.pem", XRDP_CFG_PATH);
log_message(LOG_LEVEL_INFO, LOG(LOG_LEVEL_INFO,
"Using default X.509 certificate: %s", "Using default X.509 certificate: %s",
client_info->certificate); client_info->certificate);
} }
else if (value[0] != '/') else if (value[0] != '/')
{ {
/* default certificate path */ /* default certificate path */
g_snprintf(client_info->certificate, 1023, "%s/cert.pem", XRDP_CFG_PATH); g_snprintf(client_info->certificate, 1023, "%s/cert.pem", XRDP_CFG_PATH);
log_message(LOG_LEVEL_WARNING, LOG(LOG_LEVEL_WARNING,
"X.509 certificate should use absolute path, using " "X.509 certificate should use absolute path, using "
"default instead: %s", client_info->certificate); "default instead: %s", client_info->certificate);
} }
else else
{ {
@ -241,10 +237,10 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
g_strncpy(client_info->certificate, value, 1023); g_strncpy(client_info->certificate, value, 1023);
} }
if (!g_file_readable(client_info->certificate)) if (!g_file_readable(client_info->certificate))
{ {
log_message(LOG_LEVEL_ERROR, "Cannot read certificate file %s: %s", LOG(LOG_LEVEL_ERROR, "Cannot read certificate file %s: %s",
client_info->certificate, g_get_strerror()); client_info->certificate, g_get_strerror());
} }
} }
else if (g_strcasecmp(item, "key_file") == 0) else if (g_strcasecmp(item, "key_file") == 0)
@ -254,16 +250,16 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
{ {
/* default key_file path */ /* default key_file path */
g_snprintf(client_info->key_file, 1023, "%s/key.pem", XRDP_CFG_PATH); g_snprintf(client_info->key_file, 1023, "%s/key.pem", XRDP_CFG_PATH);
log_message(LOG_LEVEL_INFO, "Using default X.509 key file: %s", LOG(LOG_LEVEL_INFO, "Using default X.509 key file: %s",
client_info->key_file); client_info->key_file);
} }
else if (value[0] != '/') else if (value[0] != '/')
{ {
/* default key_file path */ /* default key_file path */
g_snprintf(client_info->key_file, 1023, "%s/key.pem", XRDP_CFG_PATH); g_snprintf(client_info->key_file, 1023, "%s/key.pem", XRDP_CFG_PATH);
log_message(LOG_LEVEL_WARNING, LOG(LOG_LEVEL_WARNING,
"X.509 key file should use absolute path, using " "X.509 key file should use absolute path, using "
"default instead: %s", client_info->key_file); "default instead: %s", client_info->key_file);
} }
else else
{ {
@ -273,8 +269,8 @@ xrdp_rdp_read_config(const char *xrdp_ini, struct xrdp_client_info *client_info)
if (!g_file_readable(client_info->key_file)) if (!g_file_readable(client_info->key_file))
{ {
log_message(LOG_LEVEL_ERROR, "Cannot read private key file %s: %s", LOG(LOG_LEVEL_ERROR, "Cannot read private key file %s: %s",
client_info->key_file, g_get_strerror()); client_info->key_file, g_get_strerror());
} }
} }
else if (g_strcasecmp(item, "domain_user_separator") == 0 else if (g_strcasecmp(item, "domain_user_separator") == 0
@ -309,9 +305,9 @@ cpuid(tui32 info, tui32 *eax, tui32 *ebx, tui32 *ecx, tui32 *edx)
"cpuid;" "cpuid;"
"xchg %%rbx, %%rsi;" "xchg %%rbx, %%rsi;"
#endif #endif
: "=a" (*eax), "=S" (*ebx), "=c" (*ecx), "=d" (*edx) : "=a" (*eax), "=S" (*ebx), "=c" (*ecx), "=d" (*edx)
: "0" (info) : "0" (info)
); );
#endif #endif
#endif #endif
} }
@ -335,7 +331,7 @@ xrdp_rdp_detect_cpu(void)
if (edx & (1 << 26)) if (edx & (1 << 26))
{ {
DEBUG(("SSE2 detected")); LOG_DEVEL(LOG_LEVEL_TRACE, "SSE2 detected");
cpu_opt |= CPU_SSE2; cpu_opt |= CPU_SSE2;
} }
@ -350,7 +346,7 @@ xrdp_rdp_create(struct xrdp_session *session, struct trans *trans)
struct xrdp_rdp *self = (struct xrdp_rdp *)NULL; struct xrdp_rdp *self = (struct xrdp_rdp *)NULL;
int bytes; int bytes;
DEBUG(("in xrdp_rdp_create")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_create");
self = (struct xrdp_rdp *)g_malloc(sizeof(struct xrdp_rdp), 1); self = (struct xrdp_rdp *)g_malloc(sizeof(struct xrdp_rdp), 1);
self->session = session; self->session = session;
self->share_id = 66538; self->share_id = 66538;
@ -374,7 +370,7 @@ xrdp_rdp_create(struct xrdp_session *session, struct trans *trans)
rfx_context_set_cpu_opt(self->rfx_enc, xrdp_rdp_detect_cpu()); rfx_context_set_cpu_opt(self->rfx_enc, xrdp_rdp_detect_cpu());
#endif #endif
self->client_info.size = sizeof(self->client_info); self->client_info.size = sizeof(self->client_info);
DEBUG(("out xrdp_rdp_create")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_create");
return self; return self;
} }
@ -433,7 +429,7 @@ xrdp_rdp_recv(struct xrdp_rdp *self, struct stream *s, int *code)
int chan = 0; int chan = 0;
const tui8 *header; const tui8 *header;
DEBUG(("in xrdp_rdp_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_recv");
if (s->next_packet == 0 || s->next_packet >= s->end) if (s->next_packet == 0 || s->next_packet >= s->end)
{ {
/* check for fastpath first */ /* check for fastpath first */
@ -446,7 +442,7 @@ xrdp_rdp_recv(struct xrdp_rdp *self, struct stream *s, int *code)
} }
/* next_packet gets set in xrdp_sec_recv_fastpath */ /* next_packet gets set in xrdp_sec_recv_fastpath */
*code = 2; // special code for fastpath input *code = 2; // special code for fastpath input
DEBUG(("out (fastpath) xrdp_rdp_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, "out (fastpath) xrdp_rdp_recv");
return 0; return 0;
} }
@ -458,14 +454,13 @@ xrdp_rdp_recv(struct xrdp_rdp *self, struct stream *s, int *code)
{ {
s->next_packet = 0; s->next_packet = 0;
*code = -1; *code = -1;
DEBUG(("out (1) xrdp_rdp_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, "out (1) xrdp_rdp_recv");
return 0; return 0;
} }
if (error != 0) if (error != 0)
{ {
DEBUG(("out xrdp_rdp_recv error")); LOG(LOG_LEVEL_ERROR, "out xrdp_rdp_recv error");
g_writeln("xrdp_rdp_recv: xrdp_sec_recv failed");
return 1; return 1;
} }
@ -475,20 +470,20 @@ xrdp_rdp_recv(struct xrdp_rdp *self, struct stream *s, int *code)
{ {
if (xrdp_channel_process(self->sec_layer->chan_layer, s, chan) != 0) if (xrdp_channel_process(self->sec_layer->chan_layer, s, chan) != 0)
{ {
g_writeln("xrdp_channel_process returned unhandled error") ; LOG(LOG_LEVEL_ERROR, "xrdp_channel_process returned unhandled error") ;
} }
} }
else else
{ {
if (chan != 1) if (chan != 1)
{ {
g_writeln("Wrong channel Id to be handled by xrdp_channel_process %d", chan); LOG(LOG_LEVEL_ERROR, "Wrong channel Id to be handled by xrdp_channel_process %d", chan);
} }
} }
s->next_packet = 0; s->next_packet = 0;
*code = 0; *code = 0;
DEBUG(("out (2) xrdp_rdp_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, "out (2) xrdp_rdp_recv");
return 0; return 0;
} }
@ -496,7 +491,7 @@ xrdp_rdp_recv(struct xrdp_rdp *self, struct stream *s, int *code)
} }
else else
{ {
DEBUG(("xrdp_rdp_recv stream not touched")) LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_recv stream not touched");
s->p = s->next_packet; s->p = s->next_packet;
} }
@ -504,20 +499,19 @@ xrdp_rdp_recv(struct xrdp_rdp *self, struct stream *s, int *code)
{ {
s->next_packet = 0; s->next_packet = 0;
*code = 0; *code = 0;
DEBUG(("out (3) xrdp_rdp_recv"));
len = (int)(s->end - s->p); len = (int)(s->end - s->p);
g_writeln("xrdp_rdp_recv: bad RDP packet, length [%d]", len); LOG_DEVEL(LOG_LEVEL_TRACE, "out (3) xrdp_rdp_recv: bad RDP packet, length [%d]", len);
return 0; return 0;
} }
else else
{ {
in_uint16_le(s, len); in_uint16_le(s, len);
/*g_writeln("New len received : %d next packet: %d s_end: %d",len,s->next_packet,s->end); */ /*LOG_DEVEL(LOG_LEVEL_TRACE, "New len received : %d next packet: %d s_end: %d",len,s->next_packet,s->end); */
in_uint16_le(s, pdu_code); in_uint16_le(s, pdu_code);
*code = pdu_code & 0xf; *code = pdu_code & 0xf;
in_uint8s(s, 2); /* mcs user id */ in_uint8s(s, 2); /* mcs user id */
s->next_packet += len; s->next_packet += len;
DEBUG(("out (4) xrdp_rdp_recv")); LOG_DEVEL(LOG_LEVEL_TRACE, "out (4) xrdp_rdp_recv");
return 0; return 0;
} }
} }
@ -528,7 +522,7 @@ xrdp_rdp_send(struct xrdp_rdp *self, struct stream *s, int pdu_type)
{ {
int len = 0; int len = 0;
DEBUG(("in xrdp_rdp_send")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_send");
s_pop_layer(s, rdp_hdr); s_pop_layer(s, rdp_hdr);
len = s->end - s->p; len = s->end - s->p;
out_uint16_le(s, len); out_uint16_le(s, len);
@ -537,11 +531,11 @@ xrdp_rdp_send(struct xrdp_rdp *self, struct stream *s, int pdu_type)
if (xrdp_sec_send(self->sec_layer, s, MCS_GLOBAL_CHANNEL) != 0) if (xrdp_sec_send(self->sec_layer, s, MCS_GLOBAL_CHANNEL) != 0)
{ {
DEBUG(("out xrdp_rdp_send error")); LOG(LOG_LEVEL_ERROR, "out xrdp_rdp_send error");
return 1; return 1;
} }
DEBUG(("out xrdp_rdp_send")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_send");
return 0; return 0;
} }
@ -564,7 +558,7 @@ xrdp_rdp_send_data(struct xrdp_rdp *self, struct stream *s,
struct stream ls; struct stream ls;
struct xrdp_mppc_enc *mppc_enc; struct xrdp_mppc_enc *mppc_enc;
DEBUG(("in xrdp_rdp_send_data")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_send_data");
s_pop_layer(s, rdp_hdr); s_pop_layer(s, rdp_hdr);
len = (int)(s->end - s->p); len = (int)(s->end - s->p);
pdutype = 0x10 | PDUTYPE_DATAPDU; pdutype = 0x10 | PDUTYPE_DATAPDU;
@ -579,9 +573,9 @@ xrdp_rdp_send_data(struct xrdp_rdp *self, struct stream *s,
mppc_enc = self->mppc_enc; mppc_enc = self->mppc_enc;
if (compress_rdp(mppc_enc, (tui8 *)(s->p + 18), tocomplen)) if (compress_rdp(mppc_enc, (tui8 *)(s->p + 18), tocomplen))
{ {
DEBUG(("mppc_encode ok flags 0x%x bytes_in_opb %d historyOffset %d " LOG_DEVEL(LOG_LEVEL_TRACE, "mppc_encode ok flags 0x%x bytes_in_opb %d historyOffset %d "
"tocomplen %d", mppc_enc->flags, mppc_enc->bytes_in_opb, "tocomplen %d", mppc_enc->flags, mppc_enc->bytes_in_opb,
mppc_enc->historyOffset, tocomplen)); mppc_enc->historyOffset, tocomplen);
clen = mppc_enc->bytes_in_opb + 18; clen = mppc_enc->bytes_in_opb + 18;
pdulen = clen; pdulen = clen;
@ -606,9 +600,9 @@ xrdp_rdp_send_data(struct xrdp_rdp *self, struct stream *s,
} }
else else
{ {
LLOGLN(10, ("xrdp_rdp_send_data: mppc_encode not ok " LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_rdp_send_data: mppc_encode not ok "
"type %d flags %d", mppc_enc->protocol_type, "type %d flags %d", mppc_enc->protocol_type,
mppc_enc->flags)); mppc_enc->flags);
} }
} }
@ -625,11 +619,11 @@ xrdp_rdp_send_data(struct xrdp_rdp *self, struct stream *s,
if (xrdp_sec_send(self->sec_layer, s, MCS_GLOBAL_CHANNEL) != 0) if (xrdp_sec_send(self->sec_layer, s, MCS_GLOBAL_CHANNEL) != 0)
{ {
DEBUG(("out xrdp_rdp_send_data error")); LOG(LOG_LEVEL_ERROR, "out xrdp_rdp_send_data error");
return 1; return 1;
} }
DEBUG(("out xrdp_rdp_send_data")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_send_data");
return 0; return 0;
} }
@ -691,7 +685,7 @@ xrdp_rdp_send_fastpath(struct xrdp_rdp *self, struct stream *s,
struct stream send_s; struct stream send_s;
struct xrdp_mppc_enc *mppc_enc; struct xrdp_mppc_enc *mppc_enc;
LLOGLN(10, ("xrdp_rdp_send_fastpath:")); LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_rdp_send_fastpath:");
s_pop_layer(s, rdp_hdr); s_pop_layer(s, rdp_hdr);
updateCode = data_pdu_type; updateCode = data_pdu_type;
if (self->client_info.rdp_compression) if (self->client_info.rdp_compression)
@ -735,8 +729,8 @@ xrdp_rdp_send_fastpath(struct xrdp_rdp *self, struct stream *s,
} }
} }
send_len = no_comp_len; send_len = no_comp_len;
LLOGLN(10, ("xrdp_rdp_send_fastpath: no_comp_len %d fragmentation %d", LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_rdp_send_fastpath: no_comp_len %d fragmentation %d",
no_comp_len, fragmentation)); no_comp_len, fragmentation);
if ((compression != 0) && (no_comp_len > header_bytes + 16)) if ((compression != 0) && (no_comp_len > header_bytes + 16))
{ {
to_comp_len = no_comp_len - header_bytes; to_comp_len = no_comp_len - header_bytes;
@ -745,14 +739,14 @@ xrdp_rdp_send_fastpath(struct xrdp_rdp *self, struct stream *s,
to_comp_len)) to_comp_len))
{ {
comp_len = mppc_enc->bytes_in_opb + header_bytes; comp_len = mppc_enc->bytes_in_opb + header_bytes;
LLOGLN(10, ("xrdp_rdp_send_fastpath: no_comp_len %d " LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_rdp_send_fastpath: no_comp_len %d "
"comp_len %d", no_comp_len, comp_len)); "comp_len %d", no_comp_len, comp_len);
send_len = comp_len; send_len = comp_len;
comp_type = mppc_enc->flags; comp_type = mppc_enc->flags;
/* outputBuffer has 64 bytes preceding it */ /* outputBuffer has 64 bytes preceding it */
g_memset(&comp_s, 0, sizeof(comp_s)); g_memset(&comp_s, 0, sizeof(comp_s));
comp_s.data = mppc_enc->outputBuffer - comp_s.data = mppc_enc->outputBuffer -
(rdp_offset + header_bytes); (rdp_offset + header_bytes);
comp_s.p = comp_s.data + rdp_offset; comp_s.p = comp_s.data + rdp_offset;
comp_s.end = comp_s.p + send_len; comp_s.end = comp_s.p + send_len;
comp_s.size = send_len; comp_s.size = send_len;
@ -762,14 +756,14 @@ xrdp_rdp_send_fastpath(struct xrdp_rdp *self, struct stream *s,
} }
else else
{ {
LLOGLN(10, ("xrdp_rdp_send_fastpath: mppc_encode not ok " LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_rdp_send_fastpath: mppc_encode not ok "
"type %d flags %d", mppc_enc->protocol_type, "type %d flags %d", mppc_enc->protocol_type,
mppc_enc->flags)); mppc_enc->flags);
} }
} }
updateHeader = (updateCode & 15) | updateHeader = (updateCode & 15) |
((fragmentation & 3) << 4) | ((fragmentation & 3) << 4) |
((compression & 3) << 6); ((compression & 3) << 6);
out_uint8(&send_s, updateHeader); out_uint8(&send_s, updateHeader);
if (compression != 0) if (compression != 0)
{ {
@ -780,7 +774,7 @@ xrdp_rdp_send_fastpath(struct xrdp_rdp *self, struct stream *s,
send_s.end = send_s.p + send_len; send_s.end = send_s.p + send_len;
if (xrdp_sec_send_fastpath(self->sec_layer, &send_s) != 0) if (xrdp_sec_send_fastpath(self->sec_layer, &send_s) != 0)
{ {
LLOGLN(0, ("xrdp_rdp_send_fastpath: xrdp_fastpath_send failed")); LOG(LOG_LEVEL_ERROR, "xrdp_rdp_send_fastpath: xrdp_fastpath_send failed");
return 1; return 1;
} }
frag_s.p += no_comp_len; frag_s.p += no_comp_len;
@ -800,11 +794,11 @@ xrdp_rdp_send_data_update_sync(struct xrdp_rdp *self)
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
DEBUG(("in xrdp_rdp_send_data_update_sync")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_send_data_update_sync");
if (self->client_info.use_fast_path & 1) /* fastpath output supported */ if (self->client_info.use_fast_path & 1) /* fastpath output supported */
{ {
LLOGLN(10, ("xrdp_rdp_send_data_update_sync: fastpath")); LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_rdp_send_data_update_sync: fastpath");
if (xrdp_rdp_init_fastpath(self, s) != 0) if (xrdp_rdp_init_fastpath(self, s) != 0)
{ {
free_stream(s); free_stream(s);
@ -815,7 +809,7 @@ xrdp_rdp_send_data_update_sync(struct xrdp_rdp *self)
{ {
if (xrdp_rdp_init_data(self, s) != 0) if (xrdp_rdp_init_data(self, s) != 0)
{ {
DEBUG(("out xrdp_rdp_send_data_update_sync error")); LOG(LOG_LEVEL_ERROR, "out xrdp_rdp_send_data_update_sync error");
free_stream(s); free_stream(s);
return 1; return 1;
} }
@ -838,14 +832,14 @@ xrdp_rdp_send_data_update_sync(struct xrdp_rdp *self)
{ {
if (xrdp_rdp_send_data(self, s, RDP_DATA_PDU_UPDATE) != 0) if (xrdp_rdp_send_data(self, s, RDP_DATA_PDU_UPDATE) != 0)
{ {
DEBUG(("out xrdp_rdp_send_data_update_sync error")); LOG(LOG_LEVEL_ERROR, "out xrdp_rdp_send_data_update_sync error");
free_stream(s); free_stream(s);
return 1; return 1;
} }
} }
DEBUG(("out xrdp_rdp_send_data_update_sync")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_send_data_update_sync");
free_stream(s); free_stream(s);
return 0; return 0;
} }
@ -857,7 +851,7 @@ xrdp_rdp_incoming(struct xrdp_rdp *self)
struct xrdp_iso *iso; struct xrdp_iso *iso;
iso = self->sec_layer->mcs_layer->iso_layer; iso = self->sec_layer->mcs_layer->iso_layer;
DEBUG(("in xrdp_rdp_incoming")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_incoming");
if (xrdp_sec_incoming(self->sec_layer) != 0) if (xrdp_sec_incoming(self->sec_layer) != 0)
{ {
@ -865,7 +859,7 @@ xrdp_rdp_incoming(struct xrdp_rdp *self)
} }
self->mcs_channel = self->sec_layer->mcs_layer->userid + self->mcs_channel = self->sec_layer->mcs_layer->userid +
MCS_USERCHANNEL_BASE; MCS_USERCHANNEL_BASE;
DEBUG(("out xrdp_rdp_incoming mcs channel %d", self->mcs_channel)); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_incoming mcs channel %d", self->mcs_channel);
g_strncpy(self->client_info.client_addr, iso->trans->addr, g_strncpy(self->client_info.client_addr, iso->trans->addr,
sizeof(self->client_info.client_addr) - 1); sizeof(self->client_info.client_addr) - 1);
g_strncpy(self->client_info.client_port, iso->trans->port, g_strncpy(self->client_info.client_port, iso->trans->port,
@ -874,21 +868,21 @@ xrdp_rdp_incoming(struct xrdp_rdp *self)
/* log TLS version and cipher of TLS connections */ /* log TLS version and cipher of TLS connections */
if (iso->selectedProtocol > PROTOCOL_RDP) if (iso->selectedProtocol > PROTOCOL_RDP)
{ {
log_message(LOG_LEVEL_INFO, LOG(LOG_LEVEL_INFO,
"TLS connection established from %s port %s: %s with cipher %s", "TLS connection established from %s port %s: %s with cipher %s",
self->client_info.client_addr, self->client_info.client_addr,
self->client_info.client_port, self->client_info.client_port,
iso->trans->ssl_protocol, iso->trans->ssl_protocol,
iso->trans->cipher_name); iso->trans->cipher_name);
} }
/* log non-TLS connections */ /* log non-TLS connections */
else else
{ {
log_message(LOG_LEVEL_INFO, LOG(LOG_LEVEL_INFO,
"Non-TLS connection established from %s port %s: " "Non-TLS connection established from %s port %s: "
"encrypted with standard RDP security", "encrypted with standard RDP security",
self->client_info.client_addr, self->client_info.client_addr,
self->client_info.client_port); self->client_info.client_port);
} }
return 0; return 0;
@ -920,7 +914,7 @@ xrdp_rdp_process_data_input(struct xrdp_rdp *self, struct stream *s)
} }
in_uint16_le(s, num_events); in_uint16_le(s, num_events);
in_uint8s(s, 2); /* pad */ in_uint8s(s, 2); /* pad */
DEBUG(("in xrdp_rdp_process_data_input %d events", num_events)); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_process_data_input %d events", num_events);
for (index = 0; index < num_events; index++) for (index = 0; index < num_events; index++)
{ {
@ -933,8 +927,8 @@ xrdp_rdp_process_data_input(struct xrdp_rdp *self, struct stream *s)
in_uint16_le(s, device_flags); in_uint16_le(s, device_flags);
in_sint16_le(s, param1); in_sint16_le(s, param1);
in_sint16_le(s, param2); in_sint16_le(s, param2);
DEBUG(("xrdp_rdp_process_data_input event %4.4x flags %4.4x param1 %d " LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data_input event %4.4x flags %4.4x param1 %d "
"param2 %d time %d", msg_type, device_flags, param1, param2, time)); "param2 %d time %d", msg_type, device_flags, param1, param2, time);
if (self->session->callback != 0) if (self->session->callback != 0)
{ {
@ -949,7 +943,7 @@ xrdp_rdp_process_data_input(struct xrdp_rdp *self, struct stream *s)
} }
} }
DEBUG(("out xrdp_rdp_process_data_input")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_process_data_input");
return 0; return 0;
} }
@ -1018,24 +1012,24 @@ xrdp_rdp_process_data_control(struct xrdp_rdp *self, struct stream *s)
{ {
int action; int action;
DEBUG(("xrdp_rdp_process_data_control")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data_control");
in_uint16_le(s, action); in_uint16_le(s, action);
in_uint8s(s, 2); /* user id */ in_uint8s(s, 2); /* user id */
in_uint8s(s, 4); /* control id */ in_uint8s(s, 4); /* control id */
if (action == RDP_CTL_REQUEST_CONTROL) if (action == RDP_CTL_REQUEST_CONTROL)
{ {
DEBUG(("xrdp_rdp_process_data_control got RDP_CTL_REQUEST_CONTROL")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data_control got RDP_CTL_REQUEST_CONTROL");
DEBUG(("xrdp_rdp_process_data_control calling xrdp_rdp_send_synchronise")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data_control calling xrdp_rdp_send_synchronise");
xrdp_rdp_send_synchronise(self); xrdp_rdp_send_synchronise(self);
DEBUG(("xrdp_rdp_process_data_control sending RDP_CTL_COOPERATE")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data_control sending RDP_CTL_COOPERATE");
xrdp_rdp_send_control(self, RDP_CTL_COOPERATE); xrdp_rdp_send_control(self, RDP_CTL_COOPERATE);
DEBUG(("xrdp_rdp_process_data_control sending RDP_CTL_GRANT_CONTROL")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data_control sending RDP_CTL_GRANT_CONTROL");
xrdp_rdp_send_control(self, RDP_CTL_GRANT_CONTROL); xrdp_rdp_send_control(self, RDP_CTL_GRANT_CONTROL);
} }
else else
{ {
DEBUG(("xrdp_rdp_process_data_control unknown action")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data_control unknown action");
} }
return 0; return 0;
@ -1045,7 +1039,7 @@ xrdp_rdp_process_data_control(struct xrdp_rdp *self, struct stream *s)
static int static int
xrdp_rdp_process_data_sync(struct xrdp_rdp *self) xrdp_rdp_process_data_sync(struct xrdp_rdp *self)
{ {
DEBUG(("xrdp_rdp_process_data_sync")); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data_sync");
return 0; return 0;
} }
@ -1069,7 +1063,7 @@ xrdp_rdp_process_screen_update(struct xrdp_rdp *self, struct stream *s)
} }
in_uint8(s, num_rects); in_uint8(s, num_rects);
in_uint8s(s, 3); /* pad */ in_uint8s(s, 3); /* pad */
g_writeln("xrdp_rdp_process_screen_update: num_rects %d", num_rects); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_screen_update: num_rects %d", num_rects);
for (index = 0; index < num_rects; index++) for (index = 0; index < num_rects; index++)
{ {
if (!s_check_rem(s, 8)) if (!s_check_rem(s, 8))
@ -1081,7 +1075,7 @@ xrdp_rdp_process_screen_update(struct xrdp_rdp *self, struct stream *s)
in_uint16_le(s, top); in_uint16_le(s, top);
in_uint16_le(s, right); in_uint16_le(s, right);
in_uint16_le(s, bottom); in_uint16_le(s, bottom);
g_writeln(" left %d top %d right %d bottom %d", LOG_DEVEL(LOG_LEVEL_TRACE, " left %d top %d right %d bottom %d",
left, top, right, bottom); left, top, right, bottom);
cx = (right - left) + 1; cx = (right - left) + 1;
cy = (bottom - top) + 1; cy = (bottom - top) + 1;
@ -1132,7 +1126,7 @@ xrdp_rdp_process_data_font(struct xrdp_rdp *self, struct stream *s)
{ {
int seq; int seq;
DEBUG(("in xrdp_rdp_process_data_font")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_process_data_font");
in_uint8s(s, 2); /* NumberFonts: 0x0, SHOULD be set to 0 */ in_uint8s(s, 2); /* NumberFonts: 0x0, SHOULD be set to 0 */
in_uint8s(s, 2); /* TotalNumberFonts: 0x0, SHOULD be set to 0 */ in_uint8s(s, 2); /* TotalNumberFonts: 0x0, SHOULD be set to 0 */
in_uint16_le(s, seq); /* ListFlags */ in_uint16_le(s, seq); /* ListFlags */
@ -1142,17 +1136,17 @@ xrdp_rdp_process_data_font(struct xrdp_rdp *self, struct stream *s)
if (seq == 2 || seq == 3) /* after second font message, we are up and */ if (seq == 2 || seq == 3) /* after second font message, we are up and */
{ {
/* running */ /* running */
DEBUG(("sending fontmap")); LOG_DEVEL(LOG_LEVEL_TRACE, "sending fontmap");
xrdp_rdp_send_fontmap(self); xrdp_rdp_send_fontmap(self);
self->session->up_and_running = 1; self->session->up_and_running = 1;
g_writeln("yeah, up_and_running"); LOG_DEVEL(LOG_LEVEL_TRACE, "yeah, up_and_running");
DEBUG(("up_and_running set")); LOG_DEVEL(LOG_LEVEL_TRACE, "up_and_running set");
xrdp_rdp_send_data_update_sync(self); xrdp_rdp_send_data_update_sync(self);
xrdp_channel_drdynvc_start(self->sec_layer->chan_layer); xrdp_channel_drdynvc_start(self->sec_layer->chan_layer);
} }
DEBUG(("out xrdp_rdp_process_data_font")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_process_data_font");
return 0; return 0;
} }
@ -1221,9 +1215,9 @@ xrdp_rdp_process_frame_ack(struct xrdp_rdp *self, struct stream *s)
{ {
int frame_id; int frame_id;
//g_writeln("xrdp_rdp_process_frame_ack:"); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_frame_ack:");
in_uint32_le(s, frame_id); in_uint32_le(s, frame_id);
//g_writeln(" frame_id %d", frame_id); LOG_DEVEL(LOG_LEVEL_TRACE, " frame_id %d", frame_id);
if (self->session->callback != 0) if (self->session->callback != 0)
{ {
/* call to xrdp_wm.c : callback */ /* call to xrdp_wm.c : callback */
@ -1248,13 +1242,13 @@ xrdp_rdp_process_suppress(struct xrdp_rdp *self, struct stream *s)
return 1; return 1;
} }
in_uint8(s, allowDisplayUpdates); in_uint8(s, allowDisplayUpdates);
g_writeln("xrdp_rdp_process_suppress: allowDisplayUpdates %d bytes " LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_suppress: allowDisplayUpdates %d bytes "
"left %d", allowDisplayUpdates, (int) (s->end - s->p)); "left %d", allowDisplayUpdates, (int) (s->end - s->p));
switch (allowDisplayUpdates) switch (allowDisplayUpdates)
{ {
case 0: /* SUPPRESS_DISPLAY_UPDATES */ case 0: /* SUPPRESS_DISPLAY_UPDATES */
self->client_info.suppress_output = 1; self->client_info.suppress_output = 1;
g_writeln("xrdp_rdp_process_suppress: suppress_output %d", LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_suppress: suppress_output %d",
self->client_info.suppress_output); self->client_info.suppress_output);
if (self->session->callback != 0) if (self->session->callback != 0)
{ {
@ -1273,7 +1267,7 @@ xrdp_rdp_process_suppress(struct xrdp_rdp *self, struct stream *s)
in_uint16_le(s, top); in_uint16_le(s, top);
in_uint16_le(s, right); in_uint16_le(s, right);
in_uint16_le(s, bottom); in_uint16_le(s, bottom);
g_writeln("xrdp_rdp_process_suppress: suppress_output %d " LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_suppress: suppress_output %d "
"left %d top %d right %d bottom %d", "left %d top %d right %d bottom %d",
self->client_info.suppress_output, self->client_info.suppress_output,
left, top, right, bottom); left, top, right, bottom);
@ -1316,7 +1310,7 @@ xrdp_rdp_process_data(struct xrdp_rdp *self, struct stream *s)
{ {
return 1; return 1;
} }
DEBUG(("xrdp_rdp_process_data pduType2 %d", pduType2)); LOG_DEVEL(LOG_LEVEL_TRACE, "xrdp_rdp_process_data pduType2 %d", pduType2);
switch (pduType2) switch (pduType2)
{ {
case RDP_DATA_PDU_POINTER: /* 27(0x1b) */ case RDP_DATA_PDU_POINTER: /* 27(0x1b) */
@ -1350,7 +1344,7 @@ xrdp_rdp_process_data(struct xrdp_rdp *self, struct stream *s)
xrdp_rdp_process_frame_ack(self, s); xrdp_rdp_process_frame_ack(self, s);
break; break;
default: default:
g_writeln("unknown in xrdp_rdp_process_data pduType2 %d", pduType2); LOG_DEVEL(LOG_LEVEL_TRACE, "unknown in xrdp_rdp_process_data pduType2 %d", pduType2);
break; break;
} }
return 0; return 0;
@ -1361,9 +1355,9 @@ xrdp_rdp_disconnect(struct xrdp_rdp *self)
{ {
int rv; int rv;
DEBUG(("in xrdp_rdp_disconnect")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_disconnect");
rv = xrdp_sec_disconnect(self->sec_layer); rv = xrdp_sec_disconnect(self->sec_layer);
DEBUG(("out xrdp_rdp_disconnect")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_disconnect");
return rv; return rv;
} }
@ -1373,14 +1367,14 @@ xrdp_rdp_send_deactivate(struct xrdp_rdp *self)
{ {
struct stream *s; struct stream *s;
DEBUG(("in xrdp_rdp_send_deactivate")); LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_rdp_send_deactivate");
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
if (xrdp_rdp_init(self, s) != 0) if (xrdp_rdp_init(self, s) != 0)
{ {
free_stream(s); free_stream(s);
DEBUG(("out xrdp_rdp_send_deactivate error")); LOG(LOG_LEVEL_ERROR, "out xrdp_rdp_send_deactivate error");
return 1; return 1;
} }
@ -1389,12 +1383,12 @@ xrdp_rdp_send_deactivate(struct xrdp_rdp *self)
if (xrdp_rdp_send(self, s, PDUTYPE_DEACTIVATEALLPDU) != 0) if (xrdp_rdp_send(self, s, PDUTYPE_DEACTIVATEALLPDU) != 0)
{ {
free_stream(s); free_stream(s);
DEBUG(("out xrdp_rdp_send_deactivate error")); LOG(LOG_LEVEL_ERROR, "out xrdp_rdp_send_deactivate error");
return 1; return 1;
} }
free_stream(s); free_stream(s);
DEBUG(("out xrdp_rdp_send_deactivate")); LOG_DEVEL(LOG_LEVEL_TRACE, "out xrdp_rdp_send_deactivate");
return 0; return 0;
} }
@ -1405,7 +1399,7 @@ xrdp_rdp_send_session_info(struct xrdp_rdp *self, const char *data,
{ {
struct stream *s; struct stream *s;
LLOGLN(0, ("xrdp_rdp_send_session_info: data_bytes %d", data_bytes)); LOG_DEVEL(LOG_LEVEL_INFO, "xrdp_rdp_send_session_info: data_bytes %d", data_bytes);
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
@ -1417,7 +1411,7 @@ xrdp_rdp_send_session_info(struct xrdp_rdp *self, const char *data,
if (s_check_rem_out(s, data_bytes)) if (s_check_rem_out(s, data_bytes))
{ {
out_uint8a(s, data, data_bytes); out_uint8a(s, data, data_bytes);
} }
else else
{ {

401
libxrdp/xrdp_sec.c
View File

File diff suppressed because it is too large Load Diff

2
libxrdp/xrdp_surface.c
View File

@ -111,7 +111,7 @@ xrdp_surface_send_surface_bits(struct xrdp_surface *self, int bpp, char *data,
} }
else else
{ {
g_writeln("bpp = %d is not supported\n", bpp); LOG(LOG_LEVEL_ERROR, "bpp = %d is not supported\n", bpp);
return 1; return 1;
} }