trunk/rdesktop/types.h

/*
   rdesktop: A Remote Desktop Protocol client.
   Common data types
   Copyright (C) Matthew Chapman 1999-2005
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

typedef int BOOL;

#ifndef True
#define True  (1)
#define False (0)
#endif

typedef unsigned char uint8;
typedef signed char sint8;
typedef unsigned short uint16;
typedef signed short sint16;
typedef unsigned int uint32;
typedef signed int sint32;

typedef void *HBITMAP;
typedef void *HGLYPH;
typedef void *HCOLOURMAP;
typedef void *HCURSOR;

typedef struct _COLOURENTRY
{
        uint8 red;
        uint8 green;
        uint8 blue;

}
COLOURENTRY;

typedef struct _COLOURMAP
{
        uint16 ncolours;
        COLOURENTRY *colours;

}
COLOURMAP;

typedef struct _BOUNDS
{
        sint16 left;
        sint16 top;
        sint16 right;
        sint16 bottom;

}
BOUNDS;

typedef struct _PEN
{
        uint8 style;
        uint8 width;
        uint32 colour;

}
PEN;

typedef struct _BRUSH
{
        uint8 xorigin;
        uint8 yorigin;
        uint8 style;
        uint8 pattern[8];

}
BRUSH;

typedef struct _FONTGLYPH
{
        sint16 offset;
        sint16 baseline;
        uint16 width;
        uint16 height;
        HBITMAP pixmap;

}
FONTGLYPH;

typedef struct _DATABLOB
{
        void *data;
        int size;

}
DATABLOB;

typedef struct _key_translation
{
        uint8 scancode;
        uint16 modifiers;
}
key_translation;

typedef struct _VCHANNEL
{
        uint16 mcs_id;
        char name[8];
        uint32 flags;
        struct stream in;
        void (*process) (STREAM);
}
VCHANNEL;

typedef struct _BMPCACHEENTRY
{
        HBITMAP bitmap;
        uint32 usage;

}
BMPCACHEENTRY;

/* PSTCACHE */

typedef uint8 BITMAP_ID[8];

/* Header for an entry in the persistent bitmap cache file */
typedef struct _PSTCACHE_CELLHEADER
{
        BITMAP_ID bitmap_id;
        uint8 width, height;
        uint16 length;
        uint32 stamp;
}
CELLHEADER;

#define MAX_CBSIZE 256

/* RDPSND */
typedef struct
{
        uint16 wFormatTag;
        uint16 nChannels;
        uint32 nSamplesPerSec;
        uint32 nAvgBytesPerSec;
        uint16 nBlockAlign;
        uint16 wBitsPerSample;
        uint16 cbSize;
        uint8 cb[MAX_CBSIZE];
} WAVEFORMATEX;

typedef struct _RDPCOMP
{
        uint32 roff;
        uint8 hist[RDP_MPPC_DICT_SIZE];
        struct stream ns;
}
RDPCOMP;

/* RDPDR */
typedef uint32 NTSTATUS;
typedef uint32 NTHANDLE;

typedef struct _DEVICE_FNS
{
        NTSTATUS(*create) (uint32 device, uint32 desired_access, uint32 share_mode,
                           uint32 create_disposition, uint32 flags_and_attributes, char *filename,
                           NTHANDLE * handle);
        NTSTATUS(*close) (NTHANDLE handle);
        NTSTATUS(*read) (NTHANDLE handle, uint8 * data, uint32 length, uint32 offset,
                         uint32 * result);
        NTSTATUS(*write) (NTHANDLE handle, uint8 * data, uint32 length, uint32 offset,
                          uint32 * result);
        NTSTATUS(*device_control) (NTHANDLE handle, uint32 request, STREAM in, STREAM out);
}
DEVICE_FNS;


typedef struct rdpdr_device_info
{
        uint32 device_type;
        NTHANDLE handle;
        char name[8];
        char *local_path;
        void *pdevice_data;
}
RDPDR_DEVICE;

