proto.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
RD_BOOL	bitmap_decompress (uint8 *output, int width, int height, uint8 *input, int size, int Bpp)
void	cache_rebuild_bmpcache_linked_list (uint8 id, sint16 *idx, int count)
void	cache_bump_bitmap (uint8 id, uint16 idx, int bump)
void	cache_evict_bitmap (uint8 id)
RD_HBITMAP	cache_get_bitmap (uint8 id, uint16 idx)
void	cache_put_bitmap (uint8 id, uint16 idx, RD_HBITMAP bitmap)
void	cache_save_state (void)
FONTGLYPH *	cache_get_font (uint8 font, uint16 character)
void	cache_put_font (uint8 font, uint16 character, uint16 offset, uint16 baseline, uint16 width, uint16 height, RD_HGLYPH pixmap)
DATABLOB *	cache_get_text (uint8 cache_id)
void	cache_put_text (uint8 cache_id, void *data, int length)
uint8 *	cache_get_desktop (uint32 offset, int cx, int cy, int bytes_per_pixel)
void	cache_put_desktop (uint32 offset, int cx, int cy, int scanline, int bytes_per_pixel, uint8 *data)
RD_HCURSOR	cache_get_cursor (uint16 cache_idx)
void	cache_put_cursor (uint16 cache_idx, RD_HCURSOR cursor)
BRUSHDATA *	cache_get_brush_data (uint8 colour_code, uint8 idx)
void	cache_put_brush_data (uint8 colour_code, uint8 idx, BRUSHDATA *brush_data)
VCHANNEL *	channel_register (char *name, uint32 flags, void(*callback)(STREAM))
STREAM	channel_init (VCHANNEL *channel, uint32 length)
void	channel_send (STREAM s, VCHANNEL *channel)
void	channel_process (STREAM s, uint16 mcs_channel)
void	cliprdr_send_simple_native_format_announce (uint32 format)
void	cliprdr_send_native_format_announce (uint8 *formats_data, uint32 formats_data_length)
void	cliprdr_send_data_request (uint32 format)
void	cliprdr_send_data (uint8 *data, uint32 length)
void	cliprdr_set_mode (const char *optarg)
RD_BOOL	cliprdr_init (void)
int	ctrl_init (const char *user, const char *domain, const char *host)
void	ctrl_cleanup ()
RD_BOOL	ctrl_is_slave ()
int	ctrl_send_command (const char *cmd, const char *args)
void	ctrl_add_fds (int *n, fd_set *rfds)
void	ctrl_check_fds (fd_set *rfds, fd_set *wfds)
int	disk_enum_devices (uint32 *id, char *optarg)
RD_NTSTATUS	disk_query_information (RD_NTHANDLE handle, uint32 info_class, STREAM out)
RD_NTSTATUS	disk_set_information (RD_NTHANDLE handle, uint32 info_class, STREAM in, STREAM out)
RD_NTSTATUS	disk_check_notify (RD_NTHANDLE handle)
RD_NTSTATUS	disk_create_notify (RD_NTHANDLE handle, uint32 info_class)
RD_NTSTATUS	disk_query_volume_information (RD_NTHANDLE handle, uint32 info_class, STREAM out)
RD_NTSTATUS	disk_query_directory (RD_NTHANDLE handle, uint32 info_class, char *pattern, STREAM out)
int	mppc_expand (uint8 *data, uint32 clen, uint8 ctype, uint32 *roff, uint32 *rlen)
int	get_current_workarea (uint32 *x, uint32 *y, uint32 *width, uint32 *height)
void	ewmh_init (void)
STREAM	iso_init (int length)
void	iso_send (STREAM s)
STREAM	iso_recv (uint8 *rdpver)
RD_BOOL	iso_connect (char *server, char *username, char *domain, char *password, RD_BOOL reconnect, uint32 *selected_protocol)
void	iso_disconnect (void)
void	iso_reset_state (void)
RD_BOOL	cssp_connect (char *server, char *user, char *domain, char *password, STREAM s)
void	licence_process (STREAM s)
STREAM	mcs_init (int length)
void	mcs_send_to_channel (STREAM s, uint16 channel)
void	mcs_send (STREAM s)
STREAM	mcs_recv (uint16 *channel, uint8 *rdpver)
RD_BOOL	mcs_connect_start (char *server, char *username, char *domain, char *password, RD_BOOL reconnect, uint32 *selected_protocol)
RD_BOOL	mcs_connect_finalize (STREAM s)
void	mcs_disconnect (void)
void	mcs_reset_state (void)
void	process_orders (STREAM s, uint16 num_orders)
void	reset_order_state (void)
int	parallel_enum_devices (uint32 *id, char *optarg)
int	printer_enum_devices (uint32 *id, char *optarg)
int	printercache_load_blob (char *printer_name, uint8 **data)
void	printercache_process (STREAM s)
void	pstcache_touch_bitmap (uint8 cache_id, uint16 cache_idx, uint32 stamp)
RD_BOOL	pstcache_load_bitmap (uint8 cache_id, uint16 cache_idx)
RD_BOOL	pstcache_save_bitmap (uint8 cache_id, uint16 cache_idx, uint8 *key, uint8 width, uint8 height, uint16 length, uint8 *data)
int	pstcache_enumerate (uint8 id, HASH_KEY *keylist)
RD_BOOL	pstcache_init (uint8 cache_id)
int	main (int argc, char *argv[])
void	generate_random (uint8 *random)
void *	xmalloc (int size)
void	exit_if_null (void *ptr)
char *	xstrdup (const char *s)
void *	xrealloc (void *oldmem, size_t size)
void	xfree (void *mem)
void	error (char *format,...)
void	warning (char *format,...)
void	unimpl (char *format,...)
void	hexdump (unsigned char *p, unsigned int len)
char *	next_arg (char *src, char needle)
void	toupper_str (char *p)
RD_BOOL	str_startswith (const char *s, const char *prefix)
RD_BOOL	str_handle_lines (const char *input, char **rest, str_handle_lines_t linehandler, void *data)
RD_BOOL	subprocess (char *const argv[], str_handle_lines_t linehandler, void *data)
char *	l_to_a (long N, int base)
int	load_licence (unsigned char **data)
void	save_licence (unsigned char *data, int length)
void	rd_create_ui (void)
RD_BOOL	rd_pstcache_mkdir (void)
int	rd_open_file (char *filename)
void	rd_close_file (int fd)
int	rd_read_file (int fd, void *ptr, int len)
int	rd_write_file (int fd, void *ptr, int len)
int	rd_lseek_file (int fd, int offset)
RD_BOOL	rd_lock_file (int fd, int start, int len)
void	rdp5_process (STREAM s)
void	rdp_out_unistr (STREAM s, char *string, int len)
void	rdp_in_unistr (STREAM s, int in_len, char **string, uint32 *str_size)
void	rdp_send_input (uint32 time, uint16 message_type, uint16 device_flags, uint16 param1, uint16 param2)
void	rdp_send_client_window_status (int status)
void	process_colour_pointer_pdu (STREAM s)
void	process_new_pointer_pdu (STREAM s)
void	process_cached_pointer_pdu (STREAM s)
void	process_system_pointer_pdu (STREAM s)
void	process_bitmap_updates (STREAM s)
void	process_palette (STREAM s)
void	process_disconnect_pdu (STREAM s, uint32 *ext_disc_reason)
void	rdp_main_loop (RD_BOOL *deactivated, uint32 *ext_disc_reason)
RD_BOOL	rdp_loop (RD_BOOL *deactivated, uint32 *ext_disc_reason)
RD_BOOL	rdp_connect (char *server, uint32 flags, char *domain, char *password, char *command, char *directory, RD_BOOL reconnect)
void	rdp_reset_state (void)
void	rdp_disconnect (void)
int	get_device_index (RD_NTHANDLE handle)
void	convert_to_unix_filename (char *filename)
void	rdpdr_send_completion (uint32 device, uint32 id, uint32 status, uint32 result, uint8 *buffer, uint32 length)
RD_BOOL	rdpdr_init ()
void	rdpdr_add_fds (int *n, fd_set *rfds, fd_set *wfds, struct timeval *tv, RD_BOOL *timeout)
struct async_iorequest *	rdpdr_remove_iorequest (struct async_iorequest *prev, struct async_iorequest *iorq)
void	rdpdr_check_fds (fd_set *rfds, fd_set *wfds, RD_BOOL timed_out)
RD_BOOL	rdpdr_abort_io (uint32 fd, uint32 major, RD_NTSTATUS status)
void	rdpsnd_record (const void *data, unsigned int size)
RD_BOOL	rdpsnd_init (char *optarg)
void	rdpsnd_show_help (void)
void	rdpsnd_add_fds (int *n, fd_set *rfds, fd_set *wfds, struct timeval *tv)
void	rdpsnd_check_fds (fd_set *rfds, fd_set *wfds)
struct audio_packet *	rdpsnd_queue_current_packet (void)
RD_BOOL	rdpsnd_queue_empty (void)
void	rdpsnd_queue_next (unsigned long completed_in_us)
int	rdpsnd_queue_next_tick (void)
void	rdpsnd_reset_state (void)
void	sec_hash_to_string (char *out, int out_size, uint8 *in, int in_size)
void	sec_hash_sha1_16 (uint8 *out, uint8 *in, uint8 *salt1)
void	sec_hash_48 (uint8 *out, uint8 *in, uint8 *salt1, uint8 *salt2, uint8 salt)
void	sec_hash_16 (uint8 *out, uint8 *in, uint8 *salt1, uint8 *salt2)
void	buf_out_uint32 (uint8 *buffer, uint32 value)
void	sec_sign (uint8 *signature, int siglen, uint8 *session_key, int keylen, uint8 *data, int datalen)
void	sec_decrypt (uint8 *data, int length)
STREAM	sec_init (uint32 flags, int maxlen)
void	sec_send_to_channel (STREAM s, uint32 flags, uint16 channel)
void	sec_send (STREAM s, uint32 flags)
void	sec_process_mcs_data (STREAM s)
STREAM	sec_recv (uint8 *rdpver)
RD_BOOL	sec_connect (char *server, char *username, char *domain, char *password, RD_BOOL reconnect)
void	sec_disconnect (void)
void	sec_reset_state (void)
int	serial_enum_devices (uint32 *id, char *optarg)
RD_BOOL	serial_get_event (RD_NTHANDLE handle, uint32 *result)
RD_BOOL	serial_get_timeout (RD_NTHANDLE handle, uint32 length, uint32 *timeout, uint32 *itv_timeout)
STREAM	tcp_init (uint32 maxlen)
void	tcp_send (STREAM s)
STREAM	tcp_recv (STREAM s, uint32 length)
RD_BOOL	tcp_connect (char *server)
void	tcp_disconnect (void)
char *	tcp_get_address (void)
RD_BOOL	tcp_is_connected (void)
void	tcp_reset_state (void)
RD_BOOL	tcp_tls_connect (void)
RD_BOOL	tcp_tls_get_server_pubkey (STREAM s)
void	tcp_run_ui (RD_BOOL run)
RD_BOOL	ber_in_header (STREAM s, int *tagval, int *length)
void	ber_out_header (STREAM s, int tagval, int length)
RD_BOOL	ber_parse_header (STREAM s, int tagval, int *length)
void	ber_out_integer (STREAM s, int value)
void	ui_clip_format_announce (uint8 *data, uint32 length)
void	ui_clip_handle_data (uint8 *data, uint32 length)
void	ui_clip_request_failed (void)
void	ui_clip_request_data (uint32 format)
void	ui_clip_sync (void)
void	ui_clip_set_mode (const char *optarg)
void	xclip_init (void)
void	xclip_deinit (void)
RD_BOOL	xkeymap_from_locale (const char *locale)
FILE *	xkeymap_open (const char *filename)
void	xkeymap_init (void)
RD_BOOL	handle_special_keys (uint32 keysym, unsigned int state, uint32 ev_time, RD_BOOL pressed)
key_translation	xkeymap_translate_key (uint32 keysym, unsigned int keycode, unsigned int state)
void	xkeymap_send_keys (uint32 keysym, unsigned int keycode, unsigned int state, uint32 ev_time, RD_BOOL pressed, uint8 nesting)
uint16	xkeymap_translate_button (unsigned int button)
char *	get_ksname (uint32 keysym)
void	save_remote_modifiers (uint8 scancode)
void	restore_remote_modifiers (uint32 ev_time, uint8 scancode)
void	ensure_remote_modifiers (uint32 ev_time, key_translation tr)
unsigned int	read_keyboard_state (void)
uint16	ui_get_numlock_state (unsigned int state)
void	reset_modifier_keys (void)
void	rdp_send_scancode (uint32 time, uint16 flags, uint8 scancode)
RD_BOOL	get_key_state (unsigned int state, uint32 keysym)
RD_BOOL	ui_init (void)
void	ui_init_connection (void)
void	ui_deinit (void)
RD_BOOL	ui_create_window (void)
void	ui_resize_window (void)
void	ui_destroy_window (void)
RD_BOOL	ui_have_window (void)
void	xwin_toggle_fullscreen (void)
int	ui_select (int rdp_socket)
void	ui_move_pointer (int x, int y)
RD_HBITMAP	ui_create_bitmap (int width, int height, uint8 *data)
void	ui_paint_bitmap (int x, int y, int cx, int cy, int width, int height, uint8 *data)
void	ui_destroy_bitmap (RD_HBITMAP bmp)
RD_HGLYPH	ui_create_glyph (int width, int height, uint8 *data)
void	ui_destroy_glyph (RD_HGLYPH glyph)
RD_HCURSOR	ui_create_cursor (unsigned int x, unsigned int y, int width, int height, uint8 *andmask, uint8 *xormask, int bpp)
void	ui_set_cursor (RD_HCURSOR cursor)
void	ui_destroy_cursor (RD_HCURSOR cursor)
void	ui_set_null_cursor (void)
RD_HCOLOURMAP	ui_create_colourmap (COLOURMAP *colours)
void	ui_destroy_colourmap (RD_HCOLOURMAP map)
void	ui_set_colourmap (RD_HCOLOURMAP map)
void	ui_set_clip (int x, int y, int cx, int cy)
void	ui_reset_clip (void)
void	ui_bell (void)
void	ui_destblt (uint8 opcode, int x, int y, int cx, int cy)
void	ui_patblt (uint8 opcode, int x, int y, int cx, int cy, BRUSH *brush, int bgcolour, int fgcolour)
void	ui_screenblt (uint8 opcode, int x, int y, int cx, int cy, int srcx, int srcy)
void	ui_memblt (uint8 opcode, int x, int y, int cx, int cy, RD_HBITMAP src, int srcx, int srcy)
void	ui_triblt (uint8 opcode, int x, int y, int cx, int cy, RD_HBITMAP src, int srcx, int srcy, BRUSH *brush, int bgcolour, int fgcolour)
void	ui_line (uint8 opcode, int startx, int starty, int endx, int endy, PEN *pen)
void	ui_rect (int x, int y, int cx, int cy, int colour)
void	ui_polygon (uint8 opcode, uint8 fillmode, RD_POINT *point, int npoints, BRUSH *brush, int bgcolour, int fgcolour)
void	ui_polyline (uint8 opcode, RD_POINT *points, int npoints, PEN *pen)
void	ui_ellipse (uint8 opcode, uint8 fillmode, int x, int y, int cx, int cy, BRUSH *brush, int bgcolour, int fgcolour)
void	ui_draw_glyph (int mixmode, int x, int y, int cx, int cy, RD_HGLYPH glyph, int srcx, int srcy, int bgcolour, int fgcolour)
void	ui_draw_text (uint8 font, uint8 flags, uint8 opcode, int mixmode, int x, int y, int clipx, int clipy, int clipcx, int clipcy, int boxx, int boxy, int boxcx, int boxcy, BRUSH *brush, int bgcolour, int fgcolour, uint8 *text, uint8 length)
void	ui_desktop_save (uint32 offset, int x, int y, int cx, int cy)
void	ui_desktop_restore (uint32 offset, int x, int y, int cx, int cy)
void	ui_begin_update (void)
void	ui_end_update (void)
void	ui_seamless_begin (RD_BOOL hidden)
void	ui_seamless_end ()
void	ui_seamless_hide_desktop (void)
void	ui_seamless_unhide_desktop (void)
void	ui_seamless_toggle (void)
void	ui_seamless_create_window (unsigned long id, unsigned long group, unsigned long parent, unsigned long flags)
void	ui_seamless_destroy_window (unsigned long id, unsigned long flags)
void	ui_seamless_destroy_group (unsigned long id, unsigned long flags)
void	ui_seamless_seticon (unsigned long id, const char *format, int width, int height, int chunk, const char *data, int chunk_len)
void	ui_seamless_delicon (unsigned long id, const char *format, int width, int height)
void	ui_seamless_move_window (unsigned long id, int x, int y, int width, int height, unsigned long flags)
void	ui_seamless_restack_window (unsigned long id, unsigned long behind, unsigned long flags)
void	ui_seamless_settitle (unsigned long id, const char *title, unsigned long flags)
void	ui_seamless_setstate (unsigned long id, unsigned int state, unsigned long flags)
void	ui_seamless_syncbegin (unsigned long flags)
void	ui_seamless_ack (unsigned int serial)
RD_BOOL	lspci_init (void)
RD_BOOL	seamless_init (void)
void	seamless_reset_state (void)
unsigned int	seamless_send_sync (void)
unsigned int	seamless_send_state (unsigned long id, unsigned int state, unsigned long flags)
unsigned int	seamless_send_position (unsigned long id, int x, int y, int width, int height, unsigned long flags)
void	seamless_select_timeout (struct timeval *tv)
unsigned int	seamless_send_zchange (unsigned long id, unsigned long below, unsigned long flags)
unsigned int	seamless_send_focus (unsigned long id, unsigned long flags)
unsigned int	seamless_send_destroy (unsigned long id)
unsigned int	seamless_send_spawn (char *cmd)
unsigned int	seamless_send_persistent (RD_BOOL)
void	scard_lock (int lock)
void	scard_unlock (int lock)
int	scard_enum_devices (uint32 *id, char *optarg)
void	scardSetInfo (uint32 epoch, uint32 device, uint32 id, uint32 bytes_out)
void	scard_reset_state ()

Function Documentation

ber_in_header()

RD_BOOL ber_in_header	(	STREAM	s,
		int *	tagval,
		int *	length
	)

Definition at line 90 of file asn.c.

{
    in_uint8(s, *tagval);
    in_uint8(s, *decoded_len);
 
    if (*decoded_len < 0x80)
        return True;
    else if (*decoded_len == 0x81)
    {
        in_uint8(s, *decoded_len);
        return True;
    }
    else if (*decoded_len == 0x82)
    {
        in_uint16_be(s, *decoded_len);
        return True;
    }
 
    return False;
}

ber_out_header()

void ber_out_header	(	STREAM	s,
		int	tagval,
		int	length
	)

Definition at line 61 of file asn.c.

{
    if (tagval > 0xff)
    {
        out_uint16_be(s, tagval);
    }
    else
    {
        out_uint8(s, tagval);
    }
 
    if (length >= 0x80)
    {
        out_uint8(s, 0x82);
        out_uint16_be(s, length);
    }
    else
        out_uint8(s, length);
}

Referenced by ber_out_integer(), mcs_out_domain_params(), and mcs_send_connect_initial().

ber_out_integer()

void ber_out_integer	(	STREAM	s,
		int	value
	)

Definition at line 83 of file asn.c.

{
    ber_out_header(s, BER_TAG_INTEGER, 2);
    out_uint16_be(s, value);
}

Referenced by mcs_out_domain_params().

ber_parse_header()

RD_BOOL ber_parse_header	(	STREAM	s,
		int	tagval,
		int *	length
	)

Definition at line 25 of file asn.c.

{
    int tag, len;
 
    if (tagval > 0xff)
    {
        in_uint16_be(s, tag);
    }
    else
    {
        in_uint8(s, tag);
    }
 
    if (tag != tagval)
    {
        error("expected tag %d, got %d\n", tagval, tag);
        return False;
    }
 
    in_uint8(s, len);
 
    if (len & 0x80)
    {
        len &= ~0x80;
        *length = 0;
        while (len--)
            next_be(s, *length);
    }
    else
        *length = len;
 
    return s_check(s);
}

Referenced by mcs_parse_domain_params(), and mcs_recv_connect_response().

bitmap_decompress()

RD_BOOL bitmap_decompress	(	uint8 *	output,
		int	width,
		int	height,
		uint8 *	input,
		int	size,
		int	Bpp
	)

Definition at line 884 of file bitmap.c.

{
    RD_BOOL rv = False;
 
    switch (Bpp)
    {
        case 1:
            rv = bitmap_decompress1(output, width, height, input, size);
            break;
        case 2:
            rv = bitmap_decompress2(output, width, height, input, size);
            break;
        case 3:
            rv = bitmap_decompress3(output, width, height, input, size);
            break;
        case 4:
            rv = bitmap_decompress4(output, width, height, input, size);
            break;
        default:
            unimpl("Bpp %d\n", Bpp);
            break;
    }
    return rv;
}

buf_out_uint32()

void buf_out_uint32	(	uint8 *	buffer,
		uint32	value
	)

Definition at line 304 of file secure.c.

{
    buffer[0] = (value) & 0xff;
    buffer[1] = (value >> 8) & 0xff;
    buffer[2] = (value >> 16) & 0xff;
    buffer[3] = (value >> 24) & 0xff;
}

