You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2116 lines
61 KiB
2116 lines
61 KiB
/**
|
|
* xrdp: A Remote Desktop Protocol server.
|
|
*
|
|
* Copyright (C) Jay Sorg 2004-2014
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* simple window manager
|
|
*/
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include <config_ac.h>
|
|
#endif
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include "xrdp.h"
|
|
#include "log.h"
|
|
|
|
/*****************************************************************************/
|
|
struct xrdp_wm *
|
|
xrdp_wm_create(struct xrdp_process *owner,
|
|
struct xrdp_client_info *client_info)
|
|
{
|
|
struct xrdp_wm *self = (struct xrdp_wm *)NULL;
|
|
char event_name[256];
|
|
int pid = 0;
|
|
|
|
/* initialize (zero out) local variables: */
|
|
g_memset(event_name, 0, sizeof(char) * 256);
|
|
|
|
self = (struct xrdp_wm *)g_malloc(sizeof(struct xrdp_wm), 1);
|
|
self->client_info = client_info;
|
|
self->screen = xrdp_bitmap_create(client_info->width,
|
|
client_info->height,
|
|
client_info->bpp,
|
|
WND_TYPE_SCREEN, self);
|
|
self->screen->wm = self;
|
|
self->pro_layer = owner;
|
|
self->session = owner->session;
|
|
pid = g_getpid();
|
|
g_snprintf(event_name, 255, "xrdp_%8.8x_wm_login_mode_event_%8.8x",
|
|
pid, owner->session_id);
|
|
log_message(LOG_LEVEL_DEBUG, "%s", event_name);
|
|
self->login_mode_event = g_create_wait_obj(event_name);
|
|
self->painter = xrdp_painter_create(self, self->session);
|
|
self->cache = xrdp_cache_create(self, self->session, self->client_info);
|
|
self->log = list_create();
|
|
self->log->auto_free = 1;
|
|
self->mm = xrdp_mm_create(self);
|
|
self->default_font = xrdp_font_create(self);
|
|
/* this will use built in keymap or load from file */
|
|
get_keymaps(self->session->client_info->keylayout, &(self->keymap));
|
|
xrdp_wm_set_login_mode(self, 0);
|
|
self->target_surface = self->screen;
|
|
self->current_surface_index = 0xffff; /* screen */
|
|
|
|
/* to store configuration from xrdp.ini */
|
|
self->xrdp_config = g_new0(struct xrdp_config, 1);
|
|
|
|
return self;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
void
|
|
xrdp_wm_delete(struct xrdp_wm *self)
|
|
{
|
|
if (self == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
xrdp_mm_delete(self->mm);
|
|
xrdp_cache_delete(self->cache);
|
|
xrdp_painter_delete(self->painter);
|
|
xrdp_bitmap_delete(self->screen);
|
|
/* free the log */
|
|
list_delete(self->log);
|
|
/* free default font */
|
|
xrdp_font_delete(self->default_font);
|
|
g_delete_wait_obj(self->login_mode_event);
|
|
|
|
if (self->xrdp_config)
|
|
g_free(self->xrdp_config);
|
|
|
|
/* free self */
|
|
g_free(self);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_send_palette(struct xrdp_wm *self)
|
|
{
|
|
return libxrdp_send_palette(self->session, self->palette);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_send_bell(struct xrdp_wm *self)
|
|
{
|
|
return libxrdp_send_bell(self->session);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_send_bitmap(struct xrdp_wm *self, struct xrdp_bitmap *bitmap,
|
|
int x, int y, int cx, int cy)
|
|
{
|
|
return libxrdp_send_bitmap(self->session, bitmap->width, bitmap->height,
|
|
bitmap->bpp, bitmap->data, x, y, cx, cy);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_set_focused(struct xrdp_wm *self, struct xrdp_bitmap *wnd)
|
|
{
|
|
struct xrdp_bitmap *focus_out_control;
|
|
struct xrdp_bitmap *focus_in_control;
|
|
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (self->focused_window == wnd)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
focus_out_control = 0;
|
|
focus_in_control = 0;
|
|
|
|
if (self->focused_window != 0)
|
|
{
|
|
xrdp_bitmap_set_focus(self->focused_window, 0);
|
|
focus_out_control = self->focused_window->focused_control;
|
|
}
|
|
|
|
self->focused_window = wnd;
|
|
|
|
if (self->focused_window != 0)
|
|
{
|
|
xrdp_bitmap_set_focus(self->focused_window, 1);
|
|
focus_in_control = self->focused_window->focused_control;
|
|
}
|
|
|
|
xrdp_bitmap_invalidate(focus_out_control, 0);
|
|
xrdp_bitmap_invalidate(focus_in_control, 0);
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
static int
|
|
xrdp_wm_get_pixel(char *data, int x, int y, int width, int bpp)
|
|
{
|
|
int start;
|
|
int shift;
|
|
|
|
if (bpp == 1)
|
|
{
|
|
width = (width + 7) / 8;
|
|
start = (y * width) + x / 8;
|
|
shift = x % 8;
|
|
return (data[start] & (0x80 >> shift)) != 0;
|
|
}
|
|
else if (bpp == 4)
|
|
{
|
|
width = (width + 1) / 2;
|
|
start = y * width + x / 2;
|
|
shift = x % 2;
|
|
|
|
if (shift == 0)
|
|
{
|
|
return (data[start] & 0xf0) >> 4;
|
|
}
|
|
else
|
|
{
|
|
return data[start] & 0x0f;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_pointer(struct xrdp_wm *self, char *data, char *mask, int x, int y,
|
|
int bpp)
|
|
{
|
|
int bytes;
|
|
struct xrdp_pointer_item pointer_item;
|
|
|
|
if (bpp == 0)
|
|
{
|
|
bpp = 24;
|
|
}
|
|
bytes = ((bpp + 7) / 8) * 32 * 32;
|
|
g_memset(&pointer_item, 0, sizeof(struct xrdp_pointer_item));
|
|
pointer_item.x = x;
|
|
pointer_item.y = y;
|
|
pointer_item.bpp = bpp;
|
|
g_memcpy(pointer_item.data, data, bytes);
|
|
g_memcpy(pointer_item.mask, mask, 32 * 32 / 8);
|
|
self->screen->pointer = xrdp_cache_add_pointer(self->cache, &pointer_item);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* returns error */
|
|
int
|
|
xrdp_wm_load_pointer(struct xrdp_wm *self, char *file_name, char *data,
|
|
char *mask, int *x, int *y)
|
|
{
|
|
int fd;
|
|
int bpp;
|
|
int w;
|
|
int h;
|
|
int i;
|
|
int j;
|
|
int pixel;
|
|
int palette[16];
|
|
struct stream *fs;
|
|
|
|
if (!g_file_exist(file_name))
|
|
{
|
|
log_message(LOG_LEVEL_ERROR,"xrdp_wm_load_pointer: error pointer file [%s] does not exist",
|
|
file_name);
|
|
return 1;
|
|
}
|
|
|
|
make_stream(fs);
|
|
init_stream(fs, 8192);
|
|
fd = g_file_open(file_name);
|
|
|
|
if (fd < 0)
|
|
{
|
|
log_message(LOG_LEVEL_ERROR,"xrdp_wm_load_pointer: error loading pointer from file [%s]",
|
|
file_name);
|
|
xstream_free(fs);
|
|
return 1;
|
|
}
|
|
|
|
g_file_read(fd, fs->data, 8192);
|
|
g_file_close(fd);
|
|
in_uint8s(fs, 6);
|
|
in_uint8(fs, w);
|
|
in_uint8(fs, h);
|
|
in_uint8s(fs, 2);
|
|
in_uint16_le(fs, *x);
|
|
in_uint16_le(fs, *y);
|
|
in_uint8s(fs, 22);
|
|
in_uint8(fs, bpp);
|
|
in_uint8s(fs, 25);
|
|
|
|
if (w == 32 && h == 32)
|
|
{
|
|
if (bpp == 1)
|
|
{
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
in_uint32_le(fs, pixel);
|
|
palette[i] = pixel;
|
|
}
|
|
for (i = 0; i < 32; i++)
|
|
{
|
|
for (j = 0; j < 32; j++)
|
|
{
|
|
pixel = palette[xrdp_wm_get_pixel(fs->p, j, i, 32, 1)];
|
|
*data = pixel;
|
|
data++;
|
|
*data = pixel >> 8;
|
|
data++;
|
|
*data = pixel >> 16;
|
|
data++;
|
|
}
|
|
}
|
|
|
|
in_uint8s(fs, 128);
|
|
}
|
|
else if (bpp == 4)
|
|
{
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
in_uint32_le(fs, pixel);
|
|
palette[i] = pixel;
|
|
}
|
|
for (i = 0; i < 32; i++)
|
|
{
|
|
for (j = 0; j < 32; j++)
|
|
{
|
|
pixel = palette[xrdp_wm_get_pixel(fs->p, j, i, 32, 1)];
|
|
*data = pixel;
|
|
data++;
|
|
*data = pixel >> 8;
|
|
data++;
|
|
*data = pixel >> 16;
|
|
data++;
|
|
}
|
|
}
|
|
|
|
in_uint8s(fs, 512);
|
|
}
|
|
|
|
g_memcpy(mask, fs->p, 128); /* mask */
|
|
}
|
|
|
|
free_stream(fs);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_send_pointer(struct xrdp_wm *self, int cache_idx,
|
|
char *data, char *mask, int x, int y, int bpp)
|
|
{
|
|
return libxrdp_send_pointer(self->session, cache_idx, data, mask,
|
|
x, y, bpp);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_set_pointer(struct xrdp_wm *self, int cache_idx)
|
|
{
|
|
return libxrdp_set_pointer(self->session, cache_idx);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* convert hex string to int */
|
|
unsigned int
|
|
xrdp_wm_htoi (const char *ptr)
|
|
{
|
|
unsigned int value = 0;
|
|
char ch = *ptr;
|
|
|
|
while (ch == ' ' || ch == '\t')
|
|
{
|
|
ch = *(++ptr);
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
if (ch >= '0' && ch <= '9')
|
|
{
|
|
value = (value << 4) + (ch - '0');
|
|
}
|
|
else if (ch >= 'A' && ch <= 'F')
|
|
{
|
|
value = (value << 4) + (ch - 'A' + 10);
|
|
}
|
|
else if (ch >= 'a' && ch <= 'f')
|
|
{
|
|
value = (value << 4) + (ch - 'a' + 10);
|
|
}
|
|
else
|
|
{
|
|
return value;
|
|
}
|
|
|
|
ch = *(++ptr);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_load_static_colors_plus(struct xrdp_wm *self, char *autorun_name)
|
|
{
|
|
int bindex;
|
|
int gindex;
|
|
int rindex;
|
|
|
|
int fd;
|
|
int index;
|
|
char *val;
|
|
struct list *names;
|
|
struct list *values;
|
|
char cfg_file[256];
|
|
|
|
if (autorun_name != 0)
|
|
{
|
|
autorun_name[0] = 0;
|
|
}
|
|
|
|
/* initialize with defaults */
|
|
self->black = HCOLOR(self->screen->bpp, 0x000000);
|
|
self->grey = HCOLOR(self->screen->bpp, 0xc0c0c0);
|
|
self->dark_grey = HCOLOR(self->screen->bpp, 0x808080);
|
|
self->blue = HCOLOR(self->screen->bpp, 0x0000ff);
|
|
self->dark_blue = HCOLOR(self->screen->bpp, 0x00007f);
|
|
self->white = HCOLOR(self->screen->bpp, 0xffffff);
|
|
self->red = HCOLOR(self->screen->bpp, 0xff0000);
|
|
self->green = HCOLOR(self->screen->bpp, 0x00ff00);
|
|
self->background = HCOLOR(self->screen->bpp, 0x000000);
|
|
|
|
/* now load them from the globals in xrdp.ini if defined */
|
|
g_snprintf(cfg_file, 255, "%s/xrdp.ini", XRDP_CFG_PATH);
|
|
fd = g_file_open(cfg_file);
|
|
|
|
if (fd > 0)
|
|
{
|
|
names = list_create();
|
|
names->auto_free = 1;
|
|
values = list_create();
|
|
values->auto_free = 1;
|
|
|
|
if (file_read_section(fd, "globals", names, values) == 0)
|
|
{
|
|
for (index = 0; index < names->count; index++)
|
|
{
|
|
val = (char *)list_get_item(names, index);
|
|
|
|
if (val != 0)
|
|
{
|
|
if (g_strcasecmp(val, "black") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->black = HCOLOR(self->screen->bpp,xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "grey") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->grey = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "dark_grey") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->dark_grey = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "blue") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->blue = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "dark_blue") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->dark_blue = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "white") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->white = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "red") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->red = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "green") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->green = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "background") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->background = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
|
|
}
|
|
else if (g_strcasecmp(val, "autorun") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
|
|
if (autorun_name != 0)
|
|
{
|
|
g_strncpy(autorun_name, val, 255);
|
|
}
|
|
}
|
|
else if (g_strcasecmp(val, "hidelogwindow") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
self->hide_log_window = g_text2bool(val);
|
|
}
|
|
else if (g_strcasecmp(val, "pamerrortxt") == 0)
|
|
{
|
|
val = (char *)list_get_item(values, index);
|
|
g_strncpy(self->pamerrortxt, val, 255);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
list_delete(names);
|
|
list_delete(values);
|
|
g_file_close(fd);
|
|
}
|
|
else
|
|
{
|
|
log_message(LOG_LEVEL_ERROR,"xrdp_wm_load_static_colors: Could not read xrdp.ini file %s", cfg_file);
|
|
}
|
|
|
|
if (self->screen->bpp == 8)
|
|
{
|
|
/* rgb332 */
|
|
for (bindex = 0; bindex < 4; bindex++)
|
|
{
|
|
for (gindex = 0; gindex < 8; gindex++)
|
|
{
|
|
for (rindex = 0; rindex < 8; rindex++)
|
|
{
|
|
self->palette[(bindex << 6) | (gindex << 3) | rindex] =
|
|
(((rindex << 5) | (rindex << 2) | (rindex >> 1)) << 16) |
|
|
(((gindex << 5) | (gindex << 2) | (gindex >> 1)) << 8) |
|
|
((bindex << 6) | (bindex << 4) | (bindex << 2) | (bindex));
|
|
}
|
|
}
|
|
}
|
|
|
|
xrdp_wm_send_palette(self);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* returns error */
|
|
int
|
|
xrdp_wm_load_static_pointers(struct xrdp_wm *self)
|
|
{
|
|
struct xrdp_pointer_item pointer_item;
|
|
char file_path[256];
|
|
|
|
DEBUG(("sending cursor"));
|
|
g_snprintf(file_path, 255, "%s/cursor1.cur", XRDP_SHARE_PATH);
|
|
g_memset(&pointer_item, 0, sizeof(pointer_item));
|
|
xrdp_wm_load_pointer(self, file_path, pointer_item.data,
|
|
pointer_item.mask, &pointer_item.x, &pointer_item.y);
|
|
xrdp_cache_add_pointer_static(self->cache, &pointer_item, 1);
|
|
DEBUG(("sending cursor"));
|
|
g_snprintf(file_path, 255, "%s/cursor0.cur", XRDP_SHARE_PATH);
|
|
g_memset(&pointer_item, 0, sizeof(pointer_item));
|
|
xrdp_wm_load_pointer(self, file_path, pointer_item.data,
|
|
pointer_item.mask, &pointer_item.x, &pointer_item.y);
|
|
xrdp_cache_add_pointer_static(self->cache, &pointer_item, 0);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_init(struct xrdp_wm *self)
|
|
{
|
|
int fd;
|
|
int index;
|
|
struct list *names;
|
|
struct list *values;
|
|
char *q;
|
|
const char *r;
|
|
char param[256];
|
|
char default_section_name[256];
|
|
char section_name[256];
|
|
char cfg_file[256];
|
|
char autorun_name[256];
|
|
|
|
g_writeln("in xrdp_wm_init: ");
|
|
|
|
load_xrdp_config(self->xrdp_config, self->screen->bpp);
|
|
|
|
xrdp_wm_load_static_colors_plus(self, autorun_name);
|
|
xrdp_wm_load_static_pointers(self);
|
|
self->screen->bg_color = self->xrdp_config->cfg_globals.ls_top_window_bg_color;
|
|
|
|
if (self->session->client_info->rdp_autologin)
|
|
{
|
|
/*
|
|
* NOTE: this should eventually be accessed from self->xrdp_config
|
|
*/
|
|
|
|
g_snprintf(cfg_file, 255, "%s/xrdp.ini", XRDP_CFG_PATH);
|
|
fd = g_file_open(cfg_file); /* xrdp.ini */
|
|
if (fd != -1)
|
|
{
|
|
names = list_create();
|
|
names->auto_free = 1;
|
|
values = list_create();
|
|
values->auto_free = 1;
|
|
|
|
/* pick up the first section name except for 'globals', 'Logging', 'channels'
|
|
* in xrdp.ini and use it as default section name */
|
|
file_read_sections(fd, names);
|
|
default_section_name[0] = '\0';
|
|
for (index = 0; index < names->count; index++)
|
|
{
|
|
q = (char *)list_get_item(names, index);
|
|
if ((g_strncasecmp("globals", q, 8) != 0) &&
|
|
(g_strncasecmp("Logging", q, 8) != 0) &&
|
|
(g_strncasecmp("channels", q, 9) != 0))
|
|
{
|
|
g_strncpy(default_section_name, q, 255);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* look for module name to be loaded */
|
|
if (autorun_name[0] != 0)
|
|
{
|
|
/* if autorun is configured in xrdp.ini, we enforce that module to be loaded */
|
|
g_strncpy(section_name, autorun_name, 255);
|
|
}
|
|
else if (self->session->client_info->domain[0] != '\0' &&
|
|
self->session->client_info->domain[0] != '_')
|
|
{
|
|
/* domain names that starts with '_' are reserved for IP/DNS to
|
|
* simplify for the user in a proxy setup */
|
|
|
|
/* we use the domain name as the module name to be loaded */
|
|
g_strncpy(section_name,
|
|
self->session->client_info->domain, 255);
|
|
}
|
|
else
|
|
{
|
|
/* if no domain is given, and autorun is not specified in xrdp.ini
|
|
* use default_section_name as section_name */
|
|
g_strncpy(section_name, default_section_name, 255);
|
|
}
|
|
|
|
list_clear(names);
|
|
|
|
/* if given section name doesn't match any sections configured
|
|
* in xrdp.ini, fallback to default_section_name */
|
|
if (file_read_section(fd, section_name, names, values) != 0)
|
|
{
|
|
log_message(LOG_LEVEL_INFO,
|
|
"Module \"%s\" specified by %s from %s port %s "
|
|
"is not configured. Using \"%s\" instead.",
|
|
section_name,
|
|
self->session->client_info->username,
|
|
self->session->client_info->client_addr,
|
|
self->session->client_info->client_port,
|
|
default_section_name);
|
|
list_clear(names);
|
|
list_clear(values);
|
|
|
|
g_strncpy(section_name, default_section_name, 255);
|
|
}
|
|
|
|
/* look for the required module in xrdp.ini, fetch its parameters */
|
|
if (file_read_section(fd, section_name, names, values) == 0)
|
|
{
|
|
for (index = 0; index < names->count; index++)
|
|
{
|
|
q = (char *)list_get_item(names, index);
|
|
r = (char *)list_get_item(values, index);
|
|
|
|
if (g_strncmp("password", q, 255) == 0)
|
|
{
|
|
/* if the password has been asked for by the module, use what the
|
|
client says.
|
|
if the password has been manually set in the config, use that
|
|
instead of what the client says. */
|
|
if (g_strncmp("ask", r, 3) == 0)
|
|
{
|
|
r = self->session->client_info->password;
|
|
}
|
|
}
|
|
else if (g_strncmp("username", q, 255) == 0)
|
|
{
|
|
/* if the username has been asked for by the module, use what the
|
|
client says.
|
|
if the username has been manually set in the config, use that
|
|
instead of what the client says. */
|
|
if (g_strncmp("ask", r, 3) == 0)
|
|
{
|
|
r = self->session->client_info->username;
|
|
}
|
|
}
|
|
else if (g_strncmp("ip", q, 255) == 0)
|
|
{
|
|
/* if the ip has been asked for by the module, use what the
|
|
client says (target ip should be in 'domain' field, when starting with "_")
|
|
if the ip has been manually set in the config, use that
|
|
instead of what the client says. */
|
|
if (g_strncmp("ask", r, 3) == 0)
|
|
{
|
|
if (self->session->client_info->domain[0] == '_')
|
|
{
|
|
g_strncpy(param, &self->session->client_info->domain[1], 255);
|
|
r = param;
|
|
}
|
|
|
|
}
|
|
}
|
|
else if (g_strncmp("port", q, 255) == 0)
|
|
{
|
|
if (g_strncmp("ask3389", r, 7) == 0)
|
|
{
|
|
r = "3389"; /* use default */
|
|
}
|
|
}
|
|
|
|
list_add_item(self->mm->login_names, (long)g_strdup(q));
|
|
list_add_item(self->mm->login_values, (long)g_strdup(r));
|
|
}
|
|
|
|
xrdp_wm_set_login_mode(self, 2);
|
|
}
|
|
else
|
|
{
|
|
/* Hopefully, we never reach here. */
|
|
log_message(LOG_LEVEL_DEBUG,
|
|
"Control should never reach %s:%d", __FILE__, __LINE__);
|
|
}
|
|
|
|
list_delete(names);
|
|
list_delete(values);
|
|
g_file_close(fd);
|
|
}
|
|
else
|
|
{
|
|
log_message(LOG_LEVEL_ERROR,"xrdp_wm_init: Could not read xrdp.ini file %s", cfg_file);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_writeln(" xrdp_wm_init: no autologin / auto run detected, draw login window");
|
|
xrdp_login_wnd_create(self);
|
|
/* clear screen */
|
|
xrdp_bitmap_invalidate(self->screen, 0);
|
|
xrdp_wm_set_focused(self, self->login_window);
|
|
xrdp_wm_set_login_mode(self, 1);
|
|
}
|
|
|
|
g_writeln("out xrdp_wm_init: ");
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* returns the number for rects visible for an area relative to a drawable */
|
|
/* putting the rects in region */
|
|
int
|
|
xrdp_wm_get_vis_region(struct xrdp_wm *self, struct xrdp_bitmap *bitmap,
|
|
int x, int y, int cx, int cy,
|
|
struct xrdp_region *region, int clip_children)
|
|
{
|
|
int i;
|
|
struct xrdp_bitmap *p;
|
|
struct xrdp_rect a;
|
|
struct xrdp_rect b;
|
|
|
|
/* area we are drawing */
|
|
MAKERECT(a, bitmap->left + x, bitmap->top + y, cx, cy);
|
|
p = bitmap->parent;
|
|
|
|
while (p != 0)
|
|
{
|
|
RECTOFFSET(a, p->left, p->top);
|
|
p = p->parent;
|
|
}
|
|
|
|
a.left = MAX(self->screen->left, a.left);
|
|
a.top = MAX(self->screen->top, a.top);
|
|
a.right = MIN(self->screen->left + self->screen->width, a.right);
|
|
a.bottom = MIN(self->screen->top + self->screen->height, a.bottom);
|
|
xrdp_region_add_rect(region, &a);
|
|
|
|
if (clip_children)
|
|
{
|
|
/* loop through all windows in z order */
|
|
for (i = 0; i < self->screen->child_list->count; i++)
|
|
{
|
|
p = (struct xrdp_bitmap *)list_get_item(self->screen->child_list, i);
|
|
|
|
if (p == bitmap || p == bitmap->parent)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
MAKERECT(b, p->left, p->top, p->width, p->height);
|
|
xrdp_region_subtract_rect(region, &b);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* return the window at x, y on the screen */
|
|
static struct xrdp_bitmap *
|
|
xrdp_wm_at_pos(struct xrdp_bitmap *wnd, int x, int y,
|
|
struct xrdp_bitmap **wnd1)
|
|
{
|
|
int i;
|
|
struct xrdp_bitmap *p;
|
|
struct xrdp_bitmap *q;
|
|
|
|
/* loop through all windows in z order */
|
|
for (i = 0; i < wnd->child_list->count; i++)
|
|
{
|
|
p = (struct xrdp_bitmap *)list_get_item(wnd->child_list, i);
|
|
|
|
if (x >= p->left && y >= p->top && x < p->left + p->width &&
|
|
y < p->top + p->height)
|
|
{
|
|
if (wnd1 != 0)
|
|
{
|
|
*wnd1 = p;
|
|
}
|
|
|
|
q = xrdp_wm_at_pos(p, x - p->left, y - p->top, 0);
|
|
|
|
if (q == 0)
|
|
{
|
|
return p;
|
|
}
|
|
else
|
|
{
|
|
return q;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
xrdp_wm_xor_pat(struct xrdp_wm *self, int x, int y, int cx, int cy)
|
|
{
|
|
self->painter->clip_children = 0;
|
|
self->painter->rop = 0x5a;
|
|
xrdp_painter_begin_update(self->painter);
|
|
self->painter->use_clip = 0;
|
|
self->painter->mix_mode = 1;
|
|
self->painter->brush.pattern[0] = 0xaa;
|
|
self->painter->brush.pattern[1] = 0x55;
|
|
self->painter->brush.pattern[2] = 0xaa;
|
|
self->painter->brush.pattern[3] = 0x55;
|
|
self->painter->brush.pattern[4] = 0xaa;
|
|
self->painter->brush.pattern[5] = 0x55;
|
|
self->painter->brush.pattern[6] = 0xaa;
|
|
self->painter->brush.pattern[7] = 0x55;
|
|
self->painter->brush.x_origin = 0;
|
|
self->painter->brush.x_origin = 0;
|
|
self->painter->brush.style = 3;
|
|
self->painter->bg_color = self->black;
|
|
self->painter->fg_color = self->white;
|
|
/* top */
|
|
xrdp_painter_fill_rect(self->painter, self->screen, x, y, cx, 5);
|
|
/* bottom */
|
|
xrdp_painter_fill_rect(self->painter, self->screen, x, y + (cy - 5), cx, 5);
|
|
/* left */
|
|
xrdp_painter_fill_rect(self->painter, self->screen, x, y + 5, 5, cy - 10);
|
|
/* right */
|
|
xrdp_painter_fill_rect(self->painter, self->screen, x + (cx - 5), y + 5, 5,
|
|
cy - 10);
|
|
xrdp_painter_end_update(self->painter);
|
|
self->painter->rop = 0xcc;
|
|
self->painter->clip_children = 1;
|
|
self->painter->mix_mode = 0;
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* return true if rect is totally exposed going in reverse z order */
|
|
/* from wnd up */
|
|
static int
|
|
xrdp_wm_is_rect_vis(struct xrdp_wm *self, struct xrdp_bitmap *wnd,
|
|
struct xrdp_rect *rect)
|
|
{
|
|
struct xrdp_rect wnd_rect;
|
|
struct xrdp_bitmap *b;
|
|
int i;;
|
|
|
|
/* if rect is part off screen */
|
|
if (rect->left < 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (rect->top < 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (rect->right >= self->screen->width)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (rect->bottom >= self->screen->height)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
i = list_index_of(self->screen->child_list, (long)wnd);
|
|
i--;
|
|
|
|
while (i >= 0)
|
|
{
|
|
b = (struct xrdp_bitmap *)list_get_item(self->screen->child_list, i);
|
|
MAKERECT(wnd_rect, b->left, b->top, b->width, b->height);
|
|
|
|
if (rect_intersect(rect, &wnd_rect, 0))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
i--;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
xrdp_wm_move_window(struct xrdp_wm *self, struct xrdp_bitmap *wnd,
|
|
int dx, int dy)
|
|
{
|
|
struct xrdp_rect rect1;
|
|
struct xrdp_rect rect2;
|
|
struct xrdp_region *r;
|
|
int i;
|
|
|
|
MAKERECT(rect1, wnd->left, wnd->top, wnd->width, wnd->height);
|
|
|
|
self->painter->clip_children = 0;
|
|
if (xrdp_wm_is_rect_vis(self, wnd, &rect1))
|
|
{
|
|
rect2 = rect1;
|
|
RECTOFFSET(rect2, dx, dy);
|
|
|
|
if (xrdp_wm_is_rect_vis(self, wnd, &rect2))
|
|
{
|
|
xrdp_painter_begin_update(self->painter);
|
|
xrdp_painter_copy(self->painter, self->screen, self->screen,
|
|
wnd->left + dx, wnd->top + dy,
|
|
wnd->width, wnd->height,
|
|
wnd->left, wnd->top);
|
|
xrdp_painter_end_update(self->painter);
|
|
|
|
wnd->left += dx;
|
|
wnd->top += dy;
|
|
r = xrdp_region_create(self);
|
|
xrdp_region_add_rect(r, &rect1);
|
|
xrdp_region_subtract_rect(r, &rect2);
|
|
i = 0;
|
|
|
|
while (xrdp_region_get_rect(r, i, &rect1) == 0)
|
|
{
|
|
xrdp_bitmap_invalidate(self->screen, &rect1);
|
|
i++;
|
|
}
|
|
|
|
xrdp_region_delete(r);
|
|
self->painter->clip_children = 1;
|
|
return 0;
|
|
}
|
|
}
|
|
self->painter->clip_children = 1;
|
|
|
|
wnd->left += dx;
|
|
wnd->top += dy;
|
|
xrdp_bitmap_invalidate(self->screen, &rect1);
|
|
xrdp_bitmap_invalidate(wnd, 0);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
xrdp_wm_undraw_dragging_box(struct xrdp_wm *self, int do_begin_end)
|
|
{
|
|
int boxx;
|
|
int boxy;
|
|
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (self->dragging)
|
|
{
|
|
if (self->draggingxorstate)
|
|
{
|
|
if (do_begin_end)
|
|
{
|
|
xrdp_painter_begin_update(self->painter);
|
|
}
|
|
|
|
boxx = self->draggingx - self->draggingdx;
|
|
boxy = self->draggingy - self->draggingdy;
|
|
xrdp_wm_xor_pat(self, boxx, boxy, self->draggingcx, self->draggingcy);
|
|
self->draggingxorstate = 0;
|
|
|
|
if (do_begin_end)
|
|
{
|
|
xrdp_painter_end_update(self->painter);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
xrdp_wm_draw_dragging_box(struct xrdp_wm *self, int do_begin_end)
|
|
{
|
|
int boxx;
|
|
int boxy;
|
|
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (self->dragging)
|
|
{
|
|
if (!self->draggingxorstate)
|
|
{
|
|
if (do_begin_end)
|
|
{
|
|
xrdp_painter_begin_update(self->painter);
|
|
}
|
|
|
|
boxx = self->draggingx - self->draggingdx;
|
|
boxy = self->draggingy - self->draggingdy;
|
|
xrdp_wm_xor_pat(self, boxx, boxy, self->draggingcx, self->draggingcy);
|
|
self->draggingxorstate = 1;
|
|
|
|
if (do_begin_end)
|
|
{
|
|
xrdp_painter_end_update(self->painter);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_mouse_move(struct xrdp_wm *self, int x, int y)
|
|
{
|
|
struct xrdp_bitmap *b;
|
|
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (x < 0)
|
|
{
|
|
x = 0;
|
|
}
|
|
|
|
if (y < 0)
|
|
{
|
|
y = 0;
|
|
}
|
|
|
|
if (x >= self->screen->width)
|
|
{
|
|
x = self->screen->width;
|
|
}
|
|
|
|
if (y >= self->screen->height)
|
|
{
|
|
y = self->screen->height;
|
|
}
|
|
|
|
self->mouse_x = x;
|
|
self->mouse_y = y;
|
|
|
|
if (self->dragging)
|
|
{
|
|
xrdp_painter_begin_update(self->painter);
|
|
xrdp_wm_undraw_dragging_box(self, 0);
|
|
self->draggingx = x;
|
|
self->draggingy = y;
|
|
xrdp_wm_draw_dragging_box(self, 0);
|
|
xrdp_painter_end_update(self->painter);
|
|
return 0;
|
|
}
|
|
|
|
b = xrdp_wm_at_pos(self->screen, x, y, 0);
|
|
|
|
if (b == 0) /* if b is null, the movement must be over the screen */
|
|
{
|
|
if (self->screen->pointer != self->current_pointer)
|
|
{
|
|
xrdp_wm_set_pointer(self, self->screen->pointer);
|
|
self->current_pointer = self->screen->pointer;
|
|
}
|
|
|
|
if (self->mm->mod != 0) /* if screen is mod controlled */
|
|
{
|
|
if (self->mm->mod->mod_event != 0)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_MOUSEMOVE, x, y, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (self->button_down != 0)
|
|
{
|
|
if (b == self->button_down && self->button_down->state == 0)
|
|
{
|
|
self->button_down->state = 1;
|
|
xrdp_bitmap_invalidate(self->button_down, 0);
|
|
}
|
|
else if (b != self->button_down)
|
|
{
|
|
self->button_down->state = 0;
|
|
xrdp_bitmap_invalidate(self->button_down, 0);
|
|
}
|
|
}
|
|
|
|
if (b != 0)
|
|
{
|
|
if (!self->dragging)
|
|
{
|
|
if (b->pointer != self->current_pointer)
|
|
{
|
|
xrdp_wm_set_pointer(self, b->pointer);
|
|
self->current_pointer = b->pointer;
|
|
}
|
|
|
|
xrdp_bitmap_def_proc(b, WM_MOUSEMOVE,
|
|
xrdp_bitmap_from_screenx(b, x),
|
|
xrdp_bitmap_from_screeny(b, y));
|
|
|
|
if (self->button_down == 0)
|
|
{
|
|
if (b->notify != 0)
|
|
{
|
|
b->notify(b->owner, b, 2, x, y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
xrdp_wm_clear_popup(struct xrdp_wm *self)
|
|
{
|
|
int i;
|
|
struct xrdp_rect rect;
|
|
//struct xrdp_bitmap* b;
|
|
|
|
//b = 0;
|
|
if (self->popup_wnd != 0)
|
|
{
|
|
//b = self->popup_wnd->popped_from;
|
|
i = list_index_of(self->screen->child_list, (long)self->popup_wnd);
|
|
list_remove_item(self->screen->child_list, i);
|
|
MAKERECT(rect, self->popup_wnd->left, self->popup_wnd->top,
|
|
self->popup_wnd->width, self->popup_wnd->height);
|
|
xrdp_bitmap_invalidate(self->screen, &rect);
|
|
xrdp_bitmap_delete(self->popup_wnd);
|
|
}
|
|
|
|
//xrdp_wm_set_focused(self, b->parent);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_mouse_click(struct xrdp_wm *self, int x, int y, int but, int down)
|
|
{
|
|
struct xrdp_bitmap *control;
|
|
struct xrdp_bitmap *focus_out_control;
|
|
struct xrdp_bitmap *wnd;
|
|
int newx;
|
|
int newy;
|
|
int oldx;
|
|
int oldy;
|
|
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (x < 0)
|
|
{
|
|
x = 0;
|
|
}
|
|
|
|
if (y < 0)
|
|
{
|
|
y = 0;
|
|
}
|
|
|
|
if (x >= self->screen->width)
|
|
{
|
|
x = self->screen->width;
|
|
}
|
|
|
|
if (y >= self->screen->height)
|
|
{
|
|
y = self->screen->height;
|
|
}
|
|
|
|
if (self->dragging && but == 1 && !down && self->dragging_window != 0)
|
|
{
|
|
/* if done dragging */
|
|
self->draggingx = x;
|
|
self->draggingy = y;
|
|
newx = self->draggingx - self->draggingdx;
|
|
newy = self->draggingy - self->draggingdy;
|
|
oldx = self->dragging_window->left;
|
|
oldy = self->dragging_window->top;
|
|
|
|
/* draw xor box one more time */
|
|
if (self->draggingxorstate)
|
|
{
|
|
xrdp_wm_xor_pat(self, newx, newy, self->draggingcx, self->draggingcy);
|
|
}
|
|
|
|
self->draggingxorstate = 0;
|
|
/* move screen to new location */
|
|
xrdp_wm_move_window(self, self->dragging_window, newx - oldx, newy - oldy);
|
|
self->dragging_window = 0;
|
|
self->dragging = 0;
|
|
}
|
|
|
|
wnd = 0;
|
|
control = xrdp_wm_at_pos(self->screen, x, y, &wnd);
|
|
|
|
if (control == 0)
|
|
{
|
|
if (self->mm->mod != 0) /* if screen is mod controlled */
|
|
{
|
|
if (self->mm->mod->mod_event != 0)
|
|
{
|
|
if (down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_MOUSEMOVE, x, y, 0, 0);
|
|
}
|
|
if (but == 1 && down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_LBUTTONDOWN, x, y, 0, 0);
|
|
}
|
|
else if (but == 1 && !down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_LBUTTONUP, x, y, 0, 0);
|
|
}
|
|
|
|
if (but == 2 && down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_RBUTTONDOWN, x, y, 0, 0);
|
|
}
|
|
else if (but == 2 && !down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_RBUTTONUP, x, y, 0, 0);
|
|
}
|
|
|
|
if (but == 3 && down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON3DOWN, x, y, 0, 0);
|
|
}
|
|
else if (but == 3 && !down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON3UP, x, y, 0, 0);
|
|
}
|
|
|
|
if (but == 4)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON4DOWN,
|
|
self->mouse_x, self->mouse_y, 0, 0);
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON4UP,
|
|
self->mouse_x, self->mouse_y, 0, 0);
|
|
}
|
|
|
|
if (but == 5)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON5DOWN,
|
|
self->mouse_x, self->mouse_y, 0, 0);
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON5UP,
|
|
self->mouse_x, self->mouse_y, 0, 0);
|
|
}
|
|
if (but == 6 && down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON6DOWN, x, y, 0, 0);
|
|
}
|
|
else if (but == 6 && !down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON6UP, x, y, 0, 0);
|
|
}
|
|
if (but == 7 && down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON7DOWN, x, y, 0, 0);
|
|
}
|
|
else if (but == 7 && !down)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, WM_BUTTON7UP, x, y, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (self->popup_wnd != 0)
|
|
{
|
|
if (self->popup_wnd == control && !down)
|
|
{
|
|
xrdp_bitmap_def_proc(self->popup_wnd, WM_LBUTTONUP, x, y);
|
|
xrdp_wm_clear_popup(self);
|
|
self->button_down = 0;
|
|
return 0;
|
|
}
|
|
else if (self->popup_wnd != control && down)
|
|
{
|
|
xrdp_wm_clear_popup(self);
|
|
self->button_down = 0;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (control != 0)
|
|
{
|
|
if (wnd != 0)
|
|
{
|
|
if (wnd->modal_dialog != 0) /* if window has a modal dialog */
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (control == wnd)
|
|
{
|
|
}
|
|
else if (control->tab_stop)
|
|
{
|
|
focus_out_control = wnd->focused_control;
|
|
wnd->focused_control = control;
|
|
xrdp_bitmap_invalidate(focus_out_control, 0);
|
|
xrdp_bitmap_invalidate(control, 0);
|
|
}
|
|
}
|
|
|
|
if ((control->type == WND_TYPE_BUTTON ||
|
|
control->type == WND_TYPE_COMBO) &&
|
|
but == 1 && !down && self->button_down == control)
|
|
{
|
|
/* if clicking up on a button that was clicked down */
|
|
self->button_down = 0;
|
|
control->state = 0;
|
|
xrdp_bitmap_invalidate(control, 0);
|
|
|
|
if (control->parent != 0)
|
|
{
|
|
if (control->parent->notify != 0)
|
|
{
|
|
/* control can be invalid after this */
|
|
control->parent->notify(control->owner, control, 1, x, y);
|
|
}
|
|
}
|
|
}
|
|
else if ((control->type == WND_TYPE_BUTTON ||
|
|
control->type == WND_TYPE_COMBO) &&
|
|
but == 1 && down)
|
|
{
|
|
/* if clicking down on a button or combo */
|
|
self->button_down = control;
|
|
control->state = 1;
|
|
xrdp_bitmap_invalidate(control, 0);
|
|
|
|
if (control->type == WND_TYPE_COMBO)
|
|
{
|
|
xrdp_wm_pu(self, control);
|
|
}
|
|
}
|
|
else if (but == 1 && down)
|
|
{
|
|
if (self->popup_wnd == 0)
|
|
{
|
|
xrdp_wm_set_focused(self, wnd);
|
|
|
|
if (control->type == WND_TYPE_WND && y < (control->top + 21))
|
|
{
|
|
/* if dragging */
|
|
if (self->dragging) /* rarely happens */
|
|
{
|
|
newx = self->draggingx - self->draggingdx;
|
|
newy = self->draggingy - self->draggingdy;
|
|
|
|
if (self->draggingxorstate)
|
|
{
|
|
xrdp_wm_xor_pat(self, newx, newy,
|
|
self->draggingcx, self->draggingcy);
|
|
}
|
|
|
|
self->draggingxorstate = 0;
|
|
}
|
|
|
|
self->dragging = 1;
|
|
self->dragging_window = control;
|
|
self->draggingorgx = control->left;
|
|
self->draggingorgy = control->top;
|
|
self->draggingx = x;
|
|
self->draggingy = y;
|
|
self->draggingdx = x - control->left;
|
|
self->draggingdy = y - control->top;
|
|
self->draggingcx = control->width;
|
|
self->draggingcy = control->height;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
xrdp_wm_set_focused(self, 0);
|
|
}
|
|
|
|
/* no matter what, mouse is up, reset button_down */
|
|
if (but == 1 && !down && self->button_down != 0)
|
|
{
|
|
self->button_down = 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_key(struct xrdp_wm *self, int device_flags, int scan_code)
|
|
{
|
|
int msg;
|
|
struct xrdp_key_info *ki;
|
|
|
|
/*g_printf("count %d\n", self->key_down_list->count);*/
|
|
scan_code = scan_code % 128;
|
|
|
|
if (self->popup_wnd != 0)
|
|
{
|
|
xrdp_wm_clear_popup(self);
|
|
return 0;
|
|
}
|
|
|
|
if (device_flags & KBD_FLAG_UP) /* 0x8000 */
|
|
{
|
|
self->keys[scan_code] = 0;
|
|
msg = WM_KEYUP;
|
|
}
|
|
else /* key down */
|
|
{
|
|
self->keys[scan_code] = 1 | device_flags;
|
|
msg = WM_KEYDOWN;
|
|
|
|
switch (scan_code)
|
|
{
|
|
case 58:
|
|
self->caps_lock = !self->caps_lock;
|
|
break; /* caps lock */
|
|
case 69:
|
|
self->num_lock = !self->num_lock;
|
|
break; /* num lock */
|
|
case 70:
|
|
self->scroll_lock = !self->scroll_lock;
|
|
break; /* scroll lock */
|
|
}
|
|
}
|
|
|
|
if (self->mm->mod != 0)
|
|
{
|
|
if (self->mm->mod->mod_event != 0)
|
|
{
|
|
ki = get_key_info_from_scan_code
|
|
(device_flags, scan_code, self->keys, self->caps_lock,
|
|
self->num_lock, self->scroll_lock,
|
|
&(self->keymap));
|
|
|
|
if (ki != 0)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, msg, ki->chr, ki->sym,
|
|
scan_code, device_flags);
|
|
}
|
|
}
|
|
}
|
|
else if (self->focused_window != 0)
|
|
{
|
|
xrdp_bitmap_def_proc(self->focused_window,
|
|
msg, scan_code, device_flags);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* happens when client gets focus and sends key modifier info */
|
|
int
|
|
xrdp_wm_key_sync(struct xrdp_wm *self, int device_flags, int key_flags)
|
|
{
|
|
self->num_lock = 0;
|
|
self->scroll_lock = 0;
|
|
self->caps_lock = 0;
|
|
|
|
if (key_flags & 1)
|
|
{
|
|
self->scroll_lock = 1;
|
|
}
|
|
|
|
if (key_flags & 2)
|
|
{
|
|
self->num_lock = 1;
|
|
}
|
|
|
|
if (key_flags & 4)
|
|
{
|
|
self->caps_lock = 1;
|
|
}
|
|
|
|
if (self->mm->mod != 0)
|
|
{
|
|
if (self->mm->mod->mod_event != 0)
|
|
{
|
|
self->mm->mod->mod_event(self->mm->mod, 17, key_flags, device_flags,
|
|
key_flags, device_flags);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_key_unicode(struct xrdp_wm *self, int device_flags, int unicode)
|
|
{
|
|
int index;
|
|
|
|
for (index = XR_MIN_KEY_CODE; index < XR_MAX_KEY_CODE; index++)
|
|
{
|
|
if (unicode == self->keymap.keys_noshift[index].chr)
|
|
{
|
|
xrdp_wm_key(self, device_flags, index - XR_MIN_KEY_CODE);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
for (index = XR_MIN_KEY_CODE; index < XR_MAX_KEY_CODE; index++)
|
|
{
|
|
if (unicode == self->keymap.keys_shift[index].chr)
|
|
{
|
|
if (device_flags & KBD_FLAG_UP)
|
|
{
|
|
xrdp_wm_key(self, device_flags, index - XR_MIN_KEY_CODE);
|
|
xrdp_wm_key(self, KBD_FLAG_UP, XR_RDP_SCAN_LSHIFT);
|
|
}
|
|
else
|
|
{
|
|
xrdp_wm_key(self, KBD_FLAG_DOWN, XR_RDP_SCAN_LSHIFT);
|
|
xrdp_wm_key(self, device_flags, index - XR_MIN_KEY_CODE);
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
for (index = XR_MIN_KEY_CODE; index < XR_MAX_KEY_CODE; index++)
|
|
{
|
|
if (unicode == self->keymap.keys_altgr[index].chr)
|
|
{
|
|
if (device_flags & KBD_FLAG_UP)
|
|
{
|
|
xrdp_wm_key(self, device_flags, index - XR_MIN_KEY_CODE);
|
|
xrdp_wm_key(self, KBD_FLAG_UP | KBD_FLAG_EXT,
|
|
XR_RDP_SCAN_ALT);
|
|
}
|
|
else
|
|
{
|
|
xrdp_wm_key(self, KBD_FLAG_DOWN | KBD_FLAG_EXT,
|
|
XR_RDP_SCAN_ALT);
|
|
xrdp_wm_key(self, device_flags, index - XR_MIN_KEY_CODE);
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
for (index = XR_MIN_KEY_CODE; index < XR_MAX_KEY_CODE; index++)
|
|
{
|
|
if (unicode == self->keymap.keys_shiftaltgr[index].chr)
|
|
{
|
|
if (device_flags & KBD_FLAG_UP)
|
|
{
|
|
xrdp_wm_key(self, device_flags, index - XR_MIN_KEY_CODE);
|
|
xrdp_wm_key(self, KBD_FLAG_UP | KBD_FLAG_EXT, XR_RDP_SCAN_ALT);
|
|
xrdp_wm_key(self, KBD_FLAG_UP, XR_RDP_SCAN_LSHIFT);
|
|
}
|
|
else
|
|
{
|
|
xrdp_wm_key(self, KBD_FLAG_DOWN, XR_RDP_SCAN_LSHIFT);
|
|
xrdp_wm_key(self, KBD_FLAG_DOWN | KBD_FLAG_EXT,
|
|
XR_RDP_SCAN_ALT);
|
|
xrdp_wm_key(self, device_flags, index - XR_MIN_KEY_CODE);
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_pu(struct xrdp_wm *self, struct xrdp_bitmap *control)
|
|
{
|
|
int x;
|
|
int y;
|
|
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (control == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
self->popup_wnd = xrdp_bitmap_create(control->width, DEFAULT_WND_SPECIAL_H,
|
|
self->screen->bpp,
|
|
WND_TYPE_SPECIAL, self);
|
|
self->popup_wnd->popped_from = control;
|
|
self->popup_wnd->parent = self->screen;
|
|
self->popup_wnd->owner = self->screen;
|
|
x = xrdp_bitmap_to_screenx(control, 0);
|
|
y = xrdp_bitmap_to_screeny(control, 0);
|
|
self->popup_wnd->left = x;
|
|
self->popup_wnd->top = y + control->height;
|
|
self->popup_wnd->item_index = control->item_index;
|
|
list_insert_item(self->screen->child_list, 0, (long)self->popup_wnd);
|
|
xrdp_bitmap_invalidate(self->popup_wnd, 0);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
xrdp_wm_process_input_mouse(struct xrdp_wm *self, int device_flags,
|
|
int x, int y)
|
|
{
|
|
DEBUG(("mouse event flags %4.4x x %d y %d", device_flags, x, y));
|
|
|
|
if (device_flags & MOUSE_FLAG_MOVE) /* 0x0800 */
|
|
{
|
|
xrdp_wm_mouse_move(self, x, y);
|
|
}
|
|
|
|
if (device_flags & MOUSE_FLAG_BUTTON1) /* 0x1000 */
|
|
{
|
|
if (device_flags & MOUSE_FLAG_DOWN) /* 0x8000 */
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 1, 1);
|
|
}
|
|
else
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 1, 0);
|
|
}
|
|
}
|
|
|
|
if (device_flags & MOUSE_FLAG_BUTTON2) /* 0x2000 */
|
|
{
|
|
if (device_flags & MOUSE_FLAG_DOWN) /* 0x8000 */
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 2, 1);
|
|
}
|
|
else
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 2, 0);
|
|
}
|
|
}
|
|
|
|
if (device_flags & MOUSE_FLAG_BUTTON3) /* 0x4000 */
|
|
{
|
|
if (device_flags & MOUSE_FLAG_DOWN) /* 0x8000 */
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 3, 1);
|
|
}
|
|
else
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 3, 0);
|
|
}
|
|
}
|
|
|
|
if (device_flags & 0x200) /* PTRFLAGS_WHEEL */
|
|
{
|
|
if (device_flags & 0x100) /* PTRFLAGS_WHEEL_NEGATIVE */
|
|
{
|
|
xrdp_wm_mouse_click(self, 0, 0, 5, 0);
|
|
}
|
|
else
|
|
{
|
|
xrdp_wm_mouse_click(self, 0, 0, 4, 0);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
xrdp_wm_process_input_mousex(struct xrdp_wm* self, int device_flags,
|
|
int x, int y)
|
|
{
|
|
if (device_flags & 0x8000) /* PTRXFLAGS_DOWN */
|
|
{
|
|
if (device_flags & 0x0001) /* PTRXFLAGS_BUTTON1 */
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 6, 1);
|
|
}
|
|
else if (device_flags & 0x0002) /* PTRXFLAGS_BUTTON2 */
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 7, 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (device_flags & 0x0001) /* PTRXFLAGS_BUTTON1 */
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 6, 0);
|
|
}
|
|
else if (device_flags & 0x0002) /* PTRXFLAGS_BUTTON2 */
|
|
{
|
|
xrdp_wm_mouse_click(self, x, y, 7, 0);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* param1 = MAKELONG(channel_id, flags)
|
|
param2 = size
|
|
param3 = pointer to data
|
|
param4 = total size */
|
|
static int
|
|
xrdp_wm_process_channel_data(struct xrdp_wm *self,
|
|
tbus param1, tbus param2,
|
|
tbus param3, tbus param4)
|
|
{
|
|
int rv;
|
|
int chanid ;
|
|
rv = 1;
|
|
|
|
if (self->mm->mod != 0)
|
|
{
|
|
chanid = LOWORD(param1);
|
|
|
|
if (is_channel_allowed(self, chanid))
|
|
{
|
|
if (self->mm->usechansrv)
|
|
{
|
|
rv = xrdp_mm_process_channel_data(self->mm, param1, param2,
|
|
param3, param4);
|
|
}
|
|
else
|
|
{
|
|
if (self->mm->mod->mod_event != 0)
|
|
{
|
|
rv = self->mm->mod->mod_event(self->mm->mod, 0x5555, param1, param2,
|
|
param3, param4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* this is the callbacks coming from libxrdp.so */
|
|
int
|
|
callback(intptr_t id, int msg, intptr_t param1, intptr_t param2,
|
|
intptr_t param3, intptr_t param4)
|
|
{
|
|
int rv;
|
|
struct xrdp_wm *wm;
|
|
struct xrdp_rect rect;
|
|
|
|
if (id == 0) /* "id" should be "struct xrdp_process*" as long */
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
wm = ((struct xrdp_process *)id)->wm;
|
|
|
|
if (wm == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
rv = 0;
|
|
|
|
switch (msg)
|
|
{
|
|
case RDP_INPUT_SYNCHRONIZE:
|
|
rv = xrdp_wm_key_sync(wm, param3, param1);
|
|
break;
|
|
case RDP_INPUT_SCANCODE:
|
|
rv = xrdp_wm_key(wm, param3, param1);
|
|
break;
|
|
case RDP_INPUT_UNICODE:
|
|
rv = xrdp_wm_key_unicode(wm, param3, param1);
|
|
break;
|
|
case RDP_INPUT_MOUSE:
|
|
rv = xrdp_wm_process_input_mouse(wm, param3, param1, param2);
|
|
break;
|
|
case RDP_INPUT_MOUSEX:
|
|
rv = xrdp_wm_process_input_mousex(wm, param3, param1, param2);
|
|
break;
|
|
case 0x4444: /* invalidate, this is not from RDP_DATA_PDU_INPUT */
|
|
/* like the rest, it's from RDP_PDU_DATA with code 33 */
|
|
/* it's the rdp client asking for a screen update */
|
|
MAKERECT(rect, param1, param2, param3, param4);
|
|
rv = xrdp_bitmap_invalidate(wm->screen, &rect);
|
|
break;
|
|
case 0x5555: /* called from xrdp_channel.c, channel data has come in,
|
|
pass it to module if there is one */
|
|
rv = xrdp_wm_process_channel_data(wm, param1, param2, param3, param4);
|
|
break;
|
|
case 0x5556:
|
|
rv = xrdp_mm_check_chan(wm->mm);
|
|
break;
|
|
case 0x5557:
|
|
//g_writeln("callback: frame ack %d", param1);
|
|
xrdp_mm_frame_ack(wm->mm, param1);
|
|
break;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* returns error */
|
|
/* this gets called when there is nothing on any socket */
|
|
static int
|
|
xrdp_wm_login_mode_changed(struct xrdp_wm *self)
|
|
{
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
g_writeln("xrdp_wm_login_mode_changed: login_mode is %d", self->login_mode);
|
|
|
|
if (self->login_mode == 0)
|
|
{
|
|
/* this is the initial state of the login window */
|
|
xrdp_wm_set_login_mode(self, 1); /* put the wm in login mode */
|
|
list_clear(self->log);
|
|
xrdp_wm_delete_all_children(self);
|
|
self->dragging = 0;
|
|
xrdp_wm_init(self);
|
|
}
|
|
else if (self->login_mode == 2)
|
|
{
|
|
if (xrdp_mm_connect(self->mm) == 0)
|
|
{
|
|
xrdp_wm_set_login_mode(self, 3); /* put the wm in connected mode */
|
|
xrdp_wm_delete_all_children(self);
|
|
self->dragging = 0;
|
|
}
|
|
else
|
|
{
|
|
/* we do nothing on connect error so far */
|
|
}
|
|
}
|
|
else if (self->login_mode == 10)
|
|
{
|
|
xrdp_wm_delete_all_children(self);
|
|
self->dragging = 0;
|
|
xrdp_wm_set_login_mode(self, 11);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* this is the log windows notify function */
|
|
static int
|
|
xrdp_wm_log_wnd_notify(struct xrdp_bitmap *wnd,
|
|
struct xrdp_bitmap *sender,
|
|
int msg, long param1, long param2)
|
|
{
|
|
struct xrdp_painter *painter;
|
|
struct xrdp_wm *wm;
|
|
struct xrdp_rect rect;
|
|
int index;
|
|
char *text;
|
|
|
|
if (wnd == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (sender == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (wnd->owner == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
wm = wnd->wm;
|
|
|
|
if (msg == 1) /* click */
|
|
{
|
|
if (sender->id == 1) /* ok button */
|
|
{
|
|
/* close the log window */
|
|
MAKERECT(rect, wnd->left, wnd->top, wnd->width, wnd->height);
|
|
xrdp_bitmap_delete(wnd);
|
|
xrdp_bitmap_invalidate(wm->screen, &rect);
|
|
|
|
/* if module is gone, reset the session when ok is clicked */
|
|
if (wm->mm->mod_handle == 0)
|
|
{
|
|
/* make sure autologin is off */
|
|
wm->session->client_info->rdp_autologin = 0;
|
|
xrdp_wm_set_login_mode(wm, 0); /* reset session */
|
|
}
|
|
}
|
|
}
|
|
else if (msg == WM_PAINT) /* 3 */
|
|
{
|
|
painter = (struct xrdp_painter *)param1;
|
|
|
|
if (painter != 0)
|
|
{
|
|
painter->fg_color = wnd->wm->black;
|
|
|
|
for (index = 0; index < wnd->wm->log->count; index++)
|
|
{
|
|
text = (char *)list_get_item(wnd->wm->log, index);
|
|
xrdp_painter_draw_text(painter, wnd, 10, 30 + index * 15, text);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
add_string_to_logwindow(const char *msg, struct list *log)
|
|
{
|
|
const char *new_part_message;
|
|
const char *current_pointer = msg;
|
|
int len_done = 0;
|
|
|
|
do
|
|
{
|
|
new_part_message = g_strndup(current_pointer, LOG_WINDOW_CHAR_PER_LINE);
|
|
g_writeln("%s", new_part_message);
|
|
list_add_item(log, (tintptr) new_part_message);
|
|
len_done += g_strlen(new_part_message);
|
|
current_pointer += g_strlen(new_part_message);
|
|
} while ((len_done < g_strlen(msg)) && (len_done < DEFAULT_STRING_LEN));
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_show_log(struct xrdp_wm *self)
|
|
{
|
|
struct xrdp_bitmap *but;
|
|
int w;
|
|
int h;
|
|
int xoffset;
|
|
int yoffset;
|
|
int index;
|
|
int primary_x_offset;
|
|
int primary_y_offset;
|
|
|
|
|
|
if (self->hide_log_window)
|
|
{
|
|
/* make sure autologin is off */
|
|
self->session->client_info->rdp_autologin = 0;
|
|
xrdp_wm_set_login_mode(self, 0); /* reset session */
|
|
return 0;
|
|
}
|
|
|
|
if (self->log_wnd == 0)
|
|
{
|
|
w = DEFAULT_WND_LOG_W;
|
|
h = DEFAULT_WND_LOG_H;
|
|
xoffset = 10;
|
|
yoffset = 10;
|
|
|
|
if (self->screen->width < w)
|
|
{
|
|
w = self->screen->width - 4;
|
|
xoffset = 2;
|
|
}
|
|
|
|
if (self->screen->height < h)
|
|
{
|
|
h = self->screen->height - 4;
|
|
yoffset = 2;
|
|
}
|
|
|
|
primary_x_offset = 0;
|
|
primary_y_offset = 0;
|
|
|
|
/* multimon scenario, draw log window on primary monitor */
|
|
if (self->client_info->monitorCount > 1)
|
|
{
|
|
for (index = 0; index < self->client_info->monitorCount; index++)
|
|
{
|
|
if (self->client_info->minfo_wm[index].is_primary)
|
|
{
|
|
primary_x_offset = self->client_info->minfo_wm[index].left;
|
|
primary_y_offset = self->client_info->minfo_wm[index].top;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* log window */
|
|
self->log_wnd = xrdp_bitmap_create(w, h, self->screen->bpp,
|
|
WND_TYPE_WND, self);
|
|
list_add_item(self->screen->child_list, (long)self->log_wnd);
|
|
self->log_wnd->parent = self->screen;
|
|
self->log_wnd->owner = self->screen;
|
|
self->log_wnd->bg_color = self->grey;
|
|
self->log_wnd->left = primary_x_offset + xoffset;
|
|
self->log_wnd->top = primary_y_offset + yoffset;
|
|
set_string(&(self->log_wnd->caption1), "Connection Log");
|
|
/* ok button */
|
|
but = xrdp_bitmap_create(DEFAULT_BUTTON_W, DEFAULT_BUTTON_H, self->screen->bpp, WND_TYPE_BUTTON, self);
|
|
list_insert_item(self->log_wnd->child_list, 0, (long)but);
|
|
but->parent = self->log_wnd;
|
|
but->owner = self->log_wnd;
|
|
but->left = (w - DEFAULT_BUTTON_W) - xoffset;
|
|
but->top = (h - DEFAULT_BUTTON_H) - yoffset;
|
|
but->id = 1;
|
|
but->tab_stop = 1;
|
|
set_string(&but->caption1, "OK");
|
|
self->log_wnd->focused_control = but;
|
|
/* set notify function */
|
|
self->log_wnd->notify = xrdp_wm_log_wnd_notify;
|
|
}
|
|
|
|
xrdp_wm_set_focused(self, self->log_wnd);
|
|
xrdp_bitmap_invalidate(self->log_wnd, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_log_msg(struct xrdp_wm *self, enum logLevels loglevel,
|
|
const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
char msg[256];
|
|
|
|
va_start(ap, fmt);
|
|
vsnprintf(msg, sizeof(msg), fmt, ap);
|
|
va_end(ap);
|
|
|
|
log_message(loglevel, "xrdp_wm_log_msg: %s", msg);
|
|
add_string_to_logwindow(msg, self->log);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_get_wait_objs(struct xrdp_wm *self, tbus *robjs, int *rc,
|
|
tbus *wobjs, int *wc, int *timeout)
|
|
{
|
|
int i;
|
|
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
i = *rc;
|
|
robjs[i++] = self->login_mode_event;
|
|
*rc = i;
|
|
return xrdp_mm_get_wait_objs(self->mm, robjs, rc, wobjs, wc, timeout);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
int
|
|
xrdp_wm_check_wait_objs(struct xrdp_wm *self)
|
|
{
|
|
int rv;
|
|
|
|
if (self == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
rv = 0;
|
|
|
|
if (g_is_wait_obj_set(self->login_mode_event))
|
|
{
|
|
g_reset_wait_obj(self->login_mode_event);
|
|
xrdp_wm_login_mode_changed(self);
|
|
}
|
|
|
|
if (rv == 0)
|
|
{
|
|
rv = xrdp_mm_check_wait_objs(self->mm);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
xrdp_wm_set_login_mode(struct xrdp_wm *self, int login_mode)
|
|
{
|
|
self->login_mode = login_mode;
|
|
g_set_wait_obj(self->login_mode_event);
|
|
return 0;
|
|
}
|