typedef struct rdpdr_serial_device_info
{
        int dtr;
        int rts;
        uint32 control, xonoff, onlimit, offlimit;
        uint32 baud_rate,
                queue_in_size,
                queue_out_size,
                wait_mask,
                read_interval_timeout,
                read_total_timeout_multiplier,
                read_total_timeout_constant,
                write_total_timeout_multiplier, write_total_timeout_constant, posix_wait_mask;
        uint8 stop_bits, parity, word_length;
        uint8 chars[6];
        struct termios *ptermios, *pold_termios;
        int event_txempty, event_cts, event_dsr, event_rlsd, event_pending;
}
SERIAL_DEVICE;

typedef struct rdpdr_parallel_device_info
{
        char *driver, *printer;
        uint32 queue_in_size,
                queue_out_size,
                wait_mask,
                read_interval_timeout,
                read_total_timeout_multiplier,
                read_total_timeout_constant,
                write_total_timeout_multiplier,
                write_total_timeout_constant, posix_wait_mask, bloblen;
        uint8 *blob;
}
PARALLEL_DEVICE;

typedef struct rdpdr_printer_info
{
        FILE *printer_fp;
        char *driver, *printer;
        uint32 bloblen;
        uint8 *blob;
        BOOL default_printer;
}
PRINTER;

typedef struct notify_data
{
        time_t modify_time;
        time_t status_time;
        time_t total_time;
        unsigned int num_entries;
}
NOTIFY;