Referenced by cliprdr_send_data_request(), cliprdr_send_simple_native_format_announce(), and licence_generate_hwid().

cache_bump_bitmap()

void cache_bump_bitmap	(	uint8	id,
		uint16	idx,
		int	bump
	)

Definition at line 104 of file cache.c.

{
    int p_idx, n_idx, n;
 
    if (!IS_PERSISTENT(id))
        return;
 
    if (g_bmpcache_mru[id] == idx)
        return;
 
    DEBUG_RDP5(("bump bitmap: id=%d, idx=%d, bump=%d\n", id, idx, bump));
 
    n_idx = g_bmpcache[id][idx].next;
    p_idx = g_bmpcache[id][idx].previous;
 
    if (IS_SET(n_idx))
    {
        /* remove */
        --g_bmpcache_count[id];
        if (IS_SET(p_idx))
            g_bmpcache[id][p_idx].next = n_idx;
        else
            g_bmpcache_lru[id] = n_idx;
        if (IS_SET(n_idx))
            g_bmpcache[id][n_idx].previous = p_idx;
        else
            g_bmpcache_mru[id] = p_idx;
    }
    else
    {
        p_idx = NOT_SET;
        n_idx = g_bmpcache_lru[id];
    }
 
    if (bump >= 0)
    {
        for (n = 0; n < bump && IS_SET(n_idx); n++)
        {
            p_idx = n_idx;
            n_idx = g_bmpcache[id][p_idx].next;
        }
    }
    else
    {
        p_idx = g_bmpcache_mru[id];
        n_idx = NOT_SET;
    }
 
    /* insert */
    ++g_bmpcache_count[id];
    g_bmpcache[id][idx].previous = p_idx;
    g_bmpcache[id][idx].next = n_idx;
 
    if (p_idx >= 0)
        g_bmpcache[id][p_idx].next = idx;
    else
        g_bmpcache_lru[id] = idx;
 
    if (n_idx >= 0)
        g_bmpcache[id][n_idx].previous = idx;
    else
        g_bmpcache_mru[id] = idx;
}

Referenced by cache_get_bitmap(), and cache_put_bitmap().

cache_evict_bitmap()

void cache_evict_bitmap

(

uint8

id

)

Definition at line 170 of file cache.c.

{
    uint16 idx;
    int n_idx;
 
    if (!IS_PERSISTENT(id))
        return;
 
    idx = g_bmpcache_lru[id];
    n_idx = g_bmpcache[id][idx].next;
    DEBUG_RDP5(("evict bitmap: id=%d idx=%d n_idx=%d bmp=%p\n", id, idx, n_idx,
            g_bmpcache[id][idx].bitmap));
 
    ui_destroy_bitmap(g_bmpcache[id][idx].bitmap);
    --g_bmpcache_count[id];
    g_bmpcache[id][idx].bitmap = 0;
 
    g_bmpcache_lru[id] = n_idx;
    g_bmpcache[id][n_idx].previous = NOT_SET;
 
    pstcache_touch_bitmap(id, idx, 0);
}

Referenced by cache_put_bitmap().

cache_get_bitmap()

RD_HBITMAP cache_get_bitmap	(	uint8	id,
		uint16	idx
	)

Definition at line 195 of file cache.c.

{
    if ((id < NUM_ELEMENTS(g_bmpcache)) && (idx < NUM_ELEMENTS(g_bmpcache[0])))
    {
        if (g_bmpcache[id][idx].bitmap || pstcache_load_bitmap(id, idx))
        {
            if (IS_PERSISTENT(id))
                cache_bump_bitmap(id, idx, BUMP_COUNT);
 
            return g_bmpcache[id][idx].bitmap;
        }
    }
    else if ((id < NUM_ELEMENTS(g_volatile_bc)) && (idx == 0x7fff))
    {
        return g_volatile_bc[id];
    }
 
    error("get bitmap %d:%d\n", id, idx);
    return NULL;
}

Referenced by process_memblt(), and process_triblt().

cache_get_brush_data()

BRUSHDATA * cache_get_brush_data	(	uint8	colour_code,
		uint8	idx
	)

Definition at line 441 of file cache.c.

{
    colour_code = colour_code == 1 ? 0 : 1;
    if (idx < NUM_ELEMENTS(g_brushcache[0]))
    {
        return &g_brushcache[colour_code][idx];
    }
    error("get brush %d %d\n", colour_code, idx);
    return NULL;
}

Referenced by setup_brush().

cache_get_cursor()

RD_HCURSOR cache_get_cursor

(

uint16

cache_idx

)

Definition at line 400 of file cache.c.

{
    RD_HCURSOR cursor;
 
    if (cache_idx < NUM_ELEMENTS(g_cursorcache))
    {
        cursor = g_cursorcache[cache_idx];
        if (cursor != NULL)
            return cursor;
    }
 
    error("get cursor %d\n", cache_idx);
    return NULL;
}

Referenced by process_cached_pointer_pdu().

cache_get_desktop()

uint8 * cache_get_desktop	(	uint32	offset,
		int	cx,
		int	cy,
		int	bytes_per_pixel
	)

Definition at line 353 of file cache.c.

{
    int length = cx * cy * bytes_per_pixel;
 
    if (offset > sizeof(g_deskcache))
        offset = 0;
 
    if ((offset + length) <= sizeof(g_deskcache))
    {
        return &g_deskcache[offset];
    }
 
    error("get desktop %d:%d\n", offset, length);
    return NULL;
}

Referenced by RdpClientUI::Display_RestoreDesktop(), and ui_desktop_restore().

cache_get_font()

FONTGLYPH * cache_get_font	(	uint8	font,
		uint16	character
	)

Definition at line 279 of file cache.c.

{
    FONTGLYPH *glyph;
 
    if ((font < NUM_ELEMENTS(g_fontcache)) && (character < NUM_ELEMENTS(g_fontcache[0])))
    {
        glyph = &g_fontcache[font][character];
        if (glyph->pixmap != NULL)
            return glyph;
    }
 
    error("get font %d:%d\n", font, character);
    return NULL;
}

Referenced by RdpClientUI::Display_DoGlyph().

cache_get_text()

DATABLOB * cache_get_text

(

uint8

cache_id

)

Definition at line 325 of file cache.c.

{
    DATABLOB *text;
 
    text = &g_textcache[cache_id];
    return text;
}

Referenced by RdpClientUI::Display_DrawText(), and ui_draw_text().

cache_put_bitmap()

void cache_put_bitmap	(	uint8	id,
		uint16	idx,
		RD_HBITMAP	bitmap
	)

Definition at line 218 of file cache.c.

{
    RD_HBITMAP old;
 
    if ((id < NUM_ELEMENTS(g_bmpcache)) && (idx < NUM_ELEMENTS(g_bmpcache[0])))
    {
        old = g_bmpcache[id][idx].bitmap;
        if (old != NULL)
            ui_destroy_bitmap(old);
        g_bmpcache[id][idx].bitmap = bitmap;
 
        if (IS_PERSISTENT(id))
        {
            if (old == NULL)
                g_bmpcache[id][idx].previous = g_bmpcache[id][idx].next = NOT_SET;
 
            cache_bump_bitmap(id, idx, TO_TOP);
            if (g_bmpcache_count[id] > BMPCACHE2_C2_CELLS)
                cache_evict_bitmap(id);
        }
    }
    else if ((id < NUM_ELEMENTS(g_volatile_bc)) && (idx == 0x7fff))
    {
        old = g_volatile_bc[id];
        if (old != NULL)
            ui_destroy_bitmap(old);
        g_volatile_bc[id] = bitmap;
    }
    else
    {
        error("put bitmap %d:%d\n", id, idx);
    }
}

Referenced by process_bmpcache(), process_bmpcache2(), process_raw_bmpcache(), and pstcache_load_bitmap().

cache_put_brush_data()

void cache_put_brush_data	(	uint8	colour_code,
		uint8	idx,
		BRUSHDATA *	brush_data
	)

Definition at line 455 of file cache.c.

{
    BRUSHDATA *bd;
 
    colour_code = colour_code == 1 ? 0 : 1;
    if (idx < NUM_ELEMENTS(g_brushcache[0]))
    {
        bd = &g_brushcache[colour_code][idx];
        if (bd->data != 0)
        {
            xfree(bd->data);
        }
        memcpy(bd, brush_data, sizeof(BRUSHDATA));
    }
    else
    {
        error("put brush %d %d\n", colour_code, idx);
    }
}

Referenced by process_brushcache().

cache_put_cursor()

void cache_put_cursor	(	uint16	cache_idx,
		RD_HCURSOR	cursor
	)

Definition at line 417 of file cache.c.

{
    RD_HCURSOR old;
 
    if (cache_idx < NUM_ELEMENTS(g_cursorcache))
    {
        old = g_cursorcache[cache_idx];
        if (old != NULL)
            ui_destroy_cursor(old);
 
        g_cursorcache[cache_idx] = cursor;
    }
    else
    {
        error("put cursor %d\n", cache_idx);
    }
}

Referenced by process_colour_pointer_common(), and process_colour_pointer_pdu().

cache_put_desktop()

void cache_put_desktop	(	uint32	offset,
		int	cx,
		int	cy,
		int	scanline,
		int	bytes_per_pixel,
		uint8 *	data
	)

Definition at line 371 of file cache.c.

{
    int length = cx * cy * bytes_per_pixel;
 
    if (offset > sizeof(g_deskcache))
        offset = 0;
 
    if ((offset + length) <= sizeof(g_deskcache))
    {
        cx *= bytes_per_pixel;
        while (cy--)
        {
            memcpy(&g_deskcache[offset], data, cx);
            data += scanline;
            offset += cx;
        }
    }
    else
    {
        error("put desktop %d:%d\n", offset, length);
    }
}

Referenced by RdpClientUI::Display_SaveDesktop(), and ui_desktop_save().

cache_put_font()

void cache_put_font	(	uint8	font,
		uint16	character,
		uint16	offset,
		uint16	baseline,
		uint16	width,
		uint16	height,
		RD_HGLYPH	pixmap
	)

Definition at line 296 of file cache.c.

{
    FONTGLYPH *glyph;
 
    if ((font < NUM_ELEMENTS(g_fontcache)) && (character < NUM_ELEMENTS(g_fontcache[0])))
    {
        glyph = &g_fontcache[font][character];
        if (glyph->pixmap != NULL)
            ui_destroy_glyph(glyph->pixmap);
 
        glyph->offset = offset;
        glyph->baseline = baseline;
        glyph->width = width;
        glyph->height = height;
        glyph->pixmap = pixmap;
    }
    else
    {
        error("put font %d:%d\n", font, character);
    }
}

Referenced by process_fontcache().

cache_put_text()

void cache_put_text	(	uint8	cache_id,
		void *	data,
		int	length
	)

Definition at line 335 of file cache.c.

{
    DATABLOB *text;
 
    text = &g_textcache[cache_id];
    if (text->data != NULL)
        xfree(text->data);
    text->data = xmalloc(length);
    text->size = length;
    memcpy(text->data, data, length);
}

Referenced by RdpClientUI::Display_DrawText(), and ui_draw_text().

cache_rebuild_bmpcache_linked_list()

void cache_rebuild_bmpcache_linked_list	(	uint8	id,
		sint16 *	idx,
		int	count
	)

Definition at line 58 of file cache.c.

{
    int n = count, c = 0;
    sint16 n_idx;
 
    /* find top, skip evicted bitmaps */
    while (--n >= 0 && g_bmpcache[id][idx[n]].bitmap == NULL);
    if (n < 0)
    {
        g_bmpcache_mru[id] = g_bmpcache_lru[id] = NOT_SET;
        return;
    }
 
    g_bmpcache_mru[id] = idx[n];
    g_bmpcache[id][idx[n]].next = NOT_SET;
    n_idx = idx[n];
    c++;
 
    /* link list */
    while (n >= 0)
    {
        /* skip evicted bitmaps */
        while (--n >= 0 && g_bmpcache[id][idx[n]].bitmap == NULL);
 
        if (n < 0)
            break;
 
        g_bmpcache[id][n_idx].previous = idx[n];
        g_bmpcache[id][idx[n]].next = n_idx;
        n_idx = idx[n];
        c++;
    }
 
    g_bmpcache[id][n_idx].previous = NOT_SET;
    g_bmpcache_lru[id] = n_idx;
 
    if (c != g_bmpcache_count[id])
    {
        error("Oops. %d in bitmap cache linked list, %d in ui cache...\n", c,
              g_bmpcache_count[id]);
        exit(EX_SOFTWARE);
    }
}

Referenced by pstcache_enumerate().

cache_save_state()

void cache_save_state

(

void

)

Definition at line 254 of file cache.c.

{
    uint32 id = 0, t = 0;
    int idx;
 
    for (id = 0; id < NUM_ELEMENTS(g_bmpcache); id++)
        if (IS_PERSISTENT(id))
        {
            DEBUG_RDP5(("Saving cache state for bitmap cache %d...", id));
            idx = g_bmpcache_lru[id];
            while (idx >= 0)
            {
                pstcache_touch_bitmap(id, idx, ++t);
                idx = g_bmpcache[id][idx].next;
            }
            DEBUG_RDP5((" %d stamps written.\n", t));
        }
}

Referenced by main().

channel_init()

STREAM channel_init	(	VCHANNEL *	channel,
		uint32	length
	)

Definition at line 69 of file channels.c.

{
    STREAM s;
 
    s = sec_init(g_encryption ? SEC_ENCRYPT : 0, length + 8);
    s_push_layer(s, channel_hdr, 8);
    return s;
}

Referenced by cliprdr_send_packet(), lspci_send(), rdpdr_send_available(), rdpdr_send_clientcapabilty(), rdpdr_send_completion(), rdpdr_send_connect(), rdpdr_send_name(), rdpsnd_init_packet(), and seamless_send().

channel_process()

void channel_process	(	STREAM	s,
		uint16	mcs_channel
	)

Definition at line 138 of file channels.c.

{
    uint32 length, flags;
    uint32 thislength;
    VCHANNEL *channel = NULL;
    unsigned int i;
    STREAM in;
 
    for (i = 0; i < g_num_channels; i++)
    {
        channel = &g_channels[i];
        if (channel->mcs_id == mcs_channel)
            break;
    }
 
    if (i >= g_num_channels)
        return;
 
    in_uint32_le(s, length);
    in_uint32_le(s, flags);
    if ((flags & CHANNEL_FLAG_FIRST) && (flags & CHANNEL_FLAG_LAST))
    {
        /* single fragment - pass straight up */
        channel->process(s);
    }
    else
    {
        /* add fragment to defragmentation buffer */
        in = &channel->in;
        if (flags & CHANNEL_FLAG_FIRST)
        {
            if (length > in->size)
            {
                in->data = (uint8 *) xrealloc(in->data, length);
                in->size = length;
            }
            in->p = in->data;
        }
 
        thislength = MIN(s->end - s->p, in->data + in->size - in->p);
        memcpy(in->p, s->p, thislength);
        in->p += thislength;
 
        if (flags & CHANNEL_FLAG_LAST)
        {
            in->end = in->p;
            in->p = in->data;
            channel->process(in);
        }
    }
}

Referenced by sec_recv().

channel_register()

VCHANNEL * channel_register	(	char *	name,
		uint32	flags,
		void(*)(STREAM)	callback
	)

Definition at line 46 of file channels.c.

{
    VCHANNEL *channel;
 
    if (g_rdp_version < RDP_V5)
        return NULL;
 
    if (g_num_channels >= MAX_CHANNELS)
    {
        error("Channel table full, increase MAX_CHANNELS\n");
        return NULL;
    }
 
    channel = &g_channels[g_num_channels];
    channel->mcs_id = MCS_GLOBAL_CHANNEL + 1 + g_num_channels;
    strncpy(channel->name, name, 8);
    channel->flags = flags;
    channel->process = callback;
    g_num_channels++;
    return channel;
}

Referenced by cliprdr_init(), lspci_init(), rdpdr_init(), rdpsnd_init(), and seamless_init().

channel_send()

void channel_send	(	STREAM	s,
		VCHANNEL *	channel
	)

Definition at line 79 of file channels.c.

{
    uint32 length, flags;
    uint32 thislength, remaining;
    uint8 *data;
 
#ifdef WITH_SCARD
    scard_lock(SCARD_LOCK_CHANNEL);
#endif
 
    /* first fragment sent in-place */
    s_pop_layer(s, channel_hdr);
    length = s->end - s->p - 8;
 
    DEBUG_CHANNEL(("channel_send, length = %d\n", length));
 
    thislength = MIN(length, CHANNEL_CHUNK_LENGTH);
/* Note: In the original clipboard implementation, this number was
   1592, not 1600. However, I don't remember the reason and 1600 seems
   to work so.. This applies only to *this* length, not the length of
   continuation or ending packets. */
    remaining = length - thislength;
    flags = (remaining == 0) ? CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST : CHANNEL_FLAG_FIRST;
    if (channel->flags & CHANNEL_OPTION_SHOW_PROTOCOL)
        flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
 
    out_uint32_le(s, length);
    out_uint32_le(s, flags);
    data = s->end = s->p + thislength;
    DEBUG_CHANNEL(("Sending %d bytes with FLAG_FIRST\n", thislength));
    sec_send_to_channel(s, g_encryption ? SEC_ENCRYPT : 0, channel->mcs_id);
 
    /* subsequent segments copied (otherwise would have to generate headers backwards) */
    while (remaining > 0)
    {
        thislength = MIN(remaining, CHANNEL_CHUNK_LENGTH);
        remaining -= thislength;
        flags = (remaining == 0) ? CHANNEL_FLAG_LAST : 0;
        if (channel->flags & CHANNEL_OPTION_SHOW_PROTOCOL)
            flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
 
        DEBUG_CHANNEL(("Sending %d bytes with flags %d\n", thislength, flags));
 
        s = sec_init(g_encryption ? SEC_ENCRYPT : 0, thislength + 8);
        out_uint32_le(s, length);
        out_uint32_le(s, flags);
        out_uint8p(s, data, thislength);
        s_mark_end(s);
        sec_send_to_channel(s, g_encryption ? SEC_ENCRYPT : 0, channel->mcs_id);
 
        data += thislength;
    }
 
#ifdef WITH_SCARD
    scard_unlock(SCARD_LOCK_CHANNEL);
#endif
}

Referenced by cliprdr_send_packet(), lspci_send(), rdpdr_send_available(), rdpdr_send_clientcapabilty(), rdpdr_send_completion(), rdpdr_send_connect(), rdpdr_send_name(), rdpsnd_send(), and seamless_send().

cliprdr_init()

RD_BOOL cliprdr_init

(

void

)

Referenced by xclip_init().

cliprdr_send_data()

void cliprdr_send_data	(	uint8 *	data,
		uint32	length
	)

Referenced by helper_cliprdr_send_response().

cliprdr_send_data_request()

void cliprdr_send_data_request

(

uint32

format

)

Referenced by xclip_handle_SelectionRequest().

cliprdr_send_native_format_announce()

void cliprdr_send_native_format_announce	(	uint8 *	formats_data,
		uint32	formats_data_length
	)

Referenced by xclip_handle_SelectionNotify().

cliprdr_send_simple_native_format_announce()

void cliprdr_send_simple_native_format_announce

(

uint32

format

)

Referenced by helper_cliprdr_send_response(), xclip_handle_SelectionNotify(), and xclip_probe_selections().

cliprdr_set_mode()

void cliprdr_set_mode

(

const char *

optarg

)

Referenced by main().

convert_to_unix_filename()

void convert_to_unix_filename

(

char *

filename

)

Definition at line 78 of file rdpdr.c.

{
    char *p;
 
    while ((p = strchr(filename, '\\')))
    {
        *p = '/';
    }
}

Referenced by disk_set_information(), and rdpdr_process_irp().

cssp_connect()

RD_BOOL cssp_connect	(	char *	server,
		char *	user,
		char *	domain,
		char *	password,
		STREAM	s
	)

Referenced by iso_connect().

ctrl_add_fds()

void ctrl_add_fds	(	int *	n,
		fd_set *	rfds
	)

ctrl_check_fds()

void ctrl_check_fds	(	fd_set *	rfds,
		fd_set *	wfds
	)

ctrl_cleanup()

void ctrl_cleanup

(

)

ctrl_init()

int ctrl_init	(	const char *	user,
		const char *	domain,
		const char *	host
	)

ctrl_is_slave()

RD_BOOL ctrl_is_slave

(

)

ctrl_send_command()

int ctrl_send_command	(	const char *	cmd,
		const char *	args
	)

disk_check_notify()

RD_NTSTATUS disk_check_notify

(

RD_NTHANDLE

handle

)

Referenced by _rdpdr_check_fds().

disk_create_notify()

RD_NTSTATUS disk_create_notify	(	RD_NTHANDLE	handle,
		uint32	info_class
	)

Referenced by rdpdr_process_irp().

disk_enum_devices()

int disk_enum_devices	(	uint32 *	id,
		char *	optarg
	)

Referenced by main().

disk_query_directory()

RD_NTSTATUS disk_query_directory	(	RD_NTHANDLE	handle,
		uint32	info_class,
		char *	pattern,
		STREAM	out
	)

Referenced by rdpdr_process_irp().

disk_query_information()

RD_NTSTATUS disk_query_information	(	RD_NTHANDLE	handle,
		uint32	info_class,
		STREAM	out
	)

Referenced by rdpdr_process_irp().

disk_query_volume_information()

