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;
}