typedef struct fileinfo
{
        uint32 device_id, flags_and_attributes, accessmask;
        char path[256];
        DIR *pdir;
        struct dirent *pdirent;
        char pattern[64];
        BOOL delete_on_close;
        NOTIFY notify;
        uint32 info_class;
}
FILEINFO;
1	/*
2	rdesktop: A Remote Desktop Protocol client.
3	Common data types
4	Copyright (C) Matthew Chapman 1999-2005
5
6	This program is free software; you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation; either version 2 of the License, or
9	(at your option) any later version.
10
11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with this program; if not, write to the Free Software
18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19	*/
20
21	typedef int BOOL;
22
23	#ifndef True
24	#define True (1)
25	#define False (0)
26	#endif
27
28	typedef unsigned char uint8;
29	typedef signed char sint8;
30	typedef unsigned short uint16;
31	typedef signed short sint16;
32	typedef unsigned int uint32;
33	typedef signed int sint32;
34
35	typedef void *HBITMAP;
36	typedef void *HGLYPH;
37	typedef void *HCOLOURMAP;
38	typedef void *HCURSOR;
39
40	typedef struct _COLOURENTRY
41	{
42	uint8 red;
43	uint8 green;
44	uint8 blue;
45
46	}
47	COLOURENTRY;
48
49	typedef struct _COLOURMAP
50	{
51	uint16 ncolours;
52	COLOURENTRY *colours;
53
54	}
55	COLOURMAP;
56
57	typedef struct _BOUNDS
58	{
59	sint16 left;
60	sint16 top;
61	sint16 right;
62	sint16 bottom;
63
64	}
65	BOUNDS;
66
67	typedef struct _PEN
68	{
69	uint8 style;
70	uint8 width;
71	uint32 colour;
72
73	}
74	PEN;
75
76	typedef struct _BRUSH
77	{
78	uint8 xorigin;
79	uint8 yorigin;
80	uint8 style;
81	uint8 pattern[8];
82
83	}
84	BRUSH;
85
86	typedef struct _FONTGLYPH
87	{
88	sint16 offset;
89	sint16 baseline;
90	uint16 width;
91	uint16 height;
92	HBITMAP pixmap;
93
94	}
95	FONTGLYPH;
96
97	typedef struct _DATABLOB
98	{
99	void *data;
100	int size;
101
102	}
103	DATABLOB;
104
105	typedef struct _key_translation
106	{
107	uint8 scancode;
108	uint16 modifiers;
109	}
110	key_translation;
111
112	typedef struct _VCHANNEL
113	{
114	uint16 mcs_id;
115	char name[8];
116	uint32 flags;
117	struct stream in;
118	void (*process) (STREAM);
119	}
120	VCHANNEL;
121
122	typedef struct _BMPCACHEENTRY
123	{
124	HBITMAP bitmap;
125	uint32 usage;
126
127	}
128	BMPCACHEENTRY;
129
130	/* PSTCACHE */
131
132	typedef uint8 BITMAP_ID[8];
133
134	/* Header for an entry in the persistent bitmap cache file */
135	typedef struct _PSTCACHE_CELLHEADER
136	{
137	BITMAP_ID bitmap_id;
138	uint8 width, height;
139	uint16 length;
140	uint32 stamp;
141	}
142	CELLHEADER;
143
144	#define MAX_CBSIZE 256
145
146	/* RDPSND */
147	typedef struct
148	{
149	uint16 wFormatTag;
150	uint16 nChannels;
151	uint32 nSamplesPerSec;
152	uint32 nAvgBytesPerSec;
153	uint16 nBlockAlign;
154	uint16 wBitsPerSample;
155	uint16 cbSize;
156	uint8 cb[MAX_CBSIZE];
157	} WAVEFORMATEX;
158
159	typedef struct _RDPCOMP
160	{
161	uint32 roff;
162	uint8 hist[RDP_MPPC_DICT_SIZE];
163	struct stream ns;
164	}
165	RDPCOMP;
166
167	/* RDPDR */
168	typedef uint32 NTSTATUS;
169	typedef uint32 NTHANDLE;
170
171	typedef struct _DEVICE_FNS
172	{
173	NTSTATUS(*create) (uint32 device, uint32 desired_access, uint32 share_mode,
174	uint32 create_disposition, uint32 flags_and_attributes, char *filename,
175	NTHANDLE * handle);
176	NTSTATUS(*close) (NTHANDLE handle);
177	NTSTATUS(read) (NTHANDLE handle, uint8 data, uint32 length, uint32 offset,
178	uint32 * result);
179	NTSTATUS(write) (NTHANDLE handle, uint8 data, uint32 length, uint32 offset,
180	uint32 * result);
181	NTSTATUS(*device_control) (NTHANDLE handle, uint32 request, STREAM in, STREAM out);
182	}
183	DEVICE_FNS;
184
185
186	typedef struct rdpdr_device_info
187	{
188	uint32 device_type;
189	NTHANDLE handle;
190	char name[8];
191	char *local_path;
192	void *pdevice_data;
193	}
194	RDPDR_DEVICE;
195
196	typedef struct rdpdr_serial_device_info
197	{
198	int dtr;
199	int rts;
200	uint32 control, xonoff, onlimit, offlimit;
201	uint32 baud_rate,
202	queue_in_size,
203	queue_out_size,
204	wait_mask,
205	read_interval_timeout,
206	read_total_timeout_multiplier,
207	read_total_timeout_constant,
208	write_total_timeout_multiplier, write_total_timeout_constant, posix_wait_mask;
209	uint8 stop_bits, parity, word_length;
210	uint8 chars[6];
211	struct termios ptermios, pold_termios;
212	int event_txempty, event_cts, event_dsr, event_rlsd, event_pending;
213	}
214	SERIAL_DEVICE;
215
216	typedef struct rdpdr_parallel_device_info
217	{
218	char driver, printer;
219	uint32 queue_in_size,
220	queue_out_size,
221	wait_mask,
222	read_interval_timeout,
223	read_total_timeout_multiplier,
224	read_total_timeout_constant,
225	write_total_timeout_multiplier,
226	write_total_timeout_constant, posix_wait_mask, bloblen;
227	uint8 *blob;
228	}
229	PARALLEL_DEVICE;
230
231	typedef struct rdpdr_printer_info
232	{
233	FILE *printer_fp;
234	char driver, printer;
235	uint32 bloblen;
236	uint8 *blob;
237	BOOL default_printer;
238	}
239	PRINTER;
240
241	typedef struct notify_data
242	{
243	time_t modify_time;
244	time_t status_time;
245	time_t total_time;
246	unsigned int num_entries;
247	}
248	NOTIFY;
249
250	typedef struct fileinfo
251	{
252	uint32 device_id, flags_and_attributes, accessmask;
253	char path[256];
254	DIR *pdir;
255	struct dirent *pdirent;
256	char pattern[64];
257	BOOL delete_on_close;
258	NOTIFY notify;
259	uint32 info_class;
260	}
261	FILEINFO;