RD_NTSTATUS disk_query_volume_information	(	RD_NTHANDLE	handle,
		uint32	info_class,
		STREAM	out
	)

Referenced by rdpdr_process_irp().

disk_set_information()

RD_NTSTATUS disk_set_information	(	RD_NTHANDLE	handle,
		uint32	info_class,
		STREAM	in,
		STREAM	out
	)

Referenced by rdpdr_process_irp().

ensure_remote_modifiers()

void ensure_remote_modifiers	(	uint32	ev_time,
		key_translation	tr
	)

Referenced by vncKey().

error()

void error	(	char *	format,
			...
	)

Definition at line 817 of file uimain.c.

{
  va_list ap;
  char text[512];
  char text1[512];
 
  sprintf(text1, "ERROR: ");
  va_start(ap, format);
  vsprintf(text, format, ap);
  va_end(ap);
  strcat(text1, text);
  mi_error(text1);
}

ewmh_init()

void ewmh_init

(

void

)

Referenced by ui_init().

exit_if_null()

void exit_if_null

(

void *

ptr

)

generate_random()

void generate_random

(

uint8 *

random

)

Definition at line 709 of file uimain.c.

{
  int i;
 
  rand();
  rand();
  for (i = 0; i < 32; i++)
  {
    random[i] = rand(); /* higher bits are more random */
  }
}

Referenced by sec_process_crypt_info().

get_current_workarea()

int get_current_workarea	(	uint32 *	x,
		uint32 *	y,
		uint32 *	width,
		uint32 *	height
	)

Referenced by ui_init().

get_device_index()

int get_device_index

(

RD_NTHANDLE

handle

)

Referenced by parallel_close(), printer_close(), serial_close(), serial_get_event(), and serial_get_timeout().

get_key_state()

RD_BOOL get_key_state	(	unsigned int	state,
		uint32	keysym
	)

Definition at line 146 of file vnc.c.

{
    if (keysym >= FIRST_MODIFIER && keysym <= LAST_MODIFIER)
        return keystate[keysym - FIRST_MODIFIER];
    return 0;
}

Referenced by handle_special_keys(), reset_modifier_keys(), and ui_get_numlock_state().

get_ksname()

char * get_ksname

(

uint32

keysym

)

Definition at line 734 of file xkeymap.c.

{
    char *ksname = NULL;
 
    if (keysym == NoSymbol)
        ksname = "NoSymbol";
    else if (!(ksname = XKeysymToString(keysym)))
        ksname = "(no name)";
 
    return ksname;
}

Referenced by xkeymap_translate_key(), and xwin_process_events().

handle_special_keys()

RD_BOOL handle_special_keys	(	uint32	keysym,
		unsigned int	state,
		uint32	ev_time,
		RD_BOOL	pressed
	)

Referenced by vncKey(), and xwin_process_events().

hexdump()

void hexdump	(	unsigned char *	p,
		unsigned int	len
	)

Definition at line 234 of file shimdbg.c.

{
    unsigned char *line = p;
    unsigned int i, thisline, offset = 0;
 
    while (offset < len)
    {
        xprintf("%04x ", offset);
        thisline = len - offset;
        if (thisline > 16)
            thisline = 16;
 
        for (i = 0; i < thisline; i++)
            xprintf("%02x ", line[i]);
 
        for (; i < 16; i++)
            xprintf("   ");
 
        for (i = 0; i < thisline; i++)
            xprintf("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.');
 
        xprintf("\n");
        offset += thisline;
        line += thisline;
    }
}

Referenced by lspci_process(), lspci_send(), rdp5_process(), rdp_recv(), rdpdr_process(), rdpsnd_process(), rdpsnd_send(), seamless_process(), seamless_send(), sec_recv(), sec_send_to_channel(), serial_device_control(), and serial_read().

iso_connect()

RD_BOOL iso_connect	(	char *	server,
		char *	username,
		char *	domain,
		char *	password,
		RD_BOOL	reconnect,
		uint32 *	selected_protocol
	)

Definition at line 203 of file iso.c.

{
    STREAM s;
    uint8 code;
    uint32 neg_proto;
 
    g_negotiate_rdp_protocol = True;
 
    neg_proto = PROTOCOL_SSL;
 
#ifdef WITH_CREDSSP
    if (!g_use_password_as_pin)
        neg_proto |= PROTOCOL_HYBRID;
    else if (g_sc_csp_name || g_sc_reader_name || g_sc_card_name || g_sc_container_name)
        neg_proto |= PROTOCOL_HYBRID;
    else
        warning("Disables CredSSP due to missing smartcard information for SSO.\n");
#endif
 
      retry:
    *selected_protocol = PROTOCOL_RDP;
    code = 0;
 
    if (!tcp_connect(server))
        return False;
 
    iso_send_connection_request(username, neg_proto);
 
    s = iso_recv_msg(&code, NULL);
    if (s == NULL)
        return False;
 
    if (code != ISO_PDU_CC)
    {
        error("expected CC, got 0x%x\n", code);
        tcp_disconnect();
        return False;
    }
 
    if (g_rdp_version >= RDP_V5 && s_check_rem(s, 8))
    {
        /* handle RDP_NEG_REQ response */
        const char *reason = NULL;
 
        uint8 type = 0, flags = 0;
        uint16 length = 0;
        uint32 data = 0;
 
        in_uint8(s, type);
        in_uint8(s, flags);
        in_uint16(s, length);
        in_uint32(s, data);
 
        if (type == RDP_NEG_FAILURE)
        {
            RD_BOOL retry_without_neg = False;
 
            switch (data)
            {
                case SSL_WITH_USER_AUTH_REQUIRED_BY_SERVER:
                    reason = "SSL with user authentication required by server";
                    break;
                case SSL_NOT_ALLOWED_BY_SERVER:
                    reason = "SSL not allowed by server";
                    retry_without_neg = True;
                    break;
                case SSL_CERT_NOT_ON_SERVER:
                    reason = "no valid authentication certificate on server";
                    retry_without_neg = True;
                    break;
                case INCONSISTENT_FLAGS:
                    reason = "inconsistent negotiation flags";
                    break;
                case SSL_REQUIRED_BY_SERVER:
                    reason = "SSL required by server";
                    break;
                case HYBRID_REQUIRED_BY_SERVER:
                    reason = "CredSSP required by server";
                    break;
                default:
                    reason = "unknown reason";
            }
 
            tcp_disconnect();
 
            if (retry_without_neg)
            {
                fprintf(stderr,
                    "Failed to negotiate protocol, retrying with plain RDP.\n");
                g_negotiate_rdp_protocol = False;
                goto retry;
            }
 
            fprintf(stderr, "Failed to connect, %s.\n", reason);
            return False;
        }
 
        if (type != RDP_NEG_RSP)
        {
            tcp_disconnect();
            error("Expected RDP_NEG_RSP, got type = 0x%x\n", type);
            return False;
        }
 
        /* handle negotiation response */
        if (data == PROTOCOL_SSL)
        {
#ifdef WITH_SSL
            if (!tcp_tls_connect())
            {
                /* failed to connect using cssp, let retry with plain TLS */
                tcp_disconnect();
                neg_proto = PROTOCOL_RDP;
                goto retry;
            }
            /* do not use encryption when using TLS */
            g_encryption = False;
            fprintf(stderr, "Connection established using SSL.\n");
#else /* WITH_SSL */
            fprintf(stderr, "SSL not compiled in.\n");
#endif /* WITH_SSL */
        }
#ifdef WITH_CREDSSP
        else if (data == PROTOCOL_HYBRID)
        {
            if (!cssp_connect(server, username, domain, password, s))
            {
                /* failed to connect using cssp, let retry with plain TLS */
                tcp_disconnect();
                neg_proto = PROTOCOL_SSL;
                goto retry;
            }
 
            /* do not use encryption when using TLS */
            fprintf(stderr, "Connection established using CredSSP.\n");
            g_encryption = False;
        }
#endif
        else if (data == PROTOCOL_RDP)
        {
            fprintf(stderr, "Connection established using plain RDP.\n");
        }
        else if (data != PROTOCOL_RDP)
        {
            tcp_disconnect();
            error("Unexpected protocol in negotiation response, got data = 0x%x.\n",
                  data);
            return False;
        }
        if (length || flags) {}
 
        *selected_protocol = data;
    }
    return True;
}

Referenced by mcs_connect(), and mcs_connect_start().

iso_disconnect()

void iso_disconnect

(

void

)

Definition at line 362 of file iso.c.

{
    iso_send_msg(ISO_PDU_DR);
    tcp_disconnect();
}

Referenced by mcs_connect(), mcs_connect_finalize(), mcs_disconnect(), and mcs_reconnect().

iso_init()

STREAM iso_init

(

int

length

)

Definition at line 150 of file iso.c.

{
    STREAM s;
 
    s = tcp_init(length + 7);
    s_push_layer(s, iso_hdr, 7);
 
    return s;
}

Referenced by mcs_init(), mcs_send_aurq(), mcs_send_cjrq(), mcs_send_connect_initial(), and mcs_send_edrq().

iso_recv()

STREAM iso_recv

(

uint8 *

rdpver

)

Definition at line 182 of file iso.c.

{
    STREAM s;
    uint8 code = 0;
 
    s = iso_recv_msg(&code, rdpver);
    if (s == NULL)
        return NULL;
    if (rdpver != NULL)
        if (*rdpver != 3)
            return s;
    if (code != ISO_PDU_DT)
    {
        error("expected DT, got 0x%x\n", code);
        return NULL;
    }
    return s;
}

Referenced by mcs_recv(), mcs_recv_aucf(), mcs_recv_cjcf(), and mcs_recv_connect_response().

iso_reset_state()

void iso_reset_state

(

void

)

Definition at line 370 of file iso.c.

{
    g_encryption = g_encryption_initial;
    tcp_reset_state();
}

Referenced by mcs_reset_state().

iso_send()

void iso_send

(

STREAM

s

)

Definition at line 162 of file iso.c.

{
    uint16 length;
 
    s_pop_layer(s, iso_hdr);
    length = s->end - s->p;
 
    out_uint8(s, 3);    /* version */
    out_uint8(s, 0);    /* reserved */
    out_uint16_be(s, length);
 
    out_uint8(s, 2);    /* hdrlen */
    out_uint8(s, ISO_PDU_DT);   /* code */
    out_uint8(s, 0x80); /* eot */
 
    tcp_send(s);
}

Referenced by mcs_send_aurq(), mcs_send_cjrq(), mcs_send_connect_initial(), mcs_send_edrq(), and mcs_send_to_channel().

l_to_a()

char * l_to_a	(	long	N,
		int	base
	)

Definition at line 1356 of file rdesktop.c.

{
    static char ret[LTOA_BUFSIZE];
 
    char *head = ret, buf[LTOA_BUFSIZE], *tail = buf + sizeof(buf);
 
    register int divrem;
 
    if (base < 36 || 2 > base)
        base = 10;
 
    if (N < 0)
    {
        *head++ = '-';
        N = -N;
    }
 
    tail = buf + sizeof(buf);
    *--tail = 0;
 
    do
    {
        divrem = N % base;
        *--tail = (divrem <= 9) ? divrem + '0' : divrem + 'a' - 10;
        N /= base;
    }
    while (N);
 
    strcpy(head, tail);
    return ret;
}

Referenced by printer_enum_devices().

licence_process()

void licence_process

(

STREAM

s

)

Definition at line 378 of file licence.c.

{
    uint8 tag;
 
    in_uint8(s, tag);
    in_uint8s(s, 3);    /* version, length */
 
#if WITH_DEBUG
    DEBUG(("Received licensing PDU (message type 0x%02x)\n", tag));
#endif
 
    switch (tag)
    {
        case LICENCE_TAG_REQUEST:
            licence_process_request(s);
            break;
 
        case LICENCE_TAG_PLATFORM_CHALLANGE:
            licence_process_platform_challenge(s);
            break;
 
        case LICENCE_TAG_NEW_LICENCE:
        case LICENCE_TAG_UPGRADE_LICENCE:
            /* we can handle new and upgrades of licences the same way. */
            licence_process_new_license(s);
            break;
 
        case LICENCE_TAG_ERROR_ALERT:
            licence_process_error_alert(s);
            break;
 
        default:
            unimpl("licence tag 0x%02x\n", tag);
    }
}

Referenced by sec_recv().

load_licence()

int load_licence

(

unsigned char **

data

)

Referenced by licence_process_demand(), and licence_process_request().

lspci_init()

RD_BOOL lspci_init

(

void

)

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 1685 of file atactl.cpp.

{
    //ULONG Flags = 0;
    intptr_t i;
    uintptr_t j;
    char a;
    int bus_id = -1;
    int dev_id = -1;
    int cmd = 0;
    int lock = -1;
    int b_dev=-1, d_dev=-1, l_dev=0;
    int mode=-1;
    int list_bb=0;
    int persistent_hide=0;
    int power_mode=StartStop_Power_NoChg;
 
    printf("Console ATA control utility for Windows NT3.51/NT4/2000/XP/2003\n"
           "Version 0." UNIATA_VER_STR ", Copyright (c) Alexander A. Telyatnikov, 2003-2012\n"
           "Home site: http://alter.org.ua\n");
 
    for(i=1; i<argc; i++) {
        if(!argv[i])
            continue;
        if((a = argv[i][0]) != '-') {
            for(j=0; (a = argv[i][j]); j++) {
                switch(a) {
                case 'a' :
                case 's' :
                case 'c' :
                    j++;
                    bus_id = ata_num_to_x_dev(argv[i][j]);
                    break;
                case 'b' :
                    j++;
                    b_dev = ata_num_to_x_dev(argv[i][j]);
                    break;
                case 'd' :
                    j++;
                    d_dev = ata_num_to_x_dev(argv[i][j]);
                    break;
                case 'l' :
                    j++;
                    l_dev = ata_num_to_x_dev(argv[i][j]);
                    break;
                case ':' :
                    break;
                default:
                    print_help();
                }
            }
            continue;
        }
        j=1;
        while(argv[i] && (a = argv[i][j]) && (a != ' ') && (a != '\t')) {
            switch(a) {
            case 'l' :
                if(cmd || lock>0) {
                    print_help();
                }
                cmd = CMD_ATA_LIST;
                break;
            case 'x' :
                g_extended = 1;
                break;
            case 'a' :
                g_adapter_info = 1;
                break;
            case 'S' :
                persistent_hide = 1;
            case 's' :
                if(cmd || lock>0) {
                    print_help();
                }
                cmd = CMD_ATA_FIND;
                d_dev = 0;
                break;
            case 'H' :
                persistent_hide = 1;
            case 'h' :
                if(cmd) {
                    print_help();
                }
                cmd = CMD_ATA_HIDE;
                d_dev = 0;
                break;
            case 'm' :
                if(cmd) {
                    print_help();
                }
                cmd = CMD_ATA_MODE;
                i++;
                if(!argv[i]) {
                    print_help();
                }
                mode = ata_str_to_mode(argv[i]);
                if(mode == -1) {
                    i--;
                } else {
                    j = strlen(argv[i])-1;
                }
                break;
            case 'r' :
                if(cmd) {
                    print_help();
                }
                cmd = CMD_ATA_RESET;
                break;
            case 'b' :
                if(cmd) {
                    print_help();
                }
                switch(argv[i][j+1]) {
                case 'l':
                    list_bb = 1;
                    break;
                case 'a':
                    list_bb = 0;
                    break;
                case 'r':
                    list_bb = -1;
                    break;
                default:
                    j--;
                }
                j++;
                cmd = CMD_ATA_BBLK;
                break;
            case 'f' :
                if(cmd != CMD_ATA_BBLK) {
                    print_help();
                }
                i++;
                if(!argv[i]) {
                    print_help();
                }
                g_bb_list=argv[i];
                j = strlen(argv[i])-1;
                break;
            case 'p' :
                if(cmd && (cmd != CMD_ATA_FIND) && (cmd != CMD_ATA_HIDE)) {
                    print_help();
                }
                switch(argv[i][j+1]) {
                case '0':
                case 'a':
                    // do nothing
                    break;
                case '1':
                case 'i':
                    power_mode = StartStop_Power_Idle;
                    break;
                case '2':
                case 's':
                    power_mode = StartStop_Power_Standby;
                    break;
                case '3':
                case 'p':
                    power_mode = StartStop_Power_Sleep;
                    break;
                default:
                    j--;
                }
                j++;
                if(power_mode && !cmd) {
                    cmd = CMD_ATA_POWER;
                }
                break;
            case 'D' :
                power_mode = StartStop_Power_Sleep;
                if(cmd && (cmd != CMD_ATA_HIDE)) {
                    print_help();
                }
            case 'd' :
                if(cmd && (cmd != CMD_ATA_FIND) && (cmd != CMD_ATA_HIDE) && (cmd != CMD_ATA_POWER)) {
                    print_help();
                }
                if(!cmd) {
                    cmd = CMD_ATA_HIDE;
                }
                i++;
                if(!argv[i]) {
                    print_help();
                }
                if(!sscanf(argv[i], "%d", &lock)) {
                    lock = DEFAULT_REMOVAL_LOCK_TIMEOUT;
                    i--;
                }
                j = strlen(argv[i])-1;
                break;
            case 'n' :
                if(cmd != CMD_ATA_BBLK) {
                    print_help();
                }
                i++;
                if(!argv[i]) {
                    print_help();
                }
                if(!strcmp(argv[i], "hex") ||
                   !strcmp(argv[i], "16")) {
                    gRadix = 16;
                } else
                if(!strcmp(argv[i], "dec") ||
                   !strcmp(argv[i], "10")) {
                    gRadix = 10;
                } else {
                    print_help();
                }
                j = strlen(argv[i])-1;
                break;
            case '?' :
            default:
                print_help();
            }
            j++;
        }
    }
 
    if(g_adapter_info && !cmd) {
        cmd = CMD_ATA_LIST;
        b_dev = 127;
        d_dev = 127;
        l_dev = 127;
    } else
    if((d_dev == -1) && (b_dev != -1)) {
        d_dev = 127;
        l_dev = 127;
    }
 
    if((d_dev != -1) && (b_dev != -1)) {
        dev_id = (b_dev << 16) | (d_dev << 8) | l_dev;
    }
    if(cmd == CMD_ATA_LIST) {
        ata_list(bus_id, dev_id);
    } else
    if(cmd == CMD_ATA_MODE) {
        ata_mode(bus_id, dev_id, mode);
    } else
    if(cmd == CMD_ATA_RESET) {
        ata_reset(bus_id, dev_id);
    } else
    if(cmd == CMD_ATA_FIND) {
        ata_scan(bus_id, dev_id, lock, persistent_hide);
    } else
    if(cmd == CMD_ATA_HIDE) {
        ata_hide(bus_id, dev_id, lock, persistent_hide, power_mode);
    } else
    if(cmd == CMD_ATA_BBLK) {
        ata_bblk(bus_id, dev_id, list_bb);
    } else
    if(cmd == CMD_ATA_POWER) {
        ata_power_mode(bus_id, dev_id, power_mode);
    } else {
        print_help();
    }
    exit(0);
}

mcs_connect_finalize()

RD_BOOL mcs_connect_finalize

(

STREAM

s

)

Definition at line 318 of file mcs.c.

{
    unsigned int i;
 
    mcs_send_connect_initial(mcs_data);
    if (!mcs_recv_connect_response(mcs_data))
        goto error;
 
    mcs_send_edrq();
 
    mcs_send_aurq();
    if (!mcs_recv_aucf(&g_mcs_userid))
        goto error;
 
    mcs_send_cjrq(g_mcs_userid + MCS_USERCHANNEL_BASE);
 
    if (!mcs_recv_cjcf())
        goto error;
 
    mcs_send_cjrq(MCS_GLOBAL_CHANNEL);
    if (!mcs_recv_cjcf())
        goto error;
 
    for (i = 0; i < g_num_channels; i++)
    {
        mcs_send_cjrq(g_channels[i].mcs_id);
        if (!mcs_recv_cjcf())
            goto error;
    }
    return True;
 
      error:
    iso_disconnect();
    return False;
}

Referenced by sec_connect().

mcs_connect_start()

RD_BOOL mcs_connect_start	(	char *	server,
		char *	username,
		char *	domain,
		char *	password,
		RD_BOOL	reconnect,
		uint32 *	selected_protocol
	)

Definition at line 311 of file mcs.c.

{
    return iso_connect(server, username, domain, password, reconnect, selected_protocol);
}

Referenced by sec_connect().

mcs_disconnect()

void mcs_disconnect

(

void

)

Definition at line 356 of file mcs.c.

{
    iso_disconnect();
}

Referenced by sec_disconnect().

mcs_init()

STREAM mcs_init

(

int

length

)

Definition at line 242 of file mcs.c.

{
    STREAM s;
 
    s = iso_init(length + 8);
    s_push_layer(s, mcs_hdr, 8);
 
    return s;
}

Referenced by sec_init().

mcs_recv()

STREAM mcs_recv	(	uint16 *	channel,
		uint8 *	rdpver
	)

Definition at line 280 of file mcs.c.

{
    uint8 opcode, appid, length;
    STREAM s;
 
    s = iso_recv(rdpver);
    if (s == NULL)
        return NULL;
    if (rdpver != NULL)
        if (*rdpver != 3)
            return s;
    in_uint8(s, opcode);
    appid = opcode >> 2;
    if (appid != MCS_SDIN)
    {
        if (appid != MCS_DPUM)
        {
            error("expected data, got %d\n", opcode);
        }
        return NULL;
    }
    in_uint8s(s, 2);    /* userid */
    in_uint16_be(s, *channel);
    in_uint8s(s, 1);    /* flags */
    in_uint8(s, length);
    if (length & 0x80)
        in_uint8s(s, 1);    /* second byte of length */
    return s;
}

Referenced by sec_recv().

mcs_reset_state()

void mcs_reset_state

(

void

)

Definition at line 363 of file mcs.c.

{
    g_mcs_userid = 0;
    iso_reset_state();
}

Referenced by sec_reset_state().

mcs_send()

void mcs_send

(

STREAM

s

)

Definition at line 273 of file mcs.c.

{
    mcs_send_to_channel(s, MCS_GLOBAL_CHANNEL);
}

mcs_send_to_channel()

void mcs_send_to_channel	(	STREAM	s,
		uint16	channel
	)

Definition at line 254 of file mcs.c.

{
    uint16 length;
 
    s_pop_layer(s, mcs_hdr);
    length = s->end - s->p - 8;
    length |= 0x8000;
 
    out_uint8(s, (MCS_SDRQ << 2));
    out_uint16_be(s, g_mcs_userid);
    out_uint16_be(s, channel);
    out_uint8(s, 0x70); /* flags */
    out_uint16_be(s, length);
 
    iso_send(s);
}

Referenced by mcs_send(), and sec_send_to_channel().

mppc_expand()

int mppc_expand	(	uint8 *	data,
		uint32	clen,
		uint8	ctype,
		uint32 *	roff,
		uint32 *	rlen
	)

Definition at line 58 of file mppc.c.

{
    int k, walker_len = 0, walker;
    uint32 i = 0;
    int next_offset, match_off;
    int match_len;
    int old_offset, match_bits;
    RD_BOOL big = ctype & RDP_MPPC_BIG ? True : False;
 
    uint8 *dict = g_mppc_dict.hist;
 
    if ((ctype & RDP_MPPC_COMPRESSED) == 0)
    {
        *roff = 0;
        *rlen = clen;
        return 0;
    }
 
    if ((ctype & RDP_MPPC_RESET) != 0)
    {
        g_mppc_dict.roff = 0;
    }
 
    if ((ctype & RDP_MPPC_FLUSH) != 0)
    {
        memset(dict, 0, RDP_MPPC_DICT_SIZE);
        g_mppc_dict.roff = 0;
    }
 
    *roff = 0;
    *rlen = 0;
 
    walker = g_mppc_dict.roff;
 
    next_offset = walker;
    old_offset = next_offset;
    *roff = old_offset;
    if (clen == 0)
        return 0;
    clen += i;
 
    do
    {
        if (walker_len == 0)
        {
            if (i >= clen)
                break;
            walker = data[i++] << 24;
            walker_len = 8;
        }
        if (walker >= 0)
        {
            if (walker_len < 8)
            {
                if (i >= clen)
                {
                    if (walker != 0)
                        return -1;
                    break;
                }
                walker |= (data[i++] & 0xff) << (24 - walker_len);
                walker_len += 8;
            }
            if (next_offset >= RDP_MPPC_DICT_SIZE)
                return -1;
            dict[next_offset++] = (((uint32) walker) >> ((uint32) 24));
            walker <<= 8;
            walker_len -= 8;
            continue;
        }
        walker <<= 1;
        /* fetch next 8-bits */
        if (--walker_len == 0)
        {
            if (i >= clen)
                return -1;
            walker = data[i++] << 24;
            walker_len = 8;
        }
        /* literal decoding */
        if (walker >= 0)
        {
            if (walker_len < 8)
            {
                if (i >= clen)
                    return -1;
                walker |= (data[i++] & 0xff) << (24 - walker_len);
                walker_len += 8;
            }
            if (next_offset >= RDP_MPPC_DICT_SIZE)
                return -1;
            dict[next_offset++] = (uint8) (walker >> 24 | 0x80);
            walker <<= 8;
            walker_len -= 8;
            continue;
        }
 
        /* decode offset  */
        /* length pair    */
        walker <<= 1;
        if (--walker_len < (big ? 3 : 2))
        {
            if (i >= clen)
                return -1;
            walker |= (data[i++] & 0xff) << (24 - walker_len);
            walker_len += 8;
        }
 
        if (big)
        {
            /* offset decoding where offset len is:
               -63: 11111 followed by the lower 6 bits of the value
               64-319: 11110 followed by the lower 8 bits of the value ( value - 64 )
               320-2367: 1110 followed by lower 11 bits of the value ( value - 320 )
               2368-65535: 110 followed by lower 16 bits of the value ( value - 2368 )
             */
            switch (((uint32) walker) >> ((uint32) 29))
            {
                case 7: /* - 63 */
                    for (; walker_len < 9; walker_len += 8)
                    {
                        if (i >= clen)
                            return -1;
                        walker |= (data[i++] & 0xff) << (24 - walker_len);
                    }
                    walker <<= 3;
                    match_off = ((uint32) walker) >> ((uint32) 26);
                    walker <<= 6;
                    walker_len -= 9;
                    break;
 
                case 6: /* 64 - 319 */
                    for (; walker_len < 11; walker_len += 8)
                    {
                        if (i >= clen)
                            return -1;
                        walker |= (data[i++] & 0xff) << (24 - walker_len);
                    }
 
                    walker <<= 3;
                    match_off = (((uint32) walker) >> ((uint32) 24)) + 64;
                    walker <<= 8;
                    walker_len -= 11;
                    break;
 
                case 5:
                case 4: /* 320 - 2367 */
                    for (; walker_len < 13; walker_len += 8)
                    {
                        if (i >= clen)
                            return -1;
                        walker |= (data[i++] & 0xff) << (24 - walker_len);
                    }
 
                    walker <<= 2;
                    match_off = (((uint32) walker) >> ((uint32) 21)) + 320;
                    walker <<= 11;
                    walker_len -= 13;
                    break;
 
                default:    /* 2368 - 65535 */
                    for (; walker_len < 17; walker_len += 8)
                    {
                        if (i >= clen)
                            return -1;
                        walker |= (data[i++] & 0xff) << (24 - walker_len);
                    }
 
                    walker <<= 1;
                    match_off = (((uint32) walker) >> ((uint32) 16)) + 2368;
                    walker <<= 16;
                    walker_len -= 17;
                    break;
            }
        }
        else
        {
            /* offset decoding where offset len is:
               -63: 1111 followed by the lower 6 bits of the value
               64-319: 1110 followed by the lower 8 bits of the value ( value - 64 )
               320-8191: 110 followed by the lower 13 bits of the value ( value - 320 )
             */
            switch (((uint32) walker) >> ((uint32) 30))
            {
                case 3: /* - 63 */
                    if (walker_len < 8)
                    {
                        if (i >= clen)
                            return -1;
                        walker |= (data[i++] & 0xff) << (24 - walker_len);
                        walker_len += 8;
                    }
                    walker <<= 2;
                    match_off = ((uint32) walker) >> ((uint32) 26);
                    walker <<= 6;
                    walker_len -= 8;
                    break;
 
                case 2: /* 64 - 319 */
                    for (; walker_len < 10; walker_len += 8)
                    {
                        if (i >= clen)
                            return -1;
                        walker |= (data[i++] & 0xff) << (24 - walker_len);
                    }
 
                    walker <<= 2;
                    match_off = (((uint32) walker) >> ((uint32) 24)) + 64;
                    walker <<= 8;
                    walker_len -= 10;
                    break;
 
                default:    /* 320 - 8191 */
                    for (; walker_len < 14; walker_len += 8)
                    {
                        if (i >= clen)
                            return -1;
                        walker |= (data[i++] & 0xff) << (24 - walker_len);
                    }
 
                    match_off = (walker >> 18) + 320;
                    walker <<= 14;
                    walker_len -= 14;
                    break;
            }
        }
        if (walker_len == 0)
        {
            if (i >= clen)
                return -1;
            walker = data[i++] << 24;
            walker_len = 8;
        }
 
        /* decode length of match */
        match_len = 0;
        if (walker >= 0)
        {       /* special case - length of 3 is in bit 0 */
            match_len = 3;
            walker <<= 1;
            walker_len--;
        }
        else
        {
            /* this is how it works len of:
               4-7: 10 followed by 2 bits of the value
               8-15: 110 followed by 3 bits of the value
               16-31: 1110 followed by 4 bits of the value
               32-63: .... and so forth
               64-127:
               128-255:
               256-511:
               512-1023:
               1024-2047:
               2048-4095:
               4096-8191:
 
               i.e. 4097 is encoded as: 111111111110 000000000001
               meaning 4096 + 1...
             */
            match_bits = big ? 14 : 11; /* 11 or 14 bits of value at most */
            do
            {
                walker <<= 1;
                if (--walker_len == 0)
                {
                    if (i >= clen)
                        return -1;
                    walker = data[i++] << 24;
                    walker_len = 8;
                }
                if (walker >= 0)
                    break;
                if (--match_bits == 0)
                {
                    return -1;
                }
            }
            while (1);
            match_len = (big ? 16 : 13) - match_bits;
            walker <<= 1;
            if (--walker_len < match_len)
            {
                for (; walker_len < match_len; walker_len += 8)
                {
                    if (i >= clen)
                    {
                        return -1;
                    }
                    walker |= (data[i++] & 0xff) << (24 - walker_len);
                }
            }
 
            match_bits = match_len;
            match_len =
                ((walker >> (32 - match_bits)) & (~(-1 << match_bits))) | (1 <<
                                               match_bits);
            walker <<= match_bits;
            walker_len -= match_bits;
        }
        if (next_offset + match_len >= RDP_MPPC_DICT_SIZE)
        {
            return -1;
        }
        /* memory areas can overlap - meaning we can't use memXXX functions */
        k = (next_offset - match_off) & (big ? 65535 : 8191);
        do
        {
            dict[next_offset++] = dict[k++];
        }
        while (--match_len != 0);
    }
    while (1);
 
    /* store history offset */
    g_mppc_dict.roff = next_offset;
 
    *roff = old_offset;
    *rlen = next_offset - old_offset;
 
    return 0;
}

Referenced by process_data_pdu(), and rdp5_process().

next_arg()

char * next_arg	(	char *	src,
		char	needle
	)

Definition at line 1174 of file rdesktop.c.

{
    char *nextval;
    char *p;
    char *mvp = 0;
 
    /* EOS */
    if (*src == (char) 0x00)
        return 0;
 
    p = src;
    /*  skip escaped needles */
    while ((nextval = strchr(p, needle)))
    {
        mvp = nextval - 1;
        /* found backslashed needle */
        if (*mvp == '\\' && (mvp > src))
        {
            /* move string one to the left */
            while (*(mvp + 1) != (char) 0x00)
            {
                *mvp = *(mvp + 1);
                mvp++;
            }
            *mvp = (char) 0x00;
            p = nextval;
        }
        else
        {
            p = nextval + 1;
            break;
        }
 
    }
 
    /* more args available */
    if (nextval)
    {
        *nextval = (char) 0x00;
        return ++nextval;
    }
 
    /* no more args after this, jump to EOS */
    nextval = src + strlen(src);
    return nextval;
}

Referenced by disk_enum_devices(), parallel_enum_devices(), printer_enum_devices(), serial_enum_devices(), service_mainA(), and service_mainW().

parallel_enum_devices()

int parallel_enum_devices	(	uint32 *	id,
		char *	optarg
	)

Referenced by main().

printer_enum_devices()

int printer_enum_devices	(	uint32 *	id,
		char *	optarg
	)

Referenced by main().

printercache_load_blob()

int printercache_load_blob	(	char *	printer_name,
		uint8 **	data
	)

Definition at line 154 of file printercache.c.

{
    char *home, *path;
    struct stat st;
    int fd, length;
 
    if (printer_name == NULL)
        return 0;
 
    *data = NULL;
 
    home = getenv("HOME");
    if (home == NULL)
        return 0;
 
    path = (char *) xmalloc(strlen(home) + sizeof("/.rdesktop/rdpdr/") + strlen(printer_name) +
                sizeof("/AutoPrinterCacheData") + 1);
    sprintf(path, "%s/.rdesktop/rdpdr/%s/AutoPrinterCacheData", home, printer_name);
 
    fd = open(path, O_RDONLY);
    if (fd == -1)
    {
        xfree(path);
        return 0;
    }
 
    if (fstat(fd, &st))
    {
        xfree(path);
        close(fd);
        return 0;
    }
 
    *data = (uint8 *) xmalloc(st.st_size);
    length = read(fd, *data, st.st_size);
    close(fd);
    xfree(path);
    return length;
}

Referenced by announcedata_size().

printercache_process()

void printercache_process

(

STREAM

s

)

Referenced by rdpdr_process().

process_bitmap_updates()

void process_bitmap_updates

(

STREAM

s

)

Definition at line 1224 of file rdp.c.

{
    uint16 num_updates;
    uint16 left, top, right, bottom, width, height;
    uint16 cx, cy, bpp, Bpp, compress, bufsize, size;
    uint8 *data, *bmpdata;
    int i;
 
    in_uint16_le(s, num_updates);
 
    for (i = 0; i < num_updates; i++)
    {
        in_uint16_le(s, left);
        in_uint16_le(s, top);
        in_uint16_le(s, right);
        in_uint16_le(s, bottom);
        in_uint16_le(s, width);
        in_uint16_le(s, height);
        in_uint16_le(s, bpp);
        Bpp = (bpp + 7) / 8;
        in_uint16_le(s, compress);
        in_uint16_le(s, bufsize);
 
        cx = right - left + 1;
        cy = bottom - top + 1;
 
        DEBUG(("BITMAP_UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,Bpp=%d,cmp=%d)\n",
               left, top, right, bottom, width, height, Bpp, compress));
 
        if (!compress)
        {
            int y;
            bmpdata = (uint8 *) xmalloc(width * height * Bpp);
            for (y = 0; y < height; y++)
            {
                in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],
                      width * Bpp);
            }
            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
            xfree(bmpdata);
            continue;
        }
 
 
        if (compress & 0x400)
        {
            size = bufsize;
        }
        else
        {
            in_uint8s(s, 2);    /* pad */
            in_uint16_le(s, size);
            in_uint8s(s, 4);    /* line_size, final_size */
        }
        in_uint8p(s, data, size);
        bmpdata = (uint8 *) xmalloc(width * height * Bpp);
        if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
        {
            ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
        }
        else
        {
            DEBUG_RDP5(("Failed to decompress data\n"));
        }
 
        xfree(bmpdata);
    }
}

Referenced by process_update_pdu(), and rdp5_process().

process_cached_pointer_pdu()

void process_cached_pointer_pdu

(

STREAM

s

)

Definition at line 1156 of file rdp.c.

{
    uint16 cache_idx;
 
    in_uint16_le(s, cache_idx);
    ui_set_cursor(cache_get_cursor(cache_idx));
}

Referenced by process_pointer_pdu(), and rdp5_process().

process_colour_pointer_pdu()

void process_colour_pointer_pdu

(

STREAM

s

)

Definition at line 1139 of file rdp.c.

{
    process_colour_pointer_common(s, 24);
}

Referenced by process_pointer_pdu(), and rdp5_process().

process_disconnect_pdu()

void process_disconnect_pdu	(	STREAM	s,
		uint32 *	ext_disc_reason
	)

Definition at line 1407 of file rdp.c.

{
    in_uint32_le(s, *ext_disc_reason);
 
    DEBUG(("Received disconnect PDU\n"));
}

process_new_pointer_pdu()

void process_new_pointer_pdu

(

STREAM

s

)

Definition at line 1146 of file rdp.c.

{
    int xor_bpp;
 
    in_uint16_le(s, xor_bpp);
    process_colour_pointer_common(s, xor_bpp);
}

Referenced by process_pointer_pdu(), and rdp5_process().

process_orders()

void process_orders	(	STREAM	s,
		uint16	num_orders
	)

Definition at line 1311 of file orders.c.

{
    RDP_ORDER_STATE *os = &g_order_state;
    uint32 present;
    uint8 order_flags;
    int size, processed = 0;
    RD_BOOL delta;
 
    while (processed < num_orders)
    {
        in_uint8(s, order_flags);
 
        if (!(order_flags & RDP_ORDER_STANDARD))
        {
            error("order parsing failed\n");
            break;
        }
 
        if (order_flags & RDP_ORDER_SECONDARY)
        {
            process_secondary_order(s);
        }
        else
        {
            if (order_flags & RDP_ORDER_CHANGE)
            {
                in_uint8(s, os->order_type);
            }
 
            switch (os->order_type)
            {
                case RDP_ORDER_TRIBLT:
                case RDP_ORDER_TEXT2:
                    size = 3;
                    break;
 
                case RDP_ORDER_PATBLT:
                case RDP_ORDER_MEMBLT:
                case RDP_ORDER_LINE:
                case RDP_ORDER_POLYGON2:
                case RDP_ORDER_ELLIPSE2:
                    size = 2;
                    break;
 
                default:
                    size = 1;
            }
 
            rdp_in_present(s, &present, order_flags, size);
 
            if (order_flags & RDP_ORDER_BOUNDS)
            {
                if (!(order_flags & RDP_ORDER_LASTBOUNDS))
                    rdp_parse_bounds(s, &os->bounds);
 
                ui_set_clip(os->bounds.left,
                        os->bounds.top,
                        os->bounds.right -
                        os->bounds.left + 1,
                        os->bounds.bottom - os->bounds.top + 1);
            }
 
            delta = order_flags & RDP_ORDER_DELTA;
 
            switch (os->order_type)
            {
                case RDP_ORDER_DESTBLT:
                    process_destblt(s, &os->destblt, present, delta);
                    break;
 
                case RDP_ORDER_PATBLT:
                    process_patblt(s, &os->patblt, present, delta);
                    break;
 
                case RDP_ORDER_SCREENBLT:
                    process_screenblt(s, &os->screenblt, present, delta);
                    break;
 
                case RDP_ORDER_LINE:
                    process_line(s, &os->line, present, delta);
                    break;
 
                case RDP_ORDER_RECT:
                    process_rect(s, &os->rect, present, delta);
                    break;
 
                case RDP_ORDER_DESKSAVE:
                    process_desksave(s, &os->desksave, present, delta);
                    break;
 
                case RDP_ORDER_MEMBLT:
                    process_memblt(s, &os->memblt, present, delta);
                    break;
 
                case RDP_ORDER_TRIBLT:
                    process_triblt(s, &os->triblt, present, delta);
                    break;
 
                case RDP_ORDER_POLYGON:
                    process_polygon(s, &os->polygon, present, delta);
                    break;
 
                case RDP_ORDER_POLYGON2:
                    process_polygon2(s, &os->polygon2, present, delta);
                    break;
 
                case RDP_ORDER_POLYLINE:
                    process_polyline(s, &os->polyline, present, delta);
                    break;
 
                case RDP_ORDER_ELLIPSE:
                    process_ellipse(s, &os->ellipse, present, delta);
                    break;
 
                case RDP_ORDER_ELLIPSE2:
                    process_ellipse2(s, &os->ellipse2, present, delta);
                    break;
 
                case RDP_ORDER_TEXT2:
                    process_text2(s, &os->text2, present, delta);
                    break;
 
                default:
                    unimpl("order %d\n", os->order_type);
                    return;
            }
 
            if (order_flags & RDP_ORDER_BOUNDS)
                ui_reset_clip();
        }
 
        processed++;
    }
#if 0
    /* not true when RDP_COMPRESSION is set */
    if (s->p != g_next_packet)
        error("%d bytes remaining\n", (int) (g_next_packet - s->p));
#endif
 
}

Referenced by process_update_pdu(), and rdp5_process().

process_palette()

void process_palette

(

STREAM

s

)

Definition at line 1295 of file rdp.c.

{
    COLOURENTRY *entry;
    COLOURMAP map;
    RD_HCOLOURMAP hmap;
    int i;
 
    in_uint8s(s, 2);    /* pad */
    in_uint16_le(s, map.ncolours);
    in_uint8s(s, 2);    /* pad */
 
    map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
 
    DEBUG(("PALETTE(c=%d)\n", map.ncolours));
 
    for (i = 0; i < map.ncolours; i++)
    {
        entry = &map.colours[i];
        in_uint8(s, entry->red);
        in_uint8(s, entry->green);
        in_uint8(s, entry->blue);
    }
 
    hmap = ui_create_colourmap(&map);
    ui_set_colourmap(hmap);
 
    xfree(map.colours);
}

Referenced by process_update_pdu(), and rdp5_process().

process_system_pointer_pdu()

void process_system_pointer_pdu

(

STREAM

s

)

Definition at line 1166 of file rdp.c.

{
    uint16 system_pointer_type;
 
    in_uint16_le(s, system_pointer_type);
    switch (system_pointer_type)
    {
        case RDP_NULL_POINTER:
            ui_set_null_cursor();
            break;
 
        default:
            unimpl("System pointer message 0x%x\n", system_pointer_type);
    }
}

Referenced by process_pointer_pdu().

pstcache_enumerate()

int pstcache_enumerate	(	uint8	id,
		HASH_KEY *	keylist
	)

Definition at line 107 of file pstcache.c.

{
    int fd, n;
    uint16 idx;
    sint16 mru_idx[0xa00];
    uint32 mru_stamp[0xa00];
    CELLHEADER cellhdr;
 
    if (!(g_bitmap_cache && g_bitmap_cache_persist_enable && IS_PERSISTENT(id)))
        return 0;
 
    /* The server disconnects if the bitmap cache content is sent more than once */
    if (g_pstcache_enumerated)
        return 0;
 
    DEBUG_RDP5(("Persistent bitmap cache enumeration... "));
    for (idx = 0; idx < BMPCACHE2_NUM_PSTCELLS; idx++)
    {
        fd = g_pstcache_fd[id];
        rd_lseek_file(fd, idx * (g_pstcache_Bpp * MAX_CELL_SIZE + sizeof(CELLHEADER)));
        if (rd_read_file(fd, &cellhdr, sizeof(CELLHEADER)) <= 0)
            break;
 
        if (memcmp(cellhdr.key, zero_key, sizeof(HASH_KEY)) != 0)
        {
            memcpy(keylist[idx], cellhdr.key, sizeof(HASH_KEY));
 
            /* Pre-cache (not possible for 8 bit colour depth cause it needs a colourmap) */
            if (g_bitmap_cache_precache && cellhdr.stamp && g_server_depth > 8)
                pstcache_load_bitmap(id, idx);
 
            /* Sort by stamp */
            for (n = idx; n > 0 && cellhdr.stamp < mru_stamp[n - 1]; n--)
            {
                mru_idx[n] = mru_idx[n - 1];
                mru_stamp[n] = mru_stamp[n - 1];
            }
 
            mru_idx[n] = idx;
            mru_stamp[n] = cellhdr.stamp;
        }
        else
        {
            break;
        }
    }
 
    DEBUG_RDP5(("%d cached bitmaps.\n", idx));
 
    cache_rebuild_bmpcache_linked_list(id, mru_idx, idx);
    g_pstcache_enumerated = True;
    return idx;
}

Referenced by rdp_enum_bmpcache2().

pstcache_init()

RD_BOOL pstcache_init

(

uint8

cache_id

)

Definition at line 163 of file pstcache.c.

{
    int fd;
    char filename[256];
 
    if (g_pstcache_enumerated)
        return True;
 
    g_pstcache_fd[cache_id] = 0;
 
    if (!(g_bitmap_cache && g_bitmap_cache_persist_enable))
        return False;
 
    if (!rd_pstcache_mkdir())
    {
        DEBUG(("failed to get/make cache directory!\n"));
        return False;
    }
 
    g_pstcache_Bpp = (g_server_depth + 7) / 8;
    sprintf(filename, "cache/pstcache_%d_%d", cache_id, g_pstcache_Bpp);
    DEBUG(("persistent bitmap cache file: %s\n", filename));
 
    fd = rd_open_file(filename);
    if (fd == -1)
        return False;
 
    if (!rd_lock_file(fd, 0, 0))
    {
        warning("Persistent bitmap caching is disabled. (The file is already in use)\n");
        rd_close_file(fd);
        return False;
    }
 
    g_pstcache_fd[cache_id] = fd;
    return True;
}

Referenced by rdp_out_bmpcache2_caps().

pstcache_load_bitmap()

RD_BOOL pstcache_load_bitmap	(	uint8	cache_id,
		uint16	cache_idx
	)

Definition at line 53 of file pstcache.c.

{
    uint8 *celldata;
    int fd;
    CELLHEADER cellhdr;
    RD_HBITMAP bitmap;
 
    if (!g_bitmap_cache_persist_enable)
        return False;
 
    if (!IS_PERSISTENT(cache_id) || cache_idx >= BMPCACHE2_NUM_PSTCELLS)
        return False;
 
    fd = g_pstcache_fd[cache_id];
    rd_lseek_file(fd, cache_idx * (g_pstcache_Bpp * MAX_CELL_SIZE + sizeof(CELLHEADER)));
    rd_read_file(fd, &cellhdr, sizeof(CELLHEADER));
    celldata = (uint8 *) xmalloc(cellhdr.length);
    rd_read_file(fd, celldata, cellhdr.length);
 
    bitmap = ui_create_bitmap(cellhdr.width, cellhdr.height, celldata);
    DEBUG(("Load bitmap from disk: id=%d, idx=%d, bmp=%p)\n", cache_id, cache_idx, bitmap));
    cache_put_bitmap(cache_id, cache_idx, bitmap);
 
    xfree(celldata);
    return True;
}

Referenced by cache_get_bitmap(), and pstcache_enumerate().

pstcache_save_bitmap()

RD_BOOL pstcache_save_bitmap	(	uint8	cache_id,
		uint16	cache_idx,
		uint8 *	key,
		uint8	width,
		uint8	height,
		uint16	length,
		uint8 *	data
	)

Definition at line 82 of file pstcache.c.

{
    int fd;
    CELLHEADER cellhdr;
 
    if (!IS_PERSISTENT(cache_id) || cache_idx >= BMPCACHE2_NUM_PSTCELLS)
        return False;
 
    memcpy(cellhdr.key, key, sizeof(HASH_KEY));
    cellhdr.width = width;
    cellhdr.height = height;
    cellhdr.length = length;
    cellhdr.stamp = 0;
 
    fd = g_pstcache_fd[cache_id];
    rd_lseek_file(fd, cache_idx * (g_pstcache_Bpp * MAX_CELL_SIZE + sizeof(CELLHEADER)));
    rd_write_file(fd, &cellhdr, sizeof(CELLHEADER));
    rd_write_file(fd, data, length);
 
    return True;
}

Referenced by process_bmpcache2().

pstcache_touch_bitmap()

void pstcache_touch_bitmap	(	uint8	cache_id,
		uint16	cache_idx,
		uint32	stamp
	)

Definition at line 39 of file pstcache.c.

{
    int fd;
 
    if (!IS_PERSISTENT(cache_id) || cache_idx >= BMPCACHE2_NUM_PSTCELLS)
        return;
 
    fd = g_pstcache_fd[cache_id];
    rd_lseek_file(fd, 12 + cache_idx * (g_pstcache_Bpp * MAX_CELL_SIZE + sizeof(CELLHEADER)));
    rd_write_file(fd, &stamp, sizeof(stamp));
}

Referenced by cache_evict_bitmap(), and cache_save_state().

rd_close_file()

void rd_close_file

(

int

fd

)

Definition at line 847 of file uimain.c.

{
  return;
}

Referenced by pstcache_init().

rd_create_ui()

void rd_create_ui

(

void

)

rd_lock_file()

RD_BOOL rd_lock_file	(	int	fd,
		int	start,
		int	len
	)

Definition at line 875 of file uimain.c.

{
  return False;
}

Referenced by pstcache_init().

rd_lseek_file()

int rd_lseek_file	(	int	fd,
		int	offset
	)

Definition at line 868 of file uimain.c.

{
  return 0;
}

Referenced by pstcache_enumerate(), pstcache_load_bitmap(), pstcache_save_bitmap(), and pstcache_touch_bitmap().

rd_open_file()

int rd_open_file

(

char *

filename

)

Definition at line 840 of file uimain.c.

{
  return 0;
}

Referenced by pstcache_init().

rd_pstcache_mkdir()

RD_BOOL rd_pstcache_mkdir

(

void

)

Definition at line 833 of file uimain.c.

{
  return 0;
}

Referenced by pstcache_init().

rd_read_file()

int rd_read_file	(	int	fd,
		void *	ptr,
		int	len
	)

Definition at line 854 of file uimain.c.

{
  return 0;
}

Referenced by pstcache_enumerate(), and pstcache_load_bitmap().

rd_write_file()

int rd_write_file	(	int	fd,
		void *	ptr,
		int	len
	)

Definition at line 861 of file uimain.c.

{
  return 0;
}

Referenced by pstcache_save_bitmap(), and pstcache_touch_bitmap().

rdp5_process()

void rdp5_process

(

STREAM

s

)

Definition at line 28 of file rdp5.c.

{
    uint16 length, count, x, y;
    uint8 type, ctype;
    uint8 *next;
 
    uint32 roff, rlen;
    struct stream *ns = &(g_mppc_dict.ns);
    struct stream *ts;
 
#if 0
    printf("RDP5 data:\n");
    hexdump(s->p, s->end - s->p);
#endif
 
    ui_begin_update();
    while (s->p < s->end)
    {
        in_uint8(s, type);
        if (type & RDP5_COMPRESSED)
        {
            in_uint8(s, ctype);
            in_uint16_le(s, length);
            type ^= RDP5_COMPRESSED;
        }
        else
        {
            ctype = 0;
            in_uint16_le(s, length);
        }
        g_next_packet = next = s->p + length;
 
        if (ctype & RDP_MPPC_COMPRESSED)
        {
            if (mppc_expand(s->p, length, ctype, &roff, &rlen) == -1)
                error("error while decompressing packet\n");
 
            /* allocate memory and copy the uncompressed data into the temporary stream */
            ns->data = (uint8 *) xrealloc(ns->data, rlen);
 
            memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);
 
            ns->size = rlen;
            ns->end = (ns->data + ns->size);
            ns->p = ns->data;
            ns->rdp_hdr = ns->p;
 
            ts = ns;
        }
        else
            ts = s;
 
        switch (type)
        {
            case 0: /* update orders */
                in_uint16_le(ts, count);
                process_orders(ts, count);
                break;
            case 1: /* update bitmap */
                in_uint8s(ts, 2);   /* part length */
                process_bitmap_updates(ts);
                break;
            case 2: /* update palette */
                in_uint8s(ts, 2);   /* uint16 = 2 */
                process_palette(ts);
                break;
            case 3: /* update synchronize */
                break;
            case 5: /* null pointer */
                ui_set_null_cursor();
                break;
            case 6: /* default pointer */
                break;
            case 8: /* pointer position */
                in_uint16_le(ts, x);
                in_uint16_le(ts, y);
                if (s_check(ts))
                    ui_move_pointer(x, y);
                break;
            case 9: /* color pointer */
                process_colour_pointer_pdu(ts);
                break;
            case 10:    /* cached pointer */
                process_cached_pointer_pdu(ts);
                break;
            case 11:
                process_new_pointer_pdu(ts);
                break;
            default:
                unimpl("RDP5 opcode %d\n", type);
        }
 
        s->p = next;
    }
    ui_end_update();
}

Referenced by rdp_recv().

rdp_connect()

RD_BOOL rdp_connect	(	char *	server,
		uint32	flags,
		char *	domain,
		char *	password,
		char *	command,
		char *	directory,
		RD_BOOL	reconnect
	)

Definition at line 1742 of file rdp.c.

{
    RD_BOOL deactivated = False;
    uint32 ext_disc_reason = 0;
 
    if (!sec_connect(server, g_username, domain, password, reconnect))
        return False;
 
    rdp_send_logon_info(flags, domain, g_username, password, command, directory);
 
    /* run RDP loop until first licence demand active PDU */
    while (!g_rdp_shareid)
    {
        if (g_network_error)
            return False;
 
        if (!rdp_loop(&deactivated, &ext_disc_reason))
            return False;
 
        if (g_redirect)
            return True;
    }
    return True;
}

Referenced by main(), mstsc_ProtocolIOThread(), param_connect(), SEALED_::ProtocolLoop(), rdp2vnc_connect(), QMyScrollView::timerEvent(), ui_main(), and ui_main_loop().

rdp_disconnect()

void rdp_disconnect

(

void

)

Definition at line 1779 of file rdp.c.

{
    sec_disconnect();
}

Referenced by main(), SEALED_::ProtocolLoop(), and rdp2vnc_connect().

rdp_in_unistr()

void rdp_in_unistr	(	STREAM	s,
		int	in_len,
		char **	string,
		uint32 *	str_size
	)

Definition at line 265 of file rdp.c.

{
    /* Dynamic allocate of destination string if not provided */
    *string = xmalloc(in_len * 2);
    *str_size = in_len * 2;
 
#ifdef HAVE_ICONV
    size_t ibl = in_len, obl = *str_size - 1;
    char *pin = (char *) s->p, *pout = *string;
    static iconv_t iconv_h = (iconv_t) - 1;
 
    if (g_iconv_works)
    {
        if (iconv_h == (iconv_t) - 1)
        {
            if ((iconv_h = iconv_open(g_codepage, WINDOWS_CODEPAGE)) == (iconv_t) - 1)
            {
                warning("rdp_in_unistr: iconv_open[%s -> %s] fail %d\n",
                    WINDOWS_CODEPAGE, g_codepage, (int) iconv_h);
 
                g_iconv_works = False;
                return rdp_in_unistr(s, in_len, string, str_size);
            }
        }
 
        if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
        {
            if (errno == E2BIG)
            {
                warning("server sent an unexpectedly long string, truncating\n");
            }
            else
            {
                warning("rdp_in_unistr: iconv fail, errno %d\n", errno);
 
                free(*string);
                *string = NULL;
                *str_size = 0;
            }
        }
 
        /* we must update the location of the current STREAM for future reads of s->p */
        s->p += in_len;
 
        *pout = 0;
 
        if (*string)
            *str_size = pout - *string;
    }
    else
#endif
    {
        int i = 0;
        int rem = 0;
        uint32 len = in_len / 2;
 
        if (len > *str_size - 1)
        {
            warning("server sent an unexpectedly long string, truncating\n");
            len = *str_size - 1;
            rem = in_len - 2 * len;
        }
 
        while (i < len)
        {
            in_uint8a(s, &string[i++], 1);
            in_uint8s(s, 1);
        }
 
        in_uint8s(s, rem);
        string[len] = 0;
        *str_size = len;
    }
}

Referenced by disk_set_information(), printercache_process(), process_redirect_pdu(), rdp_in_unistr(), and rdpdr_process_irp().

rdp_loop()

RD_BOOL rdp_loop	(	RD_BOOL *	deactivated,
		uint32 *	ext_disc_reason
	)

Definition at line 1695 of file rdp.c.

{
    uint8 type;
    RD_BOOL cont = True;
    STREAM s;
 
    while (cont)
    {
        s = rdp_recv(&type);
        if (s == NULL)
            return False;
        switch (type)
        {
            case RDP_PDU_DEMAND_ACTIVE:
                process_demand_active(s);
                *deactivated = False;
                break;
            case RDP_PDU_DEACTIVATE:
                DEBUG(("RDP_PDU_DEACTIVATE\n"));
                *deactivated = True;
                break;
            case RDP_PDU_REDIRECT:
                return process_redirect_pdu(s, False);
                break;
            case RDP_PDU_ENHANCED_REDIRECT:
                return process_redirect_pdu(s, True);
                break;
            case RDP_PDU_DATA:
                /* If we got a data PDU, we don't need to keep the password in memory
                   anymore and therefor we should clear it for security reasons. */
                if (g_password[0] != '\0')
                    memset(g_password, 0, sizeof(g_password));
 
                process_data_pdu(s, ext_disc_reason);
                break;
            case 0:
                break;
            default:
                unimpl("PDU %d\n", type);
        }
        cont = g_next_packet < s->end;
    }
    return True;
}

Referenced by QMyMainWindow::dataReceived(), nanox_event(), rdp_connect(), rdp_main_loop(), ui_main_loop(), and ui_read_wire().

rdp_main_loop()

void rdp_main_loop	(	RD_BOOL *	deactivated,
		uint32 *	ext_disc_reason
	)

Definition at line 1682 of file rdp.c.

{
    while (rdp_loop(deactivated, ext_disc_reason))
    {
        if (g_pending_resize || g_redirect)
        {
            return;
        }
    }
}

Referenced by main(), mstsc_ProtocolIOThread(), SEALED_::ProtocolLoop(), and rdp2vnc_connect().

rdp_out_unistr()

void rdp_out_unistr	(	STREAM	s,
		char *	string,
		int	len
	)

Definition at line 188 of file rdp.c.

{
    if (string == NULL || len == 0)
        return;
 
#ifdef HAVE_ICONV
    size_t ibl = strlen(string), obl = len + 2;
    static iconv_t iconv_h = (iconv_t) - 1;
    char *pin = string, *pout = (char *) s->p;
 
    memset(pout, 0, len + 4);
 
    if (g_iconv_works)
    {
        if (iconv_h == (iconv_t) - 1)
        {
            size_t i = 1, o = 4;
            if ((iconv_h = iconv_open(WINDOWS_CODEPAGE, g_codepage)) == (iconv_t) - 1)
            {
                warning("rdp_out_unistr: iconv_open[%s -> %s] fail %d\n",
                    g_codepage, WINDOWS_CODEPAGE, (int) iconv_h);
 
                g_iconv_works = False;
                rdp_out_unistr(s, string, len);
                return;
            }
            if (iconv(iconv_h, (ICONV_CONST char **) &pin, &i, &pout, &o) ==
                (size_t) - 1)
            {
                iconv_close(iconv_h);
                iconv_h = (iconv_t) - 1;
                warning("rdp_out_unistr: iconv(1) fail, errno %d\n", errno);
 
                g_iconv_works = False;
                rdp_out_unistr(s, string, len);
                return;
            }
            pin = string;
            pout = (char *) s->p;
        }
 
        if (iconv(iconv_h, (ICONV_CONST char **) &pin, &ibl, &pout, &obl) == (size_t) - 1)
        {
            iconv_close(iconv_h);
            iconv_h = (iconv_t) - 1;
            warning("rdp_out_unistr: iconv(2) fail, errno %d\n", errno);
 
            g_iconv_works = False;
            rdp_out_unistr(s, string, len);
            return;
        }
 
        s->p += len + 2;
 
    }
    else
#endif
    {
        int i = 0, j = 0;
 
        len += 2;
 
        while (i < len)
        {
            s->p[i++] = string[j++];
            s->p[i++] = 0;
        }
 
        s->p += len;
    }
}

Referenced by disk_query_directory(), disk_query_volume_information(), rdp_out_unistr(), rdp_out_unistr_mandatory_null(), rdp_send_logon_info(), rdpdr_send_available(), rdpdr_send_name(), and sec_out_mcs_data().

rdp_reset_state()

void rdp_reset_state

(

void

)

Definition at line 1770 of file rdp.c.

{
    g_next_packet = NULL;   /* reset the packet information */
    g_rdp_shareid = 0;
    sec_reset_state();
}

Referenced by SEALED_::ProtocolLoop(), and rdesktop_reset_state().

rdp_send_client_window_status()

void rdp_send_client_window_status

(

int

status

)

Definition at line 572 of file rdp.c.

{
    STREAM s;
    static int current_status = 1;
 
    if (current_status == status)
        return;
 
    s = rdp_init_data(12);
 
    out_uint32_le(s, status);
 
    switch (status)
    {
        case 0: /* shut the server up */
            break;
 
        case 1: /* receive data again */
            out_uint32_le(s, 0);    /* unknown */
            out_uint16_le(s, g_width);
            out_uint16_le(s, g_height);
            break;
    }
 
    s_mark_end(s);
    rdp_send_data(s, RDP_DATA_PDU_CLIENT_WINDOW_STATUS);
    current_status = status;
}

Referenced by xwin_process_events().

rdp_send_input()

void rdp_send_input	(	uint32	time,
		uint16	message_type,
		uint16	device_flags,
		uint16	param1,
		uint16	param2
	)

Definition at line 551 of file rdp.c.

{
    STREAM s;
 
    s = rdp_init_data(16);
 
    out_uint16_le(s, 1);    /* number of events */
    out_uint16(s, 0);   /* pad */
 
    out_uint32_le(s, time);
    out_uint16_le(s, message_type);
    out_uint16_le(s, device_flags);
    out_uint16_le(s, param1);
    out_uint16_le(s, param2);
 
    s_mark_end(s);
    rdp_send_data(s, RDP_DATA_PDU_INPUT);
}

Referenced by ensure_remote_modifiers(), handle_button_event(), handle_special_keys(), key_event(), QMyScrollView::keyPressEvent(), QMyMainWindow::keyPressEvent(), QMyScrollView::keyReleaseEvent(), QMyMainWindow::keyReleaseEvent(), QMyMainWindow::MemuClicked(), QMyMainWindow::mouseMoveEvent(), QMyMainWindow::mousePressEvent(), QMyMainWindow::mouseReleaseEvent(), mstsc_mousewheel(), mstsc_WndProc(), nanox_event(), process_demand_active(), process_keystroke(), process_mouse(), rdp_send_scancode(), reset_modifier_keys(), QMyMainWindow::timerEvent(), ui_key_down(), ui_key_up(), ui_mouse_button(), ui_mouse_move(), ui_set_modifier_state(), vncMouse(), QMyMainWindow::wheelEvent(), and xwin_process_events().

rdp_send_scancode()

void rdp_send_scancode	(	uint32	time,
		uint16	flags,
		uint8	scancode
	)

Referenced by vncKey().

rdpdr_abort_io()

RD_BOOL rdpdr_abort_io	(	uint32	fd,
		uint32	major,
		RD_NTSTATUS	status
	)

Referenced by disk_close(), serial_close(), and serial_device_control().

rdpdr_add_fds()

void rdpdr_add_fds	(	int *	n,
		fd_set *	rfds,
		fd_set *	wfds,
		struct timeval *	tv,
		RD_BOOL *	timeout
	)

Referenced by ui_select().

rdpdr_check_fds()

void rdpdr_check_fds	(	fd_set *	rfds,
		fd_set *	wfds,
		RD_BOOL	timed_out
	)

Referenced by ui_select().

rdpdr_init()

RD_BOOL rdpdr_init

(

)

Referenced by main().

rdpdr_remove_iorequest()

struct async_iorequest * rdpdr_remove_iorequest	(	struct async_iorequest *	prev,
		struct async_iorequest *	iorq
	)

rdpdr_send_completion()

void rdpdr_send_completion	(	uint32	device,
		uint32	id,
		uint32	status,
		uint32	result,
		uint8 *	buffer,
		uint32	length
	)

rdpsnd_add_fds()

void rdpsnd_add_fds	(	int *	n,
		fd_set *	rfds,
		fd_set *	wfds,
		struct timeval *	tv
	)

rdpsnd_check_fds()

void rdpsnd_check_fds	(	fd_set *	rfds,
		fd_set *	wfds
	)

rdpsnd_init()

RD_BOOL rdpsnd_init

(

char *

optarg

)

Referenced by main(), param_connect(), QMyScrollView::timerEvent(), and ui_main_loop().

rdpsnd_queue_current_packet()

struct audio_packet * rdpsnd_queue_current_packet

(

void

)

rdpsnd_queue_empty()

RD_BOOL rdpsnd_queue_empty

(

void

)

rdpsnd_queue_next()

void rdpsnd_queue_next

(

unsigned long

completed_in_us

)

rdpsnd_queue_next_tick()

int rdpsnd_queue_next_tick

(

void

)

rdpsnd_record()

void rdpsnd_record	(	const void *	data,
		unsigned int	size
	)

rdpsnd_reset_state()

void rdpsnd_reset_state

(

void

)

rdpsnd_show_help()

void rdpsnd_show_help

(

void

)

read_keyboard_state()

unsigned int read_keyboard_state

(

void

)

Definition at line 632 of file uimain.c.

{
  return (uint32) mi_read_keyboard_state();
}

Referenced by handle_special_keys(), process_demand_active(), and reset_modifier_keys().

reset_modifier_keys()

void reset_modifier_keys

(

void

)

Referenced by xwin_process_events().

reset_order_state()

void reset_order_state

(

void

)

Definition at line 1454 of file orders.c.

{
    memset(&g_order_state, 0, sizeof(g_order_state));
    g_order_state.order_type = RDP_ORDER_PATBLT;
}

Referenced by process_demand_active().

restore_remote_modifiers()

void restore_remote_modifiers	(	uint32	ev_time,
		uint8	scancode
	)

save_licence()

void save_licence	(	unsigned char *	data,
		int	length
	)

Referenced by licence_process_issue(), and licence_process_new_license().

save_remote_modifiers()

void save_remote_modifiers

(

uint8

scancode

)

scard_enum_devices()

int scard_enum_devices	(	uint32 *	id,
		char *	optarg
	)

scard_lock()

void scard_lock

(

int

lock

)

Referenced by channel_send(), sec_send_to_channel(), tcp_init(), and tcp_send().

scard_reset_state()

void scard_reset_state

(

)

scard_unlock()

void scard_unlock

(

int

lock

)

Referenced by channel_send(), sec_send_to_channel(), tcp_init(), and tcp_send().

scardSetInfo()

void scardSetInfo	(	uint32	epoch,
		uint32	device,
		uint32	id,
		uint32	bytes_out
	)

seamless_init()

RD_BOOL seamless_init

(

void

)

Referenced by ui_init().

seamless_reset_state()

void seamless_reset_state

(

void

)

seamless_select_timeout()

void seamless_select_timeout

(

struct timeval *

tv

)

Referenced by ui_select().

seamless_send_destroy()

unsigned int seamless_send_destroy

(

unsigned long

id

)

seamless_send_focus()

unsigned int seamless_send_focus	(	unsigned long	id,
		unsigned long	flags
	)

Referenced by xwin_process_events().

seamless_send_persistent()

unsigned int seamless_send_persistent

(

RD_BOOL

)

seamless_send_position()

unsigned int seamless_send_position	(	unsigned long	id,
		int	x,
		int	y,
		int	width,
		int	height,
		unsigned long	flags
	)

Referenced by sw_update_position().

seamless_send_spawn()

unsigned int seamless_send_spawn

(

char *

cmd

)

seamless_send_state()

unsigned int seamless_send_state	(	unsigned long	id,
		unsigned int	state,
		unsigned long	flags
	)

Referenced by xwin_process_events().

seamless_send_sync()

unsigned int seamless_send_sync

(

void

)

Referenced by ui_seamless_toggle().

seamless_send_zchange()

unsigned int seamless_send_zchange	(	unsigned long	id,
		unsigned long	below,
		unsigned long	flags
	)

Referenced by sw_handle_restack().

sec_connect()

RD_BOOL sec_connect	(	char *	server,
		char *	username,
		char *	domain,
		char *	password,
		RD_BOOL	reconnect
	)

Definition at line 1005 of file secure.c.

{
    uint32 selected_proto;
    struct stream mcs_data;
 
    /* Start a MCS connect sequence */
    if (!mcs_connect_start(server, username, domain, password, reconnect, &selected_proto))
        return False;
 
    /* We exchange some RDP data during the MCS-Connect */
    mcs_data.size = 512;
    mcs_data.p = mcs_data.data = (uint8 *) xmalloc(mcs_data.size);
    sec_out_mcs_data(&mcs_data, selected_proto);
 
    /* finalize the MCS connect sequence */
    if (!mcs_connect_finalize(&mcs_data))
        return False;
 
    /* sec_process_mcs_data(&mcs_data); */
    if (g_encryption)
        sec_establish_key();
    xfree(mcs_data.data);
    return True;
}

Referenced by rdp_connect().

sec_decrypt()

void sec_decrypt	(	uint8 *	data,
		int	length
	)

Definition at line 396 of file secure.c.

{
    if (g_sec_decrypt_use_count == 4096)
    {
        sec_update(g_sec_decrypt_key, g_sec_decrypt_update_key);
        rdssl_rc4_set_key(g_rc4_decrypt_key, (char *)g_sec_decrypt_key, g_rc4_key_len);
        g_sec_decrypt_use_count = 0;
    }
 
    rdssl_rc4_crypt(g_rc4_decrypt_key,(char *)data, (char *)data, length);
    g_sec_decrypt_use_count++;
}

Referenced by sec_recv().

sec_disconnect()

void sec_disconnect

(

void

)

Definition at line 1032 of file secure.c.

{
    mcs_disconnect();
}

Referenced by rdp_disconnect().

sec_hash_16()

void sec_hash_16	(	uint8 *	out,
		uint8 *	in,
		uint8 *	salt1,
		uint8 *	salt2
	)

Definition at line 187 of file secure.c.

{
    void * md5;
    
    md5 = rdssl_md5_info_create();
    rdssl_md5_clear(md5);
    rdssl_md5_transform(md5, (char *)in, 16);
    rdssl_md5_transform(md5, (char *)salt1, 32);
    rdssl_md5_transform(md5, (char *)salt2, 32);
    rdssl_md5_complete(md5, (char *)out);
    rdssl_md5_info_delete(md5);
}

Referenced by licence_generate_keys().

sec_hash_48()

void sec_hash_48	(	uint8 *	out,
		uint8 *	in,
		uint8 *	salt1,
		uint8 *	salt2,
		uint8	salt
	)

Definition at line 155 of file secure.c.

{
    uint8 shasig[20];
    uint8 pad[4];
    void * sha;
    void * md5;
    int i;
 
    for (i = 0; i < 3; i++)
    {
        memset(pad, salt + i, i + 1);
        sha = rdssl_sha1_info_create();
        rdssl_sha1_clear(sha);
        rdssl_sha1_transform(sha, (char *)pad, i + 1);
        rdssl_sha1_transform(sha, (char *)in, 48);
        rdssl_sha1_transform(sha, (char *)salt1, 32);
        rdssl_sha1_transform(sha, (char *)salt2, 32);
        rdssl_sha1_complete(sha, (char *)shasig);
        rdssl_sha1_info_delete(sha);
        md5 = rdssl_md5_info_create();
        rdssl_md5_clear(md5);
        rdssl_md5_transform(md5, (char *)in, 48);
        rdssl_md5_transform(md5, (char *)shasig, 20);
        rdssl_md5_complete(md5, (char *)out + i * 16);
        rdssl_md5_info_delete(md5);
    }
}

Referenced by licence_generate_keys().

sec_hash_sha1_16()

void sec_hash_sha1_16	(	uint8 *	out,
		uint8 *	in,
		uint8 *	salt1
	)

Definition at line 204 of file secure.c.

{
    void * sha;
    sha = rdssl_sha1_info_create();
    rdssl_sha1_clear(sha);
    rdssl_sha1_transform(&sha, (char *)in, 16);
    rdssl_sha1_transform(&sha, (char *)salt1, 16);
    rdssl_sha1_complete(&sha, (char *)out);
    rdssl_sha1_info_delete(sha);
}

sec_hash_to_string()

void sec_hash_to_string	(	char *	out,
		int	out_size,
		uint8 *	in,
		int	in_size
	)

Definition at line 217 of file secure.c.

{
    int k;
    memset(out, 0, out_size);
    for (k = 0; k < in_size; k++, out += 2)
    {
        sprintf(out, "%.2x", in[k]);
    }
}

sec_init()

STREAM sec_init	(	uint32	flags,
		int	maxlen
	)

Definition at line 419 of file secure.c.

{
    int hdrlen;
    STREAM s;
 
    if (!g_licence_issued && !g_licence_error_result)
        hdrlen = (flags & SEC_ENCRYPT) ? 12 : 4;
    else
        hdrlen = (flags & SEC_ENCRYPT) ? 12 : 0;
    s = mcs_init(maxlen + hdrlen);
    s_push_layer(s, sec_hdr, hdrlen);
 
    return s;
}

Referenced by channel_init(), channel_send(), licence_info(), licence_present(), licence_send_authresp(), licence_send_new_licence_request(), licence_send_platform_challenge_response(), licence_send_request(), rdp_init_data(), rdp_send_confirm_active(), rdp_send_logon_info(), and sec_establish_key().

sec_process_mcs_data()

void sec_process_mcs_data

(

STREAM

s

)

Definition at line 856 of file secure.c.

{
    uint16 tag, length;
    uint8 *next_tag;
    uint8 len;
 
    in_uint8s(s, 21);   /* header (T.124 ConferenceCreateResponse) */
    in_uint8(s, len);
    if (len & 0x80)
        in_uint8(s, len);
 
    while (s->p < s->end)
    {
        in_uint16_le(s, tag);
        in_uint16_le(s, length);
 
        if (length <= 4)
            return;
 
        next_tag = s->p + length - 4;
 
        switch (tag)
        {
            case SEC_TAG_SRV_INFO:
                sec_process_srv_info(s);
                break;
 
            case SEC_TAG_SRV_CRYPT:
                sec_process_crypt_info(s);
                break;
 
            case SEC_TAG_SRV_CHANNELS:
                /* FIXME: We should parse this information and
                   use it to map RDP5 channels to MCS 
                   channels */
                break;
 
            default:
                unimpl("response tag 0x%x\n", tag);
        }
 
        s->p = next_tag;
    }
}

Referenced by mcs_recv_connect_response().

sec_recv()

STREAM sec_recv

(

uint8 *

rdpver

)

Definition at line 903 of file secure.c.

{
    uint16 sec_flags;
    /* uint16 sec_flags_hi; */
    uint16 channel;
    STREAM s;
 
    while ((s = mcs_recv(&channel, rdpver)) != NULL)
    {
        if (rdpver != NULL)
        {
            if (*rdpver != 3)
            {
                if (*rdpver & 0x80)
                {
                    in_uint8s(s, 8);    /* signature */
                    sec_decrypt(s->p, s->end - s->p);
                }
                return s;
            }
        }
        if (g_encryption || (!g_licence_issued && !g_licence_error_result))
        {
            /* TS_SECURITY_HEADER */
            in_uint16_le(s, sec_flags);
            in_uint8s(s, 2); /* sec_flags_hi */
 
            if (g_encryption)
            {
                if (sec_flags & SEC_ENCRYPT)
                {
                    in_uint8s(s, 8);    /* signature */
                    sec_decrypt(s->p, s->end - s->p);
                }
 
                if (sec_flags & SEC_LICENSE_PKT)
                {
                    licence_process(s);
                    continue;
                }
 
                if (sec_flags & SEC_REDIRECTION_PKT)    /* SEC_REDIRECT_ENCRYPT */
                {
                    uint8 swapbyte;
 
                    in_uint8s(s, 8);    /* signature */
                    sec_decrypt(s->p, s->end - s->p);
 
                    /* Check for a redirect packet, starts with 00 04 */
                    if (s->p[0] == 0 && s->p[1] == 4)
                    {
                        /* for some reason the PDU and the length seem to be swapped.
                           This isn't good, but we're going to do a byte for byte
                           swap.  So the first four values appear as: 00 04 XX YY,
                           where XX YY is the little endian length. We're going to
                           use 04 00 as the PDU type, so after our swap this will look
                           like: XX YY 04 00 */
                        swapbyte = s->p[0];
                        s->p[0] = s->p[2];
                        s->p[2] = swapbyte;
 
                        swapbyte = s->p[1];
                        s->p[1] = s->p[3];
                        s->p[3] = swapbyte;
 
                        swapbyte = s->p[2];
                        s->p[2] = s->p[3];
                        s->p[3] = swapbyte;
                    }
#ifdef WITH_DEBUG
                    /* warning!  this debug statement will show passwords in the clear! */
                    hexdump(s->p, s->end - s->p);
#endif
                }
            }
            else
            {
                if (sec_flags & SEC_LICENSE_PKT)
                {
                    licence_process(s);
                    continue;
                }
                s->p -= 4;
            }
        }
 
        if (channel != MCS_GLOBAL_CHANNEL)
        {
            channel_process(s, channel);
            if (rdpver != NULL)
                *rdpver = 0xff;
            return s;
        }
 
        return s;
    }
 
    return NULL;
}

Referenced by rdp_recv().

sec_reset_state()

void sec_reset_state

(

void

)

Definition at line 1039 of file secure.c.

{
    g_server_rdp_version = 0;
    g_sec_encrypt_use_count = 0;
    g_sec_decrypt_use_count = 0;
    g_licence_issued = 0;
    g_licence_error_result = 0;
    mcs_reset_state();
}

Referenced by rdp_reset_state().

sec_send()

void sec_send	(	STREAM	s,
		uint32	flags
	)

Definition at line 472 of file secure.c.

{
    sec_send_to_channel(s, flags, MCS_GLOBAL_CHANNEL);
}

Referenced by licence_info(), licence_present(), licence_send_authresp(), licence_send_new_licence_request(), licence_send_platform_challenge_response(), licence_send_request(), rdp_send_confirm_active(), rdp_send_data(), rdp_send_logon_info(), and sec_establish_key().

sec_send_to_channel()

void sec_send_to_channel	(	STREAM	s,
		uint32	flags,
		uint16	channel
	)

Definition at line 436 of file secure.c.

{
    int datalen;
 
#ifdef WITH_SCARD
    scard_lock(SCARD_LOCK_SEC);
#endif
 
    s_pop_layer(s, sec_hdr);
    if ((!g_licence_issued && !g_licence_error_result) || (flags & SEC_ENCRYPT))
        out_uint32_le(s, flags);
 
    if (flags & SEC_ENCRYPT)
    {
        flags &= ~SEC_ENCRYPT;
        datalen = s->end - s->p - 8;
 
#ifdef WITH_DEBUG
        DEBUG(("Sending encrypted packet:\n"));
        hexdump(s->p + 8, datalen);
#endif
 
        sec_sign(s->p, 8, g_sec_sign_key, g_rc4_key_len, s->p + 8, datalen);
        sec_encrypt(s->p + 8, datalen);
    }
 
    mcs_send_to_channel(s, channel);
 
#ifdef WITH_SCARD
    scard_unlock(SCARD_LOCK_SEC);
#endif
}

Referenced by channel_send(), and sec_send().

sec_sign()

void sec_sign	(	uint8 *	signature,
		int	siglen,
		uint8 *	session_key,
		int	keylen,
		uint8 *	data,
		int	datalen
	)

Definition at line 314 of file secure.c.

{
    uint8 shasig[20];
    uint8 md5sig[16];
    uint8 lenhdr[4];
    void * sha;
    void * md5;
 
    buf_out_uint32(lenhdr, datalen);
 
    sha = rdssl_sha1_info_create();
    rdssl_sha1_clear(sha);
    rdssl_sha1_transform(sha, (char *)session_key, keylen);
    rdssl_sha1_transform(sha, (char *)pad_54, 40);
    rdssl_sha1_transform(sha, (char *)lenhdr, 4);
    rdssl_sha1_transform(sha, (char *)data, datalen);
    rdssl_sha1_complete(sha, (char *)shasig);
    rdssl_sha1_info_delete(sha);
 
    md5 = rdssl_md5_info_create();
    rdssl_md5_clear(md5);
    rdssl_md5_transform(md5, (char *)session_key, keylen);
    rdssl_md5_transform(md5, (char *)pad_92, 48);
    rdssl_md5_transform(md5, (char *)shasig, 20);
    rdssl_md5_complete(md5, (char *)md5sig);
    rdssl_md5_info_delete(md5); 
 
    memcpy(signature, md5sig, siglen);
}

Referenced by licence_process_authreq(), licence_process_demand(), licence_process_platform_challenge(), and licence_process_request().

serial_enum_devices()

int serial_enum_devices	(	uint32 *	id,
		char *	optarg
	)

Referenced by main().

serial_get_event()

RD_BOOL serial_get_event	(	RD_NTHANDLE	handle,
		uint32 *	result
	)

Referenced by _rdpdr_check_fds().

serial_get_timeout()

RD_BOOL serial_get_timeout	(	RD_NTHANDLE	handle,
		uint32	length,
		uint32 *	timeout,
		uint32 *	itv_timeout
	)

Referenced by rdpdr_process_irp().

str_handle_lines()

RD_BOOL str_handle_lines	(	const char *	input,
		char **	rest,
		str_handle_lines_t	linehandler,
		void *	data
	)

Referenced by lspci_process(), and seamless_process().

str_startswith()

RD_BOOL str_startswith	(	const char *	s,
		const char *	prefix
	)

Definition at line 1235 of file rdesktop.c.

{
    return (strncmp(s, prefix, strlen(prefix)) == 0);
}

Referenced by FsVolumeInfo(), handle_child_line(), ui_clip_set_mode(), and xkeymap_read().

subprocess()

RD_BOOL subprocess	(	char *const	argv[],
		str_handle_lines_t	linehandler,
		void *	data
	)

Referenced by lspci_process_line().

tcp_connect()

RD_BOOL tcp_connect

(

char *

server

)

Definition at line 717 of file tcp.c.

{
    socklen_t option_len;
    uint32 option_value;
    int i;
 
#ifdef IPv6
 
    int n;
    struct addrinfo hints, *res, *ressave;
    char tcp_port_rdp_s[10];
 
    snprintf(tcp_port_rdp_s, 10, "%d", g_tcp_port_rdp);
 
    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
 
    if ((n = getaddrinfo(server, tcp_port_rdp_s, &hints, &res)))
    {
        error("getaddrinfo: %s\n", gai_strerror(n));
        return False;
    }
 
    ressave = res;
    g_sock = -1;
    while (res)
    {
        g_sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if (!(g_sock < 0))
        {
            if (connect(g_sock, res->ai_addr, res->ai_addrlen) == 0)
                break;
            TCP_CLOSE(g_sock);
            g_sock = -1;
        }
        res = res->ai_next;
    }
    freeaddrinfo(ressave);
 
    if (g_sock == -1)
    {
        error("%s: unable to connect\n", server);
        return False;
    }
 
#else /* no IPv6 support */
 
    struct hostent *nslookup;
    struct sockaddr_in servaddr;
 
    if ((nslookup = gethostbyname(server)) != NULL)
    {
        memcpy(&servaddr.sin_addr, nslookup->h_addr, sizeof(servaddr.sin_addr));
    }
    else if ((servaddr.sin_addr.s_addr = inet_addr(server)) == INADDR_NONE)
    {
        error("%s: unable to resolve host\n", server);
        return False;
    }
 
    if ((g_sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        error("socket: %s\n", TCP_STRERROR);
        return False;
    }
 
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons((uint16) g_tcp_port_rdp);
 
    if (connect(g_sock, (struct sockaddr *) &servaddr, sizeof(struct sockaddr)) < 0)
    {
        if (!g_reconnect_loop)
            error("connect: %s\n", TCP_STRERROR);
 
        TCP_CLOSE(g_sock);
        g_sock = -1;
        return False;
    }
 
#endif /* IPv6 */
 
    option_value = 1;
    option_len = sizeof(option_value);
    setsockopt(g_sock, IPPROTO_TCP, TCP_NODELAY, (void *) &option_value, option_len);
    /* receive buffer must be a least 16 K */
    if (getsockopt(g_sock, SOL_SOCKET, SO_RCVBUF, (void *) &option_value, &option_len) == 0)
    {
        if (option_value < (1024 * 16))
        {
            option_value = 1024 * 16;
            option_len = sizeof(option_value);
            setsockopt(g_sock, SOL_SOCKET, SO_RCVBUF, (void *) &option_value,
                   option_len);
        }
    }
 
    g_in.size = 4096;
    g_in.data = (uint8 *) xmalloc(g_in.size);
 
    for (i = 0; i < STREAM_COUNT; i++)
    {
        g_out[i].size = 4096;
        g_out[i].data = (uint8 *) xmalloc(g_out[i].size);
    }
 
#ifdef WITH_SSL
    g_ssl_server = xmalloc(strlen(server)+1);
#endif /* WITH_SSL */
 
    return True;
}

Referenced by iso_connect(), iso_reconnect(), LibTCPConnectCallback(), START_TEST(), and test_tcp_rto_timeout_syn_sent_impl().

tcp_disconnect()

void tcp_disconnect

(

void

)

Definition at line 832 of file tcp.c.

{
#ifdef WITH_SSL
    if (g_ssl)
    {
        xfree(g_ssl->peek_msg_mem);
        g_ssl->peek_msg_mem = NULL;
        g_ssl->peek_msg = NULL;
        g_ssl->peek_len = 0;
        xfree(g_ssl->ssl_buf);
        g_ssl->ssl_buf = NULL;
        xfree(g_ssl->extra_buf);
        g_ssl->extra_buf = NULL;
        g_ssl->extra_len = 0;
        if (SecIsValidHandle(&g_ssl->ssl_ctx))
            DeleteSecurityContext(&g_ssl->ssl_ctx);
        if (cred_handle_initialized)
            FreeCredentialsHandle(&cred_handle);
        if (have_compat_cred_handle)
            FreeCredentialsHandle(&compat_cred_handle);
        if (g_ssl_server)
        {
            xfree(g_ssl_server);
            g_ssl_server = NULL;
        }
        g_ssl = NULL;
        g_ssl_initialized = False;
    }
#endif /* WITH_SSL */
    TCP_CLOSE(g_sock);
    g_sock = -1;
}

Referenced by iso_connect(), iso_disconnect(), and iso_reconnect().

tcp_get_address()

char * tcp_get_address

(

void

)

Definition at line 866 of file tcp.c.

{
    static char ipaddr[32];
    struct sockaddr_in sockaddr;
    socklen_t len = sizeof(sockaddr);
    if (getsockname(g_sock, (struct sockaddr *) &sockaddr, &len) == 0)
    {
        uint8 *ip = (uint8 *) & sockaddr.sin_addr;
        sprintf(ipaddr, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
    }
    else
        strcpy(ipaddr, "127.0.0.1");
    return ipaddr;
}

Referenced by rdp_send_logon_info(), and wWinMain().

tcp_init()

STREAM tcp_init

(

uint32

maxlen

)

Definition at line 82 of file tcp.c.

{
    static int cur_stream_id = 0;
    STREAM result = NULL;
 
#ifdef WITH_SCARD
    scard_lock(SCARD_LOCK_TCP);
#endif
    result = &g_out[cur_stream_id];
    cur_stream_id = (cur_stream_id + 1) % STREAM_COUNT;
 
    if (maxlen > result->size)
    {
        result->data = (uint8 *) xrealloc(result->data, maxlen);
        result->size = maxlen;
    }
 
    result->p = result->data;
    result->end = result->data + result->size;
#ifdef WITH_SCARD
    scard_unlock(SCARD_LOCK_TCP);
#endif
    return result;
}

Referenced by iso_init(), iso_send_connection_request(), iso_send_msg(), and lwip_init().

tcp_is_connected()

RD_BOOL tcp_is_connected

(

void

)

Definition at line 882 of file tcp.c.

{
    struct sockaddr_in sockaddr;
    socklen_t len = sizeof(sockaddr);
    if (getpeername(g_sock, (struct sockaddr *) &sockaddr, &len))
        return True;
    return False;
}

tcp_recv()

STREAM tcp_recv	(	STREAM	s,
		uint32	length
	)

Definition at line 344 of file tcp.c.

{
    uint32 new_length, end_offset, p_offset;
    int rcvd = 0;
 
    if (g_network_error == True)
        return NULL;
 
    if (s == NULL)
    {
        /* read into "new" stream */
        if (length > g_in.size)
        {
            g_in.data = (uint8 *) xrealloc(g_in.data, length);
            g_in.size = length;
        }
        g_in.end = g_in.p = g_in.data;
        s = &g_in;
    }
    else
    {
        /* append to existing stream */
        new_length = (s->end - s->data) + length;
        if (new_length > s->size)
        {
            p_offset = s->p - s->data;
            end_offset = s->end - s->data;
            s->data = (uint8 *) xrealloc(s->data, new_length);
            s->size = new_length;
            s->p = s->data + p_offset;
            s->end = s->data + end_offset;
        }
    }
 
    while (length > 0)
    {
#ifdef WITH_SSL
        if (!g_ssl)
#endif /* WITH_SSL */
        {
            if (!ui_select(g_sock))
            {
                /* User quit */
                g_user_quit = True;
                return NULL;
            }
        }
 
#ifdef WITH_SSL
        if (g_ssl)
        {
            SIZE_T size = 0;
            BOOL eof;
            DWORD res;
 
            if (g_ssl->peek_msg)
            {
                size = min(length, g_ssl->peek_len);
                memcpy(s->end, g_ssl->peek_msg, size);
                g_ssl->peek_len -= size;
                g_ssl->peek_msg += size;
                s->end += size;
 
                if (!g_ssl->peek_len)
                {
                    xfree(g_ssl->peek_msg_mem);
                    g_ssl->peek_msg_mem = g_ssl->peek_msg = NULL;
                }
 
                return s;
            }
 
            do
            {
                res = read_ssl_chunk((BYTE*)s->end, length, TRUE, &size, &eof);
                if (res != ERROR_SUCCESS)
                {
                    if (res == WSAEWOULDBLOCK)
                    {
                        if (size)
                        {
                            res = ERROR_SUCCESS;
                        }
                    }
                    else
                    {
                        error("read_ssl_chunk: %d (%s)\n", res, TCP_STRERROR);
                        g_network_error = True;
                        return NULL;
                    }
                    break;
                }
            }
            while (!size && !eof);
            rcvd = size;
        }
        else
        {
#endif /* WITH_SSL */
            rcvd = recv(g_sock, (char *)s->end, length, 0);
            if (rcvd < 0)
            {
                if (rcvd == -1 && TCP_BLOCKS)
                {
                    rcvd = 0;
                }
                else
                {
                    error("recv: %d (%s)\n", rcvd, TCP_STRERROR);
                    g_network_error = True;
                    return NULL;
                }
            }
            else if (rcvd == 0)
            {
                error("Connection closed\n");
                return NULL;
            }
#ifdef WITH_SSL
        }
#endif /* WITH_SSL */
 
        s->end += rcvd;
        length -= rcvd;
    }
 
    return s;
}

Referenced by iso_recv_msg(), LibTCPAccept(), LibTCPConnectCallback(), START_TEST(), test_tcp_new_counters_pcb(), test_tcp_recv_expect1byte(), and test_tcp_recv_expectclose().

tcp_reset_state()

void tcp_reset_state

(

void

)

Definition at line 894 of file tcp.c.

{
    int i;
 
    /* Clear the incoming stream */
    if (g_in.data != NULL)
        xfree(g_in.data);
    g_in.p = NULL;
    g_in.end = NULL;
    g_in.data = NULL;
    g_in.size = 0;
    g_in.iso_hdr = NULL;
    g_in.mcs_hdr = NULL;
    g_in.sec_hdr = NULL;
    g_in.rdp_hdr = NULL;
    g_in.channel_hdr = NULL;
 
    /* Clear the outgoing stream(s) */
    for (i = 0; i < STREAM_COUNT; i++)
    {
        if (g_out[i].data != NULL)
            xfree(g_out[i].data);
        g_out[i].p = NULL;
        g_out[i].end = NULL;
        g_out[i].data = NULL;
        g_out[i].size = 0;
        g_out[i].iso_hdr = NULL;
        g_out[i].mcs_hdr = NULL;
        g_out[i].sec_hdr = NULL;
        g_out[i].rdp_hdr = NULL;
        g_out[i].channel_hdr = NULL;
    }
}

Referenced by iso_reset_state().

tcp_run_ui()

void tcp_run_ui

(

RD_BOOL

run

)

tcp_send()

void tcp_send

(

STREAM

s

)

Definition at line 270 of file tcp.c.

{
    int length = s->end - s->data;
    int sent, total = 0;
 
    if (g_network_error == True)
        return;
 
#ifdef WITH_SCARD
    scard_lock(SCARD_LOCK_TCP);
#endif
    while (total < length)
    {
#ifdef WITH_SSL
        if (g_ssl)
        {
            const BYTE *ptr = s->data + total;
            size_t chunk_size;
 
            sent = 0;
 
            while (length - total)
            {
                chunk_size = min(length - total, g_ssl->ssl_sizes.cbMaximumMessage);
                if (!send_ssl_chunk(ptr, chunk_size))
                {
#ifdef WITH_SCARD
                    scard_unlock(SCARD_LOCK_TCP);
#endif
 
                    //error("send_ssl_chunk: %d (%s)\n", sent, TCP_STRERROR);
                    g_network_error = True;
                    return;
                }
 
                sent += chunk_size;
                ptr += chunk_size;
                length -= chunk_size;
            }
        }
        else
        {
#endif /* WITH_SSL */
            sent = send(g_sock, (const char *)s->data + total, length - total, 0);
            if (sent <= 0)
            {
                if (sent == -1 && TCP_BLOCKS)
                {
                    TCP_SLEEP(0);
                    sent = 0;
                }
                else
                {
#ifdef WITH_SCARD
                    scard_unlock(SCARD_LOCK_TCP);
#endif
 
                    error("send: %d (%s)\n", sent, TCP_STRERROR);
                    g_network_error = True;
                    return;
                }
            }
#ifdef WITH_SSL
        }
#endif /* WITH_SSL */
        total += sent;
    }
#ifdef WITH_SCARD
    scard_unlock(SCARD_LOCK_TCP);
#endif
}

Referenced by iso_send(), iso_send_connection_request(), and iso_send_msg().

tcp_tls_connect()

RD_BOOL tcp_tls_connect

(

void

)

Referenced by iso_connect().

tcp_tls_get_server_pubkey()

RD_BOOL tcp_tls_get_server_pubkey

(

STREAM

s

)

toupper_str()

void toupper_str

(

char *

p

)

Definition at line 1223 of file rdesktop.c.

{
    while (*p)
    {
        if ((*p >= 'a') && (*p <= 'z'))
            *p = toupper((int) *p);
        p++;
    }
}

Referenced by parallel_enum_devices(), and serial_enum_devices().

ui_begin_update()

void ui_begin_update

(

void

)

Definition at line 657 of file uimain.c.

{
  mi_begin_update();
}

Referenced by process_update_pdu(), and rdp5_process().

ui_bell()

void ui_bell

(

void

)

Definition at line 158 of file uimain.c.

{
}

Referenced by process_data_pdu().

ui_clip_format_announce()

void ui_clip_format_announce	(	uint8 *	data,
		uint32	length
	)

Referenced by cliprdr_process().

ui_clip_handle_data()

void ui_clip_handle_data	(	uint8 *	data,
		uint32	length
	)

Referenced by cliprdr_process().

ui_clip_request_data()

void ui_clip_request_data

(

uint32

format

)

Referenced by cliprdr_process().

ui_clip_request_failed()

void ui_clip_request_failed

(

void

)

Referenced by cliprdr_process().

ui_clip_set_mode()

void ui_clip_set_mode

(

const char *

optarg

)

Referenced by cliprdr_set_mode().

ui_clip_sync()

void ui_clip_sync

(

void

)

Referenced by cliprdr_process().

ui_create_bitmap()

RD_HBITMAP ui_create_bitmap	(	int	width,
		int	height,
		uint8 *	data
	)

Definition at line 277 of file uimain.c.

{
  struct bitmap * b;
  int size;
 
  size = width * height * ((g_server_depth + 7) / 8);
  b = (struct bitmap *) xmalloc(sizeof(struct bitmap));
  b->data = (uint8 *) xmalloc(size);
  memcpy(b->data, data, size);
  b->width = width;
  b->height = height;
  return b;
}

Referenced by process_bmpcache(), process_bmpcache2(), process_raw_bmpcache(), pstcache_load_bitmap(), and ui_paint_bitmap().

ui_create_colourmap()

RD_HCOLOURMAP ui_create_colourmap

(

COLOURMAP *

colours

)

Definition at line 336 of file uimain.c.

{
  int i;
  int n;
 
  n = MIN(256, colours->ncolours);
  memset(pal_entries, 0, sizeof(pal_entries));
  for (i = 0; i < n; i++)
  {
    pal_entries[i] = (colours->colours[i].red << 16) |
                     (colours->colours[i].green << 8) |
                     colours->colours[i].blue;
  }
  return 0;
}

Referenced by process_colcache(), and process_palette().

ui_create_cursor()

RD_HCURSOR ui_create_cursor	(	unsigned int	x,
		unsigned int	y,
		int	width,
		int	height,
		uint8 *	andmask,
		uint8 *	xormask,
		int	bpp
	)

Definition at line 175 of file uimain.c.

{
  int i;
  int j;
  char am[32 * 4];
  char xm[32 * 4];
 
  if (width != 32 || height != 32)
  {
    return NULL;
  }
  if (xor_bpp==1)
  {
    return (void *) mi_create_cursor(x, y, width, height, (unsigned char *)andmask, (unsigned char *)xormask);
  }
  memset(am, 0, 32 * 4);
  memset(xm, 0, 32 * 4);
  for (i = 0; i < 32; i++)
  {
    for (j = 0; j < 32; j++)
    {
      if (bs_is_pixel_on((char *)andmask, j, i, 32, 1))
      {
        bs_set_pixel_on(am, j, 31 - i, 32, 1, 1);
      }
      if (bs_is_pixel_on((char *)xormask, j, i, 32, xor_bpp))
      {
        bs_set_pixel_on(xm, j, 31 - i, 32, 1, 1);
      }
    }
  }
  return (void *) mi_create_cursor(x, y, width, height, (unsigned char *)am, (unsigned char *)xm);
}

Referenced by process_colour_pointer_common(), and process_colour_pointer_pdu().

ui_create_glyph()

RD_HGLYPH ui_create_glyph	(	int	width,
		int	height,
		uint8 *	data
	)

Definition at line 234 of file uimain.c.

{
  int i;
  int j;
  char * glyph_data;
  struct bitmap * the_glyph;
 
  glyph_data = (char *) xmalloc(width * height);
  memset(glyph_data, 0, width * height);
  the_glyph = (struct bitmap *) xmalloc(sizeof(struct bitmap));
  memset(the_glyph, 0, sizeof(struct bitmap));
  the_glyph->width = width;
  the_glyph->height = height;
  the_glyph->data = (uint8 *)glyph_data;
  for (i = 0; i < height; i++)
  {
    for (j = 0; j < width; j++)
    {
      if (bs_is_pixel_on((char *)data, j, i, width, 1))
      {
        bs_set_pixel_on(glyph_data, j, i, width, 8, 255);
      }
    }
  }
  return the_glyph;
}

Referenced by process_fontcache(), ui_create_cursor(), and ui_patblt().

ui_create_window()

RD_BOOL ui_create_window

(

void

)

Definition at line 559 of file qtwin.cpp.

{
  int w, h;
  QPainter * painter;
  QWidget * desktop;
 
  g_MW = new QMyMainWindow();
  g_SV = new QMyScrollView();
  g_SV->addChild(g_MW);
  g_BS = new QPixmap(g_width, g_height);
  painter = new QPainter(g_BS);
  painter->fillRect(0, 0, g_width, g_height, QBrush(QColor("white")));
  painter->fillRect(0, 0, g_width, g_height, QBrush(QBrush::CrossPattern));
  delete painter;
  g_DS = new QPixmap(480, 480);
  g_P1 = new QPainter();
  g_P2 = new QPainter();
  g_ClipRect = new QRegion(0, 0, g_width, g_height);
  desktop = QApplication::desktop();
  w = desktop->width();              // returns screen width
  h = desktop->height();             // returns screen height
  g_MW->resize(g_width, g_height);
  if (w < g_width || h < g_height)
  {
    g_SV->resize(w, h);
  }
  else
  {
    g_SV->resize(g_width + 4, g_height + 4);
  }
  g_SV->setMaximumWidth(g_width + 4);
  g_SV->setMaximumHeight(g_height + 4);
  g_App->setMainWidget(g_SV);
  g_SV->show();
  g_MW->setMouseTracking(true);
  if (g_title[0] != 0)
  {
    g_SV->setCaption(g_title);
  }
 
/*  XGrayKey(0, 64, AnyModifie, SV->winId(), 0, GrabModeAsync, GrabModeAsync);
  XGrayKey(0, 113, AnyModifie, SV->winId(), 0, GrabModeAsync, GrabModeAsync);
  XGrayKey(0, 37, AnyModifie, SV-winId(), 0, GrabModeAsync, GrabModeAsync);
  XGrayKey(0, 109, AnyModifie, SV->winId(), 0, GrabModeAsync, GrabModeAsync);
  XGrayKey(0, 115, AnyModifie, SV->winId(), 0, GrabModeAsync, GrabModeAsync);
  XGrayKey(0, 116, AnyModifie, SV->winId(), 0, GrabModeAsync, GrabModeAsync);
  XGrayKey(0, 117, AnyModifie, SV->winId(), 0, GrabModeAsync, GrabModeAsync);
  XGrayKey(0, 62, AnyModifie, SV->winId(), 0, GrabModeAsync, GrabModeAsync);
  XGrayKey(0, 50, AnyModifie, SV->winId(), 0, GrabModeAsync, GrabModeAsync);*/
 
  return 1;
}

Referenced by main(), rdp2vnc_connect(), and xwin_toggle_fullscreen().

ui_deinit()

void ui_deinit

(

void

)

Definition at line 553 of file qtwin.cpp.

{
  delete g_App;
}

Referenced by main().

ui_desktop_restore()

void ui_desktop_restore	(	uint32	offset,
		int	x,
		int	y,
		int	cx,
		int	cy
	)

Definition at line 561 of file uimain.c.

{
}

Referenced by process_desksave().

ui_desktop_save()

void ui_desktop_save	(	uint32	offset,
		int	x,
		int	y,
		int	cx,
		int	cy
	)

Definition at line 567 of file uimain.c.

{
}

Referenced by process_desksave().

ui_destblt()

void ui_destblt	(	uint8	opcode,
		int	x,
		int	y,
		int	cx,
		int	cy
	)

Definition at line 607 of file uimain.c.

{
  bs_rect(x, y, cx, cy, 0, opcode);
  ui_invalidate(x, y, cx, cy);
  /* todo */
}

Referenced by process_destblt().

ui_destroy_bitmap()

void ui_destroy_bitmap

(

RD_HBITMAP

bmp

)

Referenced by cache_evict_bitmap(), and cache_put_bitmap().

ui_destroy_colourmap()

void ui_destroy_colourmap

(

RD_HCOLOURMAP

map

)

Definition at line 1532 of file qtewin.cpp.

{
}

Referenced by ui_set_colourmap().

ui_destroy_cursor()

void ui_destroy_cursor

(

RD_HCURSOR

cursor

)

Referenced by cache_put_cursor().

ui_destroy_glyph()

void ui_destroy_glyph

(

RD_HGLYPH

glyph

)

Definition at line 1424 of file qtewin.cpp.

{
  struct bitmap* the_glyph;
 
  the_glyph = (struct bitmap*)glyph;
  if (the_glyph != NULL)
  {
    if (the_glyph->data != NULL)
      xfree(the_glyph->data);
    xfree(the_glyph);
  }
}

Referenced by cache_put_font(), and ui_patblt().

ui_destroy_window()

void ui_destroy_window

(

void

)

Definition at line 637 of file qtwin.cpp.

{
  delete g_MW;
  delete g_SV;
  delete g_BS;
  delete g_DS;
  delete g_P1;
  delete g_P2;
  delete g_ClipRect;
}

Referenced by main(), rdp2vnc_connect(), and xwin_toggle_fullscreen().

ui_draw_glyph()

void ui_draw_glyph	(	int	mixmode,
		int	x,
		int	y,
		int	cx,
		int	cy,
		RD_HGLYPH	glyph,
		int	srcx,
		int	srcy,
		int	bgcolour,
		int	fgcolour
	)

Definition at line 782 of file vnc.c.

{
    int xx, yy;
    int ox, oy;
    vncBuffer *buf = vncDupBuffer(glyph);
 
    x &= 0xffff;
    y &= 0xffff;
 
    /* yes, sometimes same fgcolour and bgcolour are sent, but because
     * of transparency, we have to change that! */
    if (mixmode == MIX_TRANSPARENT && fgcolour == bgcolour)
        bgcolour = fgcolour ^ 0xff;
 
    ox = x;
    oy = y;
 
    for (yy = srcy; yy < srcy + cy; yy++)
    {
        for (xx = srcx; xx < srcx + cx; xx++)
        {
            vncSetPixel(buf, xx, yy, vncGetPixel(buf, xx, yy) ? fgcolour : bgcolour);
        }
    }
 
    switch (mixmode)
    {
        case MIX_TRANSPARENT:
            if (vncwinClipRect(&x, &y, &cx, &cy))
            {
                //if we clipped top or left, we have to adjust srcx,srcy;
                srcx += x - ox;
                srcy += y - oy;
                vncTransBlitFrom(server, x, y, cx, cy, buf, srcx, srcy, bgcolour);
            }
            break;
        case MIX_OPAQUE:
            if (vncwinClipRect(&x, &y, &cx, &cy))
            {
                //if we clipped top or left, we have to adjust srcx,srcy;
                srcx += x - ox;
                srcy += y - oy;
                vncCopyBlitFrom(server, x, y, cx, cy, buf, srcx, srcy);
            }
            break;
 
        default:
            unimpl("mix %d\n", mixmode);
    }
    vncDeleteBuffer(buf);
}

ui_draw_text()

void ui_draw_text	(	uint8	font,
		uint8	flags,
		uint8	opcode,
		int	mixmode,
		int	x,
		int	y,
		int	clipx,
		int	clipy,
		int	clipcx,
		int	clipcy,
		int	boxx,
		int	boxy,
		int	boxcx,
		int	boxcy,
		BRUSH *	brush,
		int	bgcolour,
		int	fgcolour,
		uint8 *	text,
		uint8	length
	)

Definition at line 412 of file uimain.c.

{
  int i;
  int j;
  int xyoffset;
  DATABLOB * entry;
  FONTGLYPH * glyph;
 
  if (boxx + boxcx > g_width)
  {
    boxcx = g_width - boxx;
  }
  if (boxcx > 1)
  {
    bs_rect(boxx, boxy, boxcx, boxcy, bgcolour, 0xc);
  }
  else
  {
    if (mixmode == MIX_OPAQUE)
    {
      bs_rect(clipx, clipy, clipcx, clipcy, bgcolour, 0xc);
    }
  }
  /* Paint text, character by character */
  for (i = 0; i < length;)
  {
    switch (text[i])
    {
      case 0xff:
        if (i + 2 < length)
        {
          cache_put_text(text[i + 1], text, text[i + 2]);
        }
        else
        {
          error("this shouldn't be happening\n");
          exit(1);
        }
        /* this will move pointer from start to first character after */
        /* FF command */
        length -= i + 3;
        text = &(text[i + 3]);
        i = 0;
        break;
      case 0xfe:
        entry = cache_get_text(text[i + 1]);
        if (entry != NULL)
        {
          if ((((uint8 *) (entry->data))[1] == 0) &&
                              (!(flags & TEXT2_IMPLICIT_X)))
          {
            if (flags & TEXT2_VERTICAL)
            {
              y += text[i + 2];
            }
            else
            {
              x += text[i + 2];
            }
          }
          for (j = 0; j < entry->size; j++)
          {
            DO_GLYPH(((uint8 *) (entry->data)), j);
          }
        }
        if (i + 2 < length)
        {
          i += 3;
        }
        else
        {
          i += 2;
        }
        length -= i;
        /* this will move pointer from start to first character after */
        /* FE command */
        text = &(text[i]);
        i = 0;
        break;
      default:
        DO_GLYPH(text, i);
        i++;
        break;
    }
  }
  if (boxcx > 1)
  {
    ui_invalidate(boxx, boxy, boxcx, boxcy);
  }
  else
  {
    ui_invalidate(clipx, clipy, clipcx, clipcy);
  }
}

Referenced by process_text2().

ui_ellipse()

void ui_ellipse	(	uint8	opcode,
		uint8	fillmode,
		int	x,
		int	y,
		int	cx,
		int	cy,
		BRUSH *	brush,
		int	bgcolour,
		int	fgcolour
	)

Definition at line 699 of file uimain.c.

{
  /* not used */
}

Referenced by process_ellipse(), and process_ellipse2().

ui_end_update()

void ui_end_update

(

void

)

Definition at line 664 of file uimain.c.

{
  mi_end_update();
}

Referenced by process_update_pdu(), and rdp5_process().

ui_get_numlock_state()

uint16 ui_get_numlock_state

(

unsigned int

state

)

Definition at line 1620 of file svgawin.c.

{
  return 0;
}

Referenced by process_demand_active().

ui_have_window()

RD_BOOL ui_have_window

(

void

)

ui_init()

RD_BOOL ui_init

(

void

)

Definition at line 546 of file qtwin.cpp.

{
  g_App = new QApplication(g_argc, g_argv);
  return 1;
}

Referenced by main().

ui_init_connection()

void ui_init_connection

(

void

)

ui_line()

void ui_line	(	uint8	opcode,
		int	startx,
		int	starty,
		int	endx,
		int	endy,
		PEN *	pen
	)

Definition at line 513 of file uimain.c.

{
  int x;
  int y;
  int cx;
  int cy;
 
  bs_line(opcode, startx, starty, endx, endy, pen->width, pen->style,
          pen->colour);
  if (pen->style == 0 && pen->width < 2 && opcode == 12)
  {
    mi_line(startx, starty, endx, endy, pen->colour);
  }
  else
  {
    x = MIN(startx, endx);
    y = MIN(starty, endy);
    cx = (MAX(startx, endx) + 1) - x;
    cy = (MAX(starty, endy) + 1) - y;
    ui_invalidate(x, y, cx, cy);
  }
}

Referenced by process_line(), and ui_polyline().

ui_memblt()

void ui_memblt	(	uint8	opcode,
		int	x,
		int	y,
		int	cx,
		int	cy,
		RD_HBITMAP	src,
		int	srcx,
		int	srcy
	)

Referenced by process_memblt().

ui_move_pointer()

void ui_move_pointer	(	int	x,
		int	y
	)

Definition at line 616 of file uimain.c.

{
}

Referenced by process_pointer_pdu(), and rdp5_process().

ui_paint_bitmap()

void ui_paint_bitmap	(	int	x,
		int	y,
		int	cx,
		int	cy,
		int	width,
		int	height,
		uint8 *	data
	)

Definition at line 307 of file uimain.c.

{
  struct bitmap b;
 
  b.width = width;
  b.height = height;
  b.data = data;
  ui_memblt(12, x, y, cx, cy, &b, 0, 0);
}

Referenced by process_bitmap_updates(), and ui_desktop_restore().

ui_patblt()

void ui_patblt	(	uint8	opcode,
		int	x,
		int	y,
		int	cx,
		int	cy,
		BRUSH *	brush,
		int	bgcolour,
		int	fgcolour
	)

Definition at line 597 of file uimain.c.

{
  bs_patblt(opcode, x, y, cx, cy, brush->style, (char *)brush->pattern,
            brush->xorigin, brush->yorigin, bgcolour, fgcolour);
  ui_invalidate(x, y, cx, cy);
}

Referenced by process_patblt(), and ui_triblt().

ui_polygon()

void ui_polygon	(	uint8	opcode,
		uint8	fillmode,
		RD_POINT *	point,
		int	npoints,
		BRUSH *	brush,
		int	bgcolour,
		int	fgcolour
	)

Definition at line 671 of file uimain.c.

{
  /* not used */
}

Referenced by process_polygon(), and process_polygon2().

ui_polyline()

void ui_polyline	(	uint8	opcode,
		RD_POINT *	points,
		int	npoints,
		PEN *	pen
	)

Definition at line 679 of file uimain.c.

{
  int i, x, y, dx, dy;
  if (npoints > 0)
  {
    x = points[0].x;
    y = points[0].y;
    for (i = 1; i < npoints; i++)
    {
      dx = points[i].x;
      dy = points[i].y;
      ui_line(opcode, x, y, x + dx, y + dy, pen);
      x = x + dx;
      y = y + dy;
    }
  }
}

Referenced by process_polyline().

ui_rect()

void ui_rect	(	int	x,
		int	y,
		int	cx,
		int	cy,
		int	colour
	)

Definition at line 573 of file uimain.c.

{
  bs_rect(x, y, cx, cy, colour, 12);
  mi_fill_rect(x, y, cx, cy, colour);
}

Referenced by process_rect(), ui_destblt(), and ui_draw_text().

ui_reset_clip()

void ui_reset_clip

(

void

)

Definition at line 328 of file uimain.c.

{
  bs_reset_clip();
  mi_reset_clip();
}

Referenced by process_orders(), and ui_create_window().

ui_resize_window()

void ui_resize_window

(

void

)

Definition at line 651 of file uimain.c.

{
}

Referenced by rdp_process_bitmap_caps().

ui_screenblt()

void ui_screenblt	(	uint8	opcode,
		int	x,
		int	y,
		int	cx,
		int	cy,
		int	srcx,
		int	srcy
	)

Definition at line 581 of file uimain.c.

{
  bs_screenblt(opcode, x, y, cx, cy, srcx, srcy);
  if (opcode == 12)
  {
    mi_screen_copy(x, y, cx, cy, srcx, srcy);
  }
  else
  {
    ui_invalidate(x, y, cx, cy);
  }
}

Referenced by process_screenblt().

ui_seamless_ack()

void ui_seamless_ack

(

unsigned int

serial

)

Referenced by seamless_process_line().

ui_seamless_begin()

void ui_seamless_begin

(

RD_BOOL

hidden

)

Referenced by seamless_process_line().

ui_seamless_create_window()

void ui_seamless_create_window	(	unsigned long	id,
		unsigned long	group,
		unsigned long	parent,
		unsigned long	flags
	)

Referenced by seamless_process_line().

ui_seamless_delicon()

void ui_seamless_delicon	(	unsigned long	id,
		const char *	format,
		int	width,
		int	height
	)

ui_seamless_destroy_group()

void ui_seamless_destroy_group	(	unsigned long	id,
		unsigned long	flags
	)

Referenced by seamless_process_line().

ui_seamless_destroy_window()

void ui_seamless_destroy_window	(	unsigned long	id,
		unsigned long	flags
	)

Referenced by seamless_process_line().

ui_seamless_end()

void ui_seamless_end

(

)

ui_seamless_hide_desktop()

void ui_seamless_hide_desktop

(

void

)

Referenced by seamless_process_line().

ui_seamless_move_window()

void ui_seamless_move_window	(	unsigned long	id,
		int	x,
		int	y,
		int	width,
		int	height,
		unsigned long	flags
	)

Referenced by seamless_process_line().

ui_seamless_restack_window()

void ui_seamless_restack_window	(	unsigned long	id,
		unsigned long	behind,
		unsigned long	flags
	)

Referenced by seamless_process_line().

ui_seamless_seticon()

void ui_seamless_seticon	(	unsigned long	id,
		const char *	format,
		int	width,
		int	height,
		int	chunk,
		const char *	data,
		int	chunk_len
	)

ui_seamless_setstate()

void ui_seamless_setstate	(	unsigned long	id,
		unsigned int	state,
		unsigned long	flags
	)

Referenced by seamless_process_line().

ui_seamless_settitle()

void ui_seamless_settitle	(	unsigned long	id,
		const char *	title,
		unsigned long	flags
	)

Referenced by seamless_process_line().

ui_seamless_syncbegin()

void ui_seamless_syncbegin

(

unsigned long

flags

)

Referenced by seamless_process_line().

ui_seamless_toggle()

void ui_seamless_toggle

(

void

)

Referenced by handle_special_keys(), ui_seamless_begin(), ui_seamless_hide_desktop(), ui_seamless_unhide_desktop(), and xwin_toggle_fullscreen().

ui_seamless_unhide_desktop()

void ui_seamless_unhide_desktop

(

void

)

Referenced by seamless_process_line().

ui_select()

int ui_select

(

int

rdp_socket

)

Definition at line 164 of file uimain.c.

{
  if (g_tcp_sck == 0)
  {
    g_tcp_sck = in;
  }
  return 1;
}

Referenced by tcp_recv().

ui_set_clip()

void ui_set_clip	(	int	x,
		int	y,
		int	cx,
		int	cy
	)

Definition at line 320 of file uimain.c.

{
  bs_set_clip(x, y, cx, cy);
  mi_set_clip(x, y, cx, cy);
}

Referenced by process_orders(), and ui_create_window().

ui_set_colourmap()

void ui_set_colourmap

(

RD_HCOLOURMAP

map

)

Definition at line 1527 of file qtewin.cpp.

{
}

Referenced by process_colcache(), and process_palette().

ui_set_cursor()

void ui_set_cursor

(

RD_HCURSOR

cursor

)

Referenced by process_cached_pointer_pdu(), process_colour_pointer_common(), and process_colour_pointer_pdu().

ui_set_null_cursor()

void ui_set_null_cursor

(

void

)

Definition at line 227 of file uimain.c.

{
  mi_set_null_cursor();
}

Referenced by process_system_pointer_pdu(), and rdp5_process().

ui_triblt()

void ui_triblt	(	uint8	opcode,
		int	x,
		int	y,
		int	cx,
		int	cy,
		RD_HBITMAP	src,
		int	srcx,
		int	srcy,
		BRUSH *	brush,
		int	bgcolour,
		int	fgcolour
	)

Referenced by process_triblt().

unimpl()

void unimpl	(	char *	format,
			...
	)

Definition at line 801 of file uimain.c.

{
  va_list ap;
  char text[512];
  char text1[512];
 
  sprintf(text1, "UNIMPL: ");
  va_start(ap, format);
  vsprintf(text, format, ap);
  va_end(ap);
  strcat(text1, text);
  mi_warning(text1);
}

Referenced by bitmap_decompress(), bitmap_decompress1(), bitmap_decompress2(), bitmap_decompress3(), cliprdr_process(), disk_device_control(), disk_query_directory(), disk_query_information(), disk_query_volume_information(), disk_set_information(), licence_process(), parallel_device_control(), printercache_process(), process_data_pdu(), process_orders(), process_pointer_pdu(), process_secondary_order(), process_system_pointer_pdu(), process_update_pdu(), rdp5_process(), rdp_loop(), rdpdr_process(), rdpdr_process_irp(), rdpsnd_process(), seamless_process_line(), sec_parse_crypt_info(), sec_process_mcs_data(), serial_device_control(), ui_destblt(), ui_draw_glyph(), ui_ellipse(), ui_memblt(), ui_patblt(), ui_polygon(), and ui_triblt().

warning()

void warning	(	char *	format,
			...
	)

Definition at line 785 of file uimain.c.

{
  va_list ap;
  char text[512];
  char text1[512];
 
  sprintf(text1, "WARNING: ");
  va_start(ap, format);
  vsprintf(text, format, ap);
  va_end(ap);
  strcat(text1, text);
  mi_warning(text1);
}

xclip_deinit()

void xclip_deinit

(

void

)

Referenced by ui_deinit().

xclip_init()

void xclip_init

(

void

)

Referenced by ui_init().

xfree()

void xfree

(

void *

mem

)

Definition at line 758 of file uimain.c.

{
  if (in != 0)
  {
    free(in);
  }
}

Referenced by _rdpdr_check_fds(), cache_put_brush_data(), cache_put_text(), cliprdr_send_native_format_announce(), free_key_translation(), licence_process_request(), lspci_process(), NotifyInfo(), QMyMainWindow::paintEvent(), printercache_load_blob(), printercache_mkdir(), printercache_rename_blob(), printercache_save_blob(), printercache_unlink_blob(), process_bitmap_updates(), process_bmpcache(), process_bmpcache2(), process_colcache(), process_palette(), process_polygon(), process_polygon2(), process_polyline(), process_raw_bmpcache(), pstcache_load_bitmap(), rdpdr_process_irp(), rdpdr_remove_iorequest(), rdpdr_send_available(), rdssl_sign_ok(), seamless_process(), seamless_process_line(), sec_connect(), sw_remove_window(), tcp_disconnect(), tcp_recv(), tcp_reset_state(), ui_clip_format_announce(), ui_create_bitmap(), ui_create_colourmap(), ui_create_cursor(), ui_destroy_colourmap(), ui_paint_bitmap(), ui_set_colourmap(), vncDeleteBuffer(), xclip_handle_PropertyNotify(), xclip_send_data_with_convert(), xkeymap_from_locale(), and xkeymap_open().

xkeymap_from_locale()

RD_BOOL xkeymap_from_locale

(

const char *

locale

)

Referenced by main().

xkeymap_init()

void xkeymap_init

(

void

)

Referenced by init_keyboard(), and ui_init().

xkeymap_open()

FILE * xkeymap_open

(

const char *

filename

)

Definition at line 222 of file xkeymap.c.

{
    char *path1, *path2;
    char *home;
    FILE *fp;
 
    /* Try ~/.rdesktop/keymaps */
    home = getenv("HOME");
    if (home)
    {
        path1 = pathjoin(home, ".rdesktop/keymaps");
        path2 = pathjoin(path1, filename);
        xfree(path1);
        fp = fopen(path2, "r");
        xfree(path2);
        if (fp)
            return fp;
    }
 
    /* Try KEYMAP_PATH */
    path1 = pathjoin(KEYMAP_PATH, filename);
    fp = fopen(path1, "r");
    xfree(path1);
    if (fp)
        return fp;
 
    /* Try current directory, in case we are running from the source
       tree */
    path1 = pathjoin("keymaps", filename);
    fp = fopen(path1, "r");
    xfree(path1);
    if (fp)
        return fp;
 
    return NULL;
}

Referenced by xkeymap_from_locale(), and xkeymap_read().

xkeymap_send_keys()

void xkeymap_send_keys	(	uint32	keysym,
		unsigned int	keycode,
		unsigned int	state,
		uint32	ev_time,
		RD_BOOL	pressed,
		uint8	nesting
	)

Referenced by xwin_process_events().

xkeymap_translate_button()

uint16 xkeymap_translate_button

(

unsigned int

button

)

Definition at line 714 of file xkeymap.c.

{
    switch (button)
    {
        case Button1:   /* left */
            return MOUSE_FLAG_BUTTON1;
        case Button2:   /* middle */
            return MOUSE_FLAG_BUTTON3;
        case Button3:   /* right */
            return MOUSE_FLAG_BUTTON2;
        case Button4:   /* wheel up */
            return MOUSE_FLAG_BUTTON4;
        case Button5:   /* wheel down */
            return MOUSE_FLAG_BUTTON5;
    }
 
    return 0;
}

Referenced by handle_button_event().

xkeymap_translate_key()

key_translation xkeymap_translate_key	(	uint32	keysym,
		unsigned int	keycode,
		unsigned int	state
	)

Referenced by vncKey().

xmalloc()

void * xmalloc

(

int

size

)

Definition at line 747 of file uimain.c.

{
  if (size < 1)
  {
    size = 1;
  }
  return malloc(size);
}

Referenced by accel_fill_rect(), accel_screen_copy(), add_async_iorequest(), add_block(), add_block_index(), add_filename_node(), add_func_desc(), add_importlib(), add_sequence(), add_structure_typeinfo(), add_to_keymap(), add_typeinfo_block(), add_var_desc(), AskTagProc(), cache_put_text(), cache_rect(), check_for_additional_prototype_types(), cliprdr_send_native_format_announce(), create_library_block(), create_msft_typeinfo(), create_msft_typelib(), ctl2_alloc_segment(), disk_enum_devices(), format_namespace(), get_file_version(), get_subtests(), init_sltg_data(), lf2crlf(), load_licence(), local_href(), lspci_process(), main(), make_expr(), make_expr1(), make_expr2(), make_expr3(), make_exprd(), make_exprl(), make_exprs(), make_exprt(), new_index_name(), NotifyInfo(), of_reverse(), output_typelib_regscript(), QMyMainWindow::paintEvent(), parallel_enum_devices(), param_connect(), pathjoin(), printer_enum_devices(), printercache_load_blob(), printercache_mkdir(), printercache_rename_blob(), printercache_save_blob(), printercache_unlink_blob(), process_bitmap_updates(), process_bmpcache(), process_bmpcache2(), process_brushcache(), process_colcache(), process_palette(), process_polygon(), process_polygon2(), process_polyline(), process_raw_bmpcache(), process_redirect_pdu(), pstcache_load_bitmap(), rdp_in_unistr(), rdpdr_process_irp(), rdssl_sign_ok(), read_importlib(), read_msft_importlib(), run_tests(), save_licence(), seamless_process(), sec_connect(), serial_enum_devices(), sltg_add_typeinfo(), str_handle_lines(), sw_find_group(), tcp_connect(), QMyScrollView::timerEvent(), translate_image(), type_dispinterface_define(), type_dispinterface_define_from_iface(), type_interface_define(), type_module_define(), type_new_encapsulated_union(), type_new_enum(), type_new_function(), type_new_nonencapsulated_union(), type_new_struct(), ui_clip_format_announce(), ui_create_bitmap(), ui_create_colourmap(), ui_create_cursor(), ui_create_glyph(), ui_create_window(), ui_desktop_save(), ui_init(), ui_invalidate(), ui_memblt(), ui_patblt(), ui_screenblt(), ui_seamless_create_window(), vncNewBuffer(), vncNewColourMap(), vncNewCursor(), write_conf_or_var_desc(), write_var_desc(), xclip_send_data_with_convert(), and xstrdup().

xrealloc()

void * xrealloc	(	void *	oldmem,
		size_t	size
	)

Definition at line 736 of file uimain.c.

{
  if (size < 1)
  {
    size = 1;
  }
  return realloc(in, size);
}

Referenced by _rdpdr_check_fds(), add_func_desc(), add_index(), add_name(), add_var_desc(), append_data(), build_iface_list(), channel_process(), ctl2_alloc_segment(), extract_rev_infos(), extract_test(), get_subtests(), local_href(), process_data_pdu(), rdp5_process(), rdpdr_process_irp(), tcp_init(), tcp_recv(), and xclip_handle_PropertyNotify().

xstrdup()

char * xstrdup

(

const char *

s

)

Definition at line 768 of file uimain.c.

{
  int len;
  char * p;
 
  if (s == 0)
  {
    return 0;
  }
  len = strlen(s);
  p = (char *) xmalloc(len + 1);
  strcpy(p, s);
  return p;
}

Referenced by add_importlib(), check_for_additional_prototype_types(), duptype(), extract_test(), main(), make_token(), seamless_process_line(), set_target(), type_new_alias(), type_new_array(), type_new_encapsulated_union(), type_new_function(), wave_out_open(), write_conf_or_var_desc(), and xkeymap_from_locale().

xwin_toggle_fullscreen()

void xwin_toggle_fullscreen

(

void

)

Definition at line 124 of file vnc.c.

{
}

Referenced by handle_special_keys().