summaryrefslogtreecommitdiff
path: root/noncore
Side-by-side diff
Diffstat (limited to 'noncore') (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/net/opierdesktop/.cvsignore4
-rw-r--r--noncore/net/opierdesktop/bitmap.cpp282
-rw-r--r--noncore/net/opierdesktop/cache.cpp235
-rw-r--r--noncore/net/opierdesktop/constants.h259
-rw-r--r--noncore/net/opierdesktop/iso.cpp170
-rw-r--r--noncore/net/opierdesktop/licence.cpp314
-rw-r--r--noncore/net/opierdesktop/mcs.cpp394
-rw-r--r--noncore/net/opierdesktop/opie-rdesktop.control9
-rw-r--r--noncore/net/opierdesktop/opierdesktop.pro26
-rw-r--r--noncore/net/opierdesktop/orders.cpp940
-rw-r--r--noncore/net/opierdesktop/orders.h286
-rw-r--r--noncore/net/opierdesktop/parse.h108
-rw-r--r--noncore/net/opierdesktop/proto.h121
-rw-r--r--noncore/net/opierdesktop/qtwin.cpp1725
-rw-r--r--noncore/net/opierdesktop/qtwin.h105
-rw-r--r--noncore/net/opierdesktop/rdesktop.cpp313
-rw-r--r--noncore/net/opierdesktop/rdesktop.h66
-rw-r--r--noncore/net/opierdesktop/rdp.cpp748
-rw-r--r--noncore/net/opierdesktop/secure.cpp658
-rw-r--r--noncore/net/opierdesktop/tcp.cpp181
-rw-r--r--noncore/net/opierdesktop/types.h110
21 files changed, 7054 insertions, 0 deletions
diff --git a/noncore/net/opierdesktop/.cvsignore b/noncore/net/opierdesktop/.cvsignore
new file mode 100644
index 0000000..df6ec24
--- a/dev/null
+++ b/noncore/net/opierdesktop/.cvsignore
@@ -0,0 +1,4 @@
+*.o
+*~
+Makefile*
+moc_*
diff --git a/noncore/net/opierdesktop/bitmap.cpp b/noncore/net/opierdesktop/bitmap.cpp
new file mode 100644
index 0000000..378623f
--- a/dev/null
+++ b/noncore/net/opierdesktop/bitmap.cpp
@@ -0,0 +1,282 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Bitmap decompression routines
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include "rdesktop.h"
+
+#define CVAL(p) (*(p++))
+
+static uint32
+cvalx(unsigned char **input, int Bpp)
+{
+ uint32 rv = 0;
+ memcpy(&rv, *input, Bpp);
+ *input += Bpp;
+ return rv;
+}
+
+static void
+setli(unsigned char *input, int offset, uint32 value, int Bpp)
+{
+ input += offset * Bpp;
+ memcpy(input, &value, Bpp);
+}
+
+static uint32
+getli(unsigned char *input, int offset, int Bpp)
+{
+ uint32 rv = 0;
+ input += offset * Bpp;
+ memcpy(&rv, input, Bpp);
+ return rv;
+}
+
+#define UNROLL8(exp) { exp exp exp exp exp exp exp exp }
+
+#define REPEAT(statement) \
+{ \
+ while((count & ~0x7) && ((x+8) < width)) \
+ UNROLL8( statement; count--; x++; ); \
+ \
+ while((count > 0) && (x < width)) { statement; count--; x++; } \
+}
+
+#define MASK_UPDATE() \
+{ \
+ mixmask <<= 1; \
+ if (mixmask == 0) \
+ { \
+ mask = fom_mask ? fom_mask : CVAL(input); \
+ mixmask = 1; \
+ } \
+}
+
+BOOL
+bitmap_decompress(unsigned char *output, int width, int height, unsigned char *input, int size,
+ int Bpp)
+{
+ unsigned char *end = input + size;
+ unsigned char *prevline = NULL, *line = NULL;
+ int opcode, count, offset, isfillormix, x = width;
+ int lastopcode = -1, insertmix = False, bicolour = False;
+ uint8 code;
+ uint32 colour1 = 0, colour2 = 0;
+ uint8 mixmask, mask = 0;
+ uint32 mix = 0xffffffff;
+ int fom_mask = 0;
+
+ while (input < end)
+ {
+ fom_mask = 0;
+ code = CVAL(input);
+ opcode = code >> 4;
+
+ /* Handle different opcode forms */
+ switch (opcode)
+ {
+ case 0xc:
+ case 0xd:
+ case 0xe:
+ opcode -= 6;
+ count = code & 0xf;
+ offset = 16;
+ break;
+
+ case 0xf:
+ opcode = code & 0xf;
+ if (opcode < 9)
+ {
+ count = CVAL(input);
+ count |= CVAL(input) << 8;
+ }
+ else
+ {
+ count = (opcode < 0xb) ? 8 : 1;
+ }
+ offset = 0;
+ break;
+
+ default:
+ opcode >>= 1;
+ count = code & 0x1f;
+ offset = 32;
+ break;
+ }
+
+ /* Handle strange cases for counts */
+ if (offset != 0)
+ {
+ isfillormix = ((opcode == 2) || (opcode == 7));
+
+ if (count == 0)
+ {
+ if (isfillormix)
+ count = CVAL(input) + 1;
+ else
+ count = CVAL(input) + offset;
+ }
+ else if (isfillormix)
+ {
+ count <<= 3;
+ }
+ }
+
+ /* Read preliminary data */
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if ((lastopcode == opcode) && !((x == width) && (prevline == NULL)))
+ insertmix = True;
+ break;
+ case 8: /* Bicolour */
+ colour1 = cvalx(&input, Bpp);
+ case 3: /* Colour */
+ colour2 = cvalx(&input, Bpp);
+ break;
+ case 6: /* SetMix/Mix */
+ case 7: /* SetMix/FillOrMix */
+ mix = cvalx(&input, Bpp);
+ opcode -= 5;
+ break;
+ case 9: /* FillOrMix_1 */
+ mask = 0x03;
+ opcode = 0x02;
+ fom_mask = 3;
+ break;
+ case 0x0a: /* FillOrMix_2 */
+ mask = 0x05;
+ opcode = 0x02;
+ fom_mask = 5;
+ break;
+
+ }
+
+ lastopcode = opcode;
+ mixmask = 0;
+
+ /* Output body */
+ while (count > 0)
+ {
+ if (x >= width)
+ {
+ if (height <= 0)
+ return False;
+
+ x = 0;
+ height--;
+
+ prevline = line;
+ line = output + height * width * Bpp;
+ }
+
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if (insertmix)
+ {
+ if (prevline == NULL)
+ setli(line, x, mix, Bpp);
+ else
+ setli(line, x,
+ getli(prevline, x, Bpp) ^ mix, Bpp);
+
+ insertmix = False;
+ count--;
+ x++;
+ }
+
+ if (prevline == NULL)
+ {
+ REPEAT(setli(line, x, 0, Bpp))}
+ else
+ {
+ REPEAT(setli
+ (line, x, getli(prevline, x, Bpp), Bpp));
+ }
+ break;
+
+ case 1: /* Mix */
+ if (prevline == NULL)
+ {
+ REPEAT(setli(line, x, mix, Bpp));
+ }
+ else
+ {
+ REPEAT(setli
+ (line, x, getli(prevline, x, Bpp) ^ mix,
+ Bpp));
+ }
+ break;
+
+ case 2: /* Fill or Mix */
+ if (prevline == NULL)
+ {
+ REPEAT(MASK_UPDATE();
+ if (mask & mixmask) setli(line, x, mix, Bpp);
+ else
+ setli(line, x, 0, Bpp););
+ }
+ else
+ {
+ REPEAT(MASK_UPDATE();
+ if (mask & mixmask)
+ setli(line, x, getli(prevline, x, Bpp) ^ mix,
+ Bpp);
+ else
+ setli(line, x, getli(prevline, x, Bpp),
+ Bpp););
+ }
+ break;
+
+ case 3: /* Colour */
+ REPEAT(setli(line, x, colour2, Bpp));
+ break;
+
+ case 4: /* Copy */
+ REPEAT(setli(line, x, cvalx(&input, Bpp), Bpp));
+ break;
+
+ case 8: /* Bicolour */
+ REPEAT(if (bicolour)
+ {
+ setli(line, x, colour2, Bpp); bicolour = False;}
+ else
+ {
+ setli(line, x, colour1, Bpp); bicolour = True;
+ count++;}
+ );
+ break;
+
+ case 0xd: /* White */
+ REPEAT(setli(line, x, 0xffffffff, Bpp));
+ break;
+
+ case 0xe: /* Black */
+ REPEAT(setli(line, x, 0, Bpp));
+ break;
+
+ default:
+ unimpl("bitmap opcode 0x%x\n", opcode);
+ return False;
+ }
+ }
+ }
+
+ return True;
+}
diff --git a/noncore/net/opierdesktop/cache.cpp b/noncore/net/opierdesktop/cache.cpp
new file mode 100644
index 0000000..42ab135
--- a/dev/null
+++ b/noncore/net/opierdesktop/cache.cpp
@@ -0,0 +1,235 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Cache routines
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include "rdesktop.h"
+
+#define NUM_ELEMENTS(array) (sizeof(array) / sizeof(array[0]))
+
+
+/* BITMAP CACHE */
+static HBITMAP bmpcache[3][600];
+
+/* Retrieve a bitmap from the cache */
+HBITMAP
+cache_get_bitmap(uint8 cache_id, uint16 cache_idx)
+{
+ HBITMAP bitmap;
+
+ if ((cache_id < NUM_ELEMENTS(bmpcache)) && (cache_idx < NUM_ELEMENTS(bmpcache[0])))
+ {
+ bitmap = bmpcache[cache_id][cache_idx];
+ if (bitmap != NULL)
+ return bitmap;
+ }
+
+ error("get bitmap %d:%d\n", cache_id, cache_idx);
+ return NULL;
+}
+
+/* Store a bitmap in the cache */
+void
+cache_put_bitmap(uint8 cache_id, uint16 cache_idx, HBITMAP bitmap)
+{
+ HBITMAP old;
+
+ if ((cache_id < NUM_ELEMENTS(bmpcache)) && (cache_idx < NUM_ELEMENTS(bmpcache[0])))
+ {
+ old = bmpcache[cache_id][cache_idx];
+ if (old != NULL)
+ ui_destroy_bitmap(old);
+
+ bmpcache[cache_id][cache_idx] = bitmap;
+ }
+ else
+ {
+ error("put bitmap %d:%d\n", cache_id, cache_idx);
+ }
+}
+
+
+/* FONT CACHE */
+static FONTGLYPH fontcache[12][256];
+
+/* Retrieve a glyph from the font cache */
+FONTGLYPH *
+cache_get_font(uint8 font, uint16 character)
+{
+ FONTGLYPH *glyph;
+
+ if ((font < NUM_ELEMENTS(fontcache)) && (character < NUM_ELEMENTS(fontcache[0])))
+ {
+ glyph = &fontcache[font][character];
+ if (glyph->pixmap != NULL)
+ return glyph;
+ }
+
+ error("get font %d:%d\n", font, character);
+ return NULL;
+}
+
+/* Store a glyph in the font cache */
+void
+cache_put_font(uint8 font, uint16 character, uint16 offset,
+ uint16 baseline, uint16 width, uint16 height, HGLYPH pixmap)
+{
+ FONTGLYPH *glyph;
+
+ if ((font < NUM_ELEMENTS(fontcache)) && (character < NUM_ELEMENTS(fontcache[0])))
+ {
+ glyph = &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);
+ }
+}
+
+
+/* TEXT CACHE */
+static DATABLOB textcache[256];
+
+/* Retrieve a text item from the cache */
+DATABLOB *
+cache_get_text(uint8 cache_id)
+{
+ DATABLOB *text;
+
+ if (cache_id < NUM_ELEMENTS(textcache))
+ {
+ text = &textcache[cache_id];
+ if (text->data != NULL)
+ return text;
+ }
+
+ error("get text %d\n", cache_id);
+ return NULL;
+}
+
+/* Store a text item in the cache */
+void
+cache_put_text(uint8 cache_id, void *data, int length)
+{
+ DATABLOB *text;
+
+ if (cache_id < NUM_ELEMENTS(textcache))
+ {
+ text = &textcache[cache_id];
+ if (text->data != NULL)
+ xfree(text->data);
+
+ text->data = xmalloc(length);
+ text->size = length;
+ memcpy(text->data, data, length);
+ }
+ else
+ {
+ error("put text %d\n", cache_id);
+ }
+}
+
+
+/* DESKTOP CACHE */
+static uint8 deskcache[0x38400];
+
+/* Retrieve desktop data from the cache */
+uint8 *
+cache_get_desktop(uint32 offset, int cx, int cy, int bytes_per_pixel)
+{
+ int length = cx * cy * bytes_per_pixel;
+
+ if ((offset + length) <= sizeof(deskcache))
+ {
+ return &deskcache[offset];
+ }
+
+ error("get desktop %d:%d\n", offset, length);
+ return NULL;
+}
+
+/* Store desktop data in the cache */
+void
+cache_put_desktop(uint32 offset, int cx, int cy, int scanline, int bytes_per_pixel, uint8 * data)
+{
+ int length = cx * cy * bytes_per_pixel;
+
+ if ((offset + length) <= sizeof(deskcache))
+ {
+ cx *= bytes_per_pixel;
+ while (cy--)
+ {
+ memcpy(&deskcache[offset], data, cx);
+ data += scanline;
+ offset += cx;
+ }
+ }
+ else
+ {
+ error("put desktop %d:%d\n", offset, length);
+ }
+}
+
+
+/* CURSOR CACHE */
+static HCURSOR cursorcache[0x20];
+
+/* Retrieve cursor from cache */
+HCURSOR
+cache_get_cursor(uint16 cache_idx)
+{
+ HCURSOR cursor;
+
+ if (cache_idx < NUM_ELEMENTS(cursorcache))
+ {
+ cursor = cursorcache[cache_idx];
+ if (cursor != NULL)
+ return cursor;
+ }
+
+ error("get cursor %d\n", cache_idx);
+ return NULL;
+}
+
+/* Store cursor in cache */
+void
+cache_put_cursor(uint16 cache_idx, HCURSOR cursor)
+{
+ HCURSOR old;
+
+ if (cache_idx < NUM_ELEMENTS(cursorcache))
+ {
+ old = cursorcache[cache_idx];
+ if (old != NULL)
+ ui_destroy_cursor(old);
+
+ cursorcache[cache_idx] = cursor;
+ }
+ else
+ {
+ error("put cursor %d\n", cache_idx);
+ }
+}
diff --git a/noncore/net/opierdesktop/constants.h b/noncore/net/opierdesktop/constants.h
new file mode 100644
index 0000000..6dfbf93
--- a/dev/null
+++ b/noncore/net/opierdesktop/constants.h
@@ -0,0 +1,259 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Miscellaneous protocol constants
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+/* TCP port for Remote Desktop Protocol */
+#define TCP_PORT_RDP 3389
+
+/* ISO PDU codes */
+enum ISO_PDU_CODE
+{
+ ISO_PDU_CR = 0xE0, /* Connection Request */
+ ISO_PDU_CC = 0xD0, /* Connection Confirm */
+ ISO_PDU_DR = 0x80, /* Disconnect Request */
+ ISO_PDU_DT = 0xF0, /* Data */
+ ISO_PDU_ER = 0x70 /* Error */
+};
+
+/* MCS PDU codes */
+enum MCS_PDU_TYPE
+{
+ MCS_EDRQ = 1, /* Erect Domain Request */
+ MCS_DPUM = 8, /* Disconnect Provider Ultimatum */
+ MCS_AURQ = 10, /* Attach User Request */
+ MCS_AUCF = 11, /* Attach User Confirm */
+ MCS_CJRQ = 14, /* Channel Join Request */
+ MCS_CJCF = 15, /* Channel Join Confirm */
+ MCS_SDRQ = 25, /* Send Data Request */
+ MCS_SDIN = 26 /* Send Data Indication */
+};
+
+#define MCS_CONNECT_INITIAL 0x7f65
+#define MCS_CONNECT_RESPONSE 0x7f66
+
+#define BER_TAG_BOOLEAN 1
+#define BER_TAG_INTEGER 2
+#define BER_TAG_OCTET_STRING 4
+#define BER_TAG_RESULT 10
+#define MCS_TAG_DOMAIN_PARAMS 0x30
+
+#define MCS_GLOBAL_CHANNEL 1003
+
+/* RDP secure transport constants */
+#define SEC_RANDOM_SIZE 32
+#define SEC_MODULUS_SIZE 64
+#define SEC_PADDING_SIZE 8
+#define SEC_EXPONENT_SIZE 4
+
+#define SEC_CLIENT_RANDOM 0x0001
+#define SEC_ENCRYPT 0x0008
+#define SEC_LOGON_INFO 0x0040
+#define SEC_LICENCE_NEG 0x0080
+
+#define SEC_TAG_SRV_INFO 0x0c01
+#define SEC_TAG_SRV_CRYPT 0x0c02
+#define SEC_TAG_SRV_3 0x0c03
+
+#define SEC_TAG_CLI_INFO 0xc001
+#define SEC_TAG_CLI_CRYPT 0xc002
+
+#define SEC_TAG_PUBKEY 0x0006
+#define SEC_TAG_KEYSIG 0x0008
+
+#define SEC_RSA_MAGIC 0x31415352 /* RSA1 */
+
+/* RDP licensing constants */
+#define LICENCE_TOKEN_SIZE 10
+#define LICENCE_HWID_SIZE 20
+#define LICENCE_SIGNATURE_SIZE 16
+
+#define LICENCE_TAG_DEMAND 0x0201
+#define LICENCE_TAG_AUTHREQ 0x0202
+#define LICENCE_TAG_ISSUE 0x0203
+#define LICENCE_TAG_REISSUE 0x0204
+#define LICENCE_TAG_PRESENT 0x0212
+#define LICENCE_TAG_REQUEST 0x0213
+#define LICENCE_TAG_AUTHRESP 0x0215
+#define LICENCE_TAG_RESULT 0x02ff
+
+#define LICENCE_TAG_USER 0x000f
+#define LICENCE_TAG_HOST 0x0010
+
+/* RDP PDU codes */
+enum RDP_PDU_TYPE
+{
+ RDP_PDU_DEMAND_ACTIVE = 1,
+ RDP_PDU_CONFIRM_ACTIVE = 3,
+ RDP_PDU_DEACTIVATE = 6,
+ RDP_PDU_DATA = 7
+};
+
+enum RDP_DATA_PDU_TYPE
+{
+ RDP_DATA_PDU_UPDATE = 2,
+ RDP_DATA_PDU_CONTROL = 20,
+ RDP_DATA_PDU_POINTER = 27,
+ RDP_DATA_PDU_INPUT = 28,
+ RDP_DATA_PDU_SYNCHRONISE = 31,
+ RDP_DATA_PDU_BELL = 34,
+ RDP_DATA_PDU_LOGON = 38,
+ RDP_DATA_PDU_FONT2 = 39
+};
+
+enum RDP_CONTROL_PDU_TYPE
+{
+ RDP_CTL_REQUEST_CONTROL = 1,
+ RDP_CTL_GRANT_CONTROL = 2,
+ RDP_CTL_DETACH = 3,
+ RDP_CTL_COOPERATE = 4
+};
+
+enum RDP_UPDATE_PDU_TYPE
+{
+ RDP_UPDATE_ORDERS = 0,
+ RDP_UPDATE_BITMAP = 1,
+ RDP_UPDATE_PALETTE = 2,
+ RDP_UPDATE_SYNCHRONIZE = 3
+};
+
+enum RDP_POINTER_PDU_TYPE
+{
+ RDP_POINTER_MOVE = 3,
+ RDP_POINTER_COLOR = 6,
+ RDP_POINTER_CACHED = 7
+};
+
+enum RDP_INPUT_DEVICE
+{
+ RDP_INPUT_SYNCHRONIZE = 0,
+ RDP_INPUT_CODEPOINT = 1,
+ RDP_INPUT_VIRTKEY = 2,
+ RDP_INPUT_SCANCODE = 4,
+ RDP_INPUT_MOUSE = 0x8001
+};
+
+/* Device flags */
+#define KBD_FLAG_RIGHT 0x0001
+#define KBD_FLAG_EXT 0x0100
+#define KBD_FLAG_QUIET 0x1000
+#define KBD_FLAG_DOWN 0x4000
+#define KBD_FLAG_UP 0x8000
+
+/* These are for synchronization; not for keystrokes */
+#define KBD_FLAG_SCROLL 0x0001
+#define KBD_FLAG_NUMLOCK 0x0002
+#define KBD_FLAG_CAPITAL 0x0004
+
+/* See T.128 */
+#define RDP_KEYPRESS 0
+#define RDP_KEYRELEASE (KBD_FLAG_DOWN | KBD_FLAG_UP)
+
+#define MOUSE_FLAG_MOVE 0x0800
+#define MOUSE_FLAG_BUTTON1 0x1000
+#define MOUSE_FLAG_BUTTON2 0x2000
+#define MOUSE_FLAG_BUTTON3 0x4000
+#define MOUSE_FLAG_BUTTON4 0x0280
+#define MOUSE_FLAG_BUTTON5 0x0380
+#define MOUSE_FLAG_DOWN 0x8000
+
+/* Raster operation masks */
+#define ROP2_S(rop3) (rop3 & 0xf)
+#define ROP2_P(rop3) ((rop3 & 0x3) | ((rop3 & 0x30) >> 2))
+
+#define ROP2_COPY 0xc
+#define ROP2_XOR 0x6
+#define ROP2_AND 0x8
+#define ROP2_NXOR 0x9
+#define ROP2_OR 0xe
+
+#define MIX_TRANSPARENT 0
+#define MIX_OPAQUE 1
+
+#define TEXT2_VERTICAL 0x04
+#define TEXT2_IMPLICIT_X 0x20
+
+/* RDP capabilities */
+#define RDP_CAPSET_GENERAL 1
+#define RDP_CAPLEN_GENERAL 0x18
+#define OS_MAJOR_TYPE_UNIX 4
+#define OS_MINOR_TYPE_XSERVER 7
+
+#define RDP_CAPSET_BITMAP 2
+#define RDP_CAPLEN_BITMAP 0x1C
+
+#define RDP_CAPSET_ORDER 3
+#define RDP_CAPLEN_ORDER 0x58
+#define ORDER_CAP_NEGOTIATE 2
+#define ORDER_CAP_NOSUPPORT 4
+
+#define RDP_CAPSET_BMPCACHE 4
+#define RDP_CAPLEN_BMPCACHE 0x28
+
+#define RDP_CAPSET_CONTROL 5
+#define RDP_CAPLEN_CONTROL 0x0C
+
+#define RDP_CAPSET_ACTIVATE 7
+#define RDP_CAPLEN_ACTIVATE 0x0C
+
+#define RDP_CAPSET_POINTER 8
+#define RDP_CAPLEN_POINTER 0x08
+
+#define RDP_CAPSET_SHARE 9
+#define RDP_CAPLEN_SHARE 0x08
+
+#define RDP_CAPSET_COLCACHE 10
+#define RDP_CAPLEN_COLCACHE 0x08
+
+#define RDP_CAPSET_UNKNOWN 13
+#define RDP_CAPLEN_UNKNOWN 0x9C
+
+#define RDP_SOURCE "MSTSC"
+
+/* Logon flags */
+#define RDP_LOGON_NORMAL 0x33
+#define RDP_LOGON_AUTO 0x8
+
+/* Keymap flags */
+#define MapRightShiftMask (1<<0)
+#define MapLeftShiftMask (1<<1)
+#define MapShiftMask (MapRightShiftMask | MapLeftShiftMask)
+
+#define MapRightAltMask (1<<2)
+#define MapLeftAltMask (1<<3)
+#define MapAltGrMask MapRightAltMask
+
+#define MapRightCtrlMask (1<<4)
+#define MapLeftCtrlMask (1<<5)
+#define MapCtrlMask (MapRightCtrlMask | MapLeftCtrlMask)
+
+#define MapRightWinMask (1<<6)
+#define MapLeftWinMask (1<<7)
+#define MapWinMask (MapRightWinMask | MapLeftWinMask)
+
+#define MapNumLockMask (1<<8)
+#define MapCapsLockMask (1<<9)
+
+#define MapLocalStateMask (1<<10)
+
+#define MapInhibitMask (1<<11)
+
+#define MASK_ADD_BITS(var, mask) (var |= mask)
+#define MASK_REMOVE_BITS(var, mask) (var &= ~mask)
+#define MASK_HAS_BITS(var, mask) ((var & mask)>0)
+#define MASK_CHANGE_BIT(var, mask, active) (var = ((var & ~mask) | (active ? mask : 0)))
diff --git a/noncore/net/opierdesktop/iso.cpp b/noncore/net/opierdesktop/iso.cpp
new file mode 100644
index 0000000..0fa1a17
--- a/dev/null
+++ b/noncore/net/opierdesktop/iso.cpp
@@ -0,0 +1,170 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Protocol services - ISO layer
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include "rdesktop.h"
+
+/* Send a self-contained ISO PDU */
+static void
+iso_send_msg(uint8 code)
+{
+ STREAM s;
+
+ s = tcp_init(11);
+
+ out_uint8(s, 3); /* version */
+ out_uint8(s, 0); /* reserved */
+ out_uint16_be(s, 11); /* length */
+
+ out_uint8(s, 6); /* hdrlen */
+ out_uint8(s, code);
+ out_uint16(s, 0); /* dst_ref */
+ out_uint16(s, 0); /* src_ref */
+ out_uint8(s, 0); /* class */
+
+ s_mark_end(s);
+ tcp_send(s);
+}
+
+/* Receive a message on the ISO layer, return code */
+static STREAM
+iso_recv_msg(uint8 * code)
+{
+ STREAM s;
+ uint16 length;
+ uint8 version;
+
+ s = tcp_recv(4);
+ if (s == NULL)
+ {
+ return NULL;
+ }
+
+ in_uint8(s, version);
+ if (version != 3)
+ {
+ error("TPKT v%d\n", version);
+ return NULL;
+ }
+
+ in_uint8s(s, 1); /* pad */
+ in_uint16_be(s, length);
+
+ s = tcp_recv(length - 4);
+ if (s == NULL)
+ return NULL;
+
+ in_uint8s(s, 1); /* hdrlen */
+ in_uint8(s, *code);
+
+ if (*code == ISO_PDU_DT)
+ {
+ in_uint8s(s, 1); /* eot */
+ return s;
+ }
+
+ in_uint8s(s, 5); /* dst_ref, src_ref, class */
+ return s;
+}
+
+/* Initialise ISO transport data packet */
+STREAM
+iso_init(int length)
+{
+ STREAM s;
+
+ s = tcp_init(length + 7);
+ s_push_layer(s, iso_hdr, 7);
+
+ return s;
+}
+
+/* Send an ISO data PDU */
+void
+iso_send(STREAM s)
+{
+ 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);
+}
+
+/* Receive ISO transport data packet */
+STREAM
+iso_recv(void)
+{
+ STREAM s;
+ uint8 code;
+
+ s = iso_recv_msg(&code);
+ if (s == NULL)
+ return NULL;
+
+ if (code != ISO_PDU_DT)
+ {
+ error("expected DT, got 0x%x\n", code);
+ return NULL;
+ }
+
+ return s;
+}
+
+/* Establish a connection up to the ISO layer */
+BOOL
+iso_connect(char *server)
+{
+ uint8 code;
+
+ if (!tcp_connect(server))
+ return False;
+
+ iso_send_msg(ISO_PDU_CR);
+
+ if (iso_recv_msg(&code) == NULL)
+ {
+ return False;
+ }
+
+ if (code != ISO_PDU_CC)
+ {
+ error("expected CC, got 0x%x\n", code);
+ tcp_disconnect();
+ return False;
+ }
+
+ return True;
+}
+
+/* Disconnect from the ISO layer */
+void
+iso_disconnect(void)
+{
+ iso_send_msg(ISO_PDU_DR);
+ tcp_disconnect();
+}
diff --git a/noncore/net/opierdesktop/licence.cpp b/noncore/net/opierdesktop/licence.cpp
new file mode 100644
index 0000000..4e5bc38
--- a/dev/null
+++ b/noncore/net/opierdesktop/licence.cpp
@@ -0,0 +1,314 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ RDP licensing negotiation
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include "rdesktop.h"
+
+#ifdef WITH_OPENSSL
+#include <openssl/rc4.h>
+#else
+#include "crypto/rc4.h"
+#endif
+
+extern char username[16];
+extern char hostname[16];
+
+static uint8 licence_key[16];
+static uint8 licence_sign_key[16];
+
+BOOL licence_issued = False;
+
+/* Generate a session key and RC4 keys, given client and server randoms */
+static void
+licence_generate_keys(uint8 * client_key, uint8 * server_key, uint8 * client_rsa)
+{
+ uint8 session_key[48];
+ uint8 temp_hash[48];
+
+ /* Generate session key - two rounds of sec_hash_48 */
+ sec_hash_48(temp_hash, client_rsa, client_key, server_key, 65);
+ sec_hash_48(session_key, temp_hash, server_key, client_key, 65);
+
+ /* Store first 16 bytes of session key, for generating signatures */
+ memcpy(licence_sign_key, session_key, 16);
+
+ /* Generate RC4 key */
+ sec_hash_16(licence_key, &session_key[16], client_key, server_key);
+}
+
+static void
+licence_generate_hwid(uint8 * hwid)
+{
+ buf_out_uint32(hwid, 2);
+ strncpy((char *) (hwid + 4), hostname, LICENCE_HWID_SIZE - 4);
+}
+
+/* Present an existing licence to the server */
+static void
+licence_present(uint8 * client_random, uint8 * rsa_data,
+ uint8 * licence_data, int licence_size, uint8 * hwid, uint8 * signature)
+{
+ uint32 sec_flags = SEC_LICENCE_NEG;
+ uint16 length =
+ 16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
+ licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
+ STREAM s;
+
+ s = sec_init(sec_flags, length + 4);
+
+ out_uint16_le(s, LICENCE_TAG_PRESENT);
+ out_uint16_le(s, length);
+
+ out_uint32_le(s, 1);
+ out_uint16(s, 0);
+ out_uint16_le(s, 0x0201);
+
+ out_uint8p(s, client_random, SEC_RANDOM_SIZE);
+ out_uint16(s, 0);
+ out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE));
+ out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
+ out_uint8s(s, SEC_PADDING_SIZE);
+
+ out_uint16_le(s, 1);
+ out_uint16_le(s, licence_size);
+ out_uint8p(s, licence_data, licence_size);
+
+ out_uint16_le(s, 1);
+ out_uint16_le(s, LICENCE_HWID_SIZE);
+ out_uint8p(s, hwid, LICENCE_HWID_SIZE);
+
+ out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
+
+ s_mark_end(s);
+ sec_send(s, sec_flags);
+}
+
+/* Send a licence request packet */
+static void
+licence_send_request(uint8 * client_random, uint8 * rsa_data, char *user, char *host)
+{
+ uint32 sec_flags = SEC_LICENCE_NEG;
+ uint16 userlen = strlen(user) + 1;
+ uint16 hostlen = strlen(host) + 1;
+ uint16 length = 128 + userlen + hostlen;
+ STREAM s;
+
+ s = sec_init(sec_flags, length + 2);
+
+ out_uint16_le(s, LICENCE_TAG_REQUEST);
+ out_uint16_le(s, length);
+
+ out_uint32_le(s, 1);
+ out_uint16(s, 0);
+ out_uint16_le(s, 0xff01);
+
+ out_uint8p(s, client_random, SEC_RANDOM_SIZE);
+ out_uint16(s, 0);
+ out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE));
+ out_uint8p(s, rsa_data, SEC_MODULUS_SIZE);
+ out_uint8s(s, SEC_PADDING_SIZE);
+
+ out_uint16(s, LICENCE_TAG_USER);
+ out_uint16(s, userlen);
+ out_uint8p(s, user, userlen);
+
+ out_uint16(s, LICENCE_TAG_HOST);
+ out_uint16(s, hostlen);
+ out_uint8p(s, host, hostlen);
+
+ s_mark_end(s);
+ sec_send(s, sec_flags);
+}
+
+/* Process a licence demand packet */
+static void
+licence_process_demand(STREAM s)
+{
+ uint8 null_data[SEC_MODULUS_SIZE];
+ uint8 *server_random;
+ uint8 signature[LICENCE_SIGNATURE_SIZE];
+ uint8 hwid[LICENCE_HWID_SIZE];
+ uint8 *licence_data;
+ int licence_size;
+ RC4_KEY crypt_key;
+
+ /* Retrieve the server random from the incoming packet */
+ in_uint8p(s, server_random, SEC_RANDOM_SIZE);
+
+ /* We currently use null client keys. This is a bit naughty but, hey,
+ the security of licence negotiation isn't exactly paramount. */
+ memset(null_data, 0, sizeof(null_data));
+ licence_generate_keys(null_data, server_random, null_data);
+
+ licence_size = load_licence(&licence_data);
+ if (licence_size != -1)
+ {
+ /* Generate a signature for the HWID buffer */
+ licence_generate_hwid(hwid);
+ sec_sign(signature, 16, licence_sign_key, 16, hwid, sizeof(hwid));
+
+ /* Now encrypt the HWID */
+ RC4_set_key(&crypt_key, 16, licence_key);
+ RC4(&crypt_key, sizeof(hwid), hwid, hwid);
+
+ licence_present(null_data, null_data, licence_data, licence_size, hwid, signature);
+ xfree(licence_data);
+ return;
+ }
+
+ licence_send_request(null_data, null_data, username, hostname);
+}
+
+/* Send an authentication response packet */
+static void
+licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
+{
+ uint32 sec_flags = SEC_LICENCE_NEG;
+ uint16 length = 58;
+ STREAM s;
+
+ s = sec_init(sec_flags, length + 2);
+
+ out_uint16_le(s, LICENCE_TAG_AUTHRESP);
+ out_uint16_le(s, length);
+
+ out_uint16_le(s, 1);
+ out_uint16_le(s, LICENCE_TOKEN_SIZE);
+ out_uint8p(s, token, LICENCE_TOKEN_SIZE);
+
+ out_uint16_le(s, 1);
+ out_uint16_le(s, LICENCE_HWID_SIZE);
+ out_uint8p(s, crypt_hwid, LICENCE_HWID_SIZE);
+
+ out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
+
+ s_mark_end(s);
+ sec_send(s, sec_flags);
+}
+
+/* Parse an authentication request packet */
+static BOOL
+licence_parse_authreq(STREAM s, uint8 ** token, uint8 ** signature)
+{
+ uint16 tokenlen;
+
+ in_uint8s(s, 6); /* unknown: f8 3d 15 00 04 f6 */
+
+ in_uint16_le(s, tokenlen);
+ if (tokenlen != LICENCE_TOKEN_SIZE)
+ {
+ error("token len %d\n", tokenlen);
+ return False;
+ }
+
+ in_uint8p(s, *token, tokenlen);
+ in_uint8p(s, *signature, LICENCE_SIGNATURE_SIZE);
+
+ return s_check_end(s);
+}
+
+/* Process an authentication request packet */
+static void
+licence_process_authreq(STREAM s)
+{
+ uint8 *in_token, *in_sig;
+ uint8 out_token[LICENCE_TOKEN_SIZE], decrypt_token[LICENCE_TOKEN_SIZE];
+ uint8 hwid[LICENCE_HWID_SIZE], crypt_hwid[LICENCE_HWID_SIZE];
+ uint8 sealed_buffer[LICENCE_TOKEN_SIZE + LICENCE_HWID_SIZE];
+ uint8 out_sig[LICENCE_SIGNATURE_SIZE];
+ RC4_KEY crypt_key;
+
+ /* Parse incoming packet and save the encrypted token */
+ licence_parse_authreq(s, &in_token, &in_sig);
+ memcpy(out_token, in_token, LICENCE_TOKEN_SIZE);
+
+ /* Decrypt the token. It should read TEST in Unicode. */
+ RC4_set_key(&crypt_key, 16, licence_key);
+ RC4(&crypt_key, LICENCE_TOKEN_SIZE, in_token, decrypt_token);
+
+ /* Generate a signature for a buffer of token and HWID */
+ licence_generate_hwid(hwid);
+ memcpy(sealed_buffer, decrypt_token, LICENCE_TOKEN_SIZE);
+ memcpy(sealed_buffer + LICENCE_TOKEN_SIZE, hwid, LICENCE_HWID_SIZE);
+ sec_sign(out_sig, 16, licence_sign_key, 16, sealed_buffer, sizeof(sealed_buffer));
+
+ /* Now encrypt the HWID */
+ RC4_set_key(&crypt_key, 16, licence_key);
+ RC4(&crypt_key, LICENCE_HWID_SIZE, hwid, crypt_hwid);
+
+ licence_send_authresp(out_token, crypt_hwid, out_sig);
+}
+
+/* Process an licence issue packet */
+static void
+licence_process_issue(STREAM s)
+{
+ RC4_KEY crypt_key;
+ uint32 length;
+ uint16 check;
+
+ in_uint8s(s, 2); /* 3d 45 - unknown */
+ in_uint16_le(s, length);
+ if (!s_check_rem(s, length))
+ return;
+
+ RC4_set_key(&crypt_key, 16, licence_key);
+ RC4(&crypt_key, length, s->p, s->p);
+
+ in_uint16(s, check);
+ if (check != 0)
+ return;
+
+ licence_issued = True;
+ save_licence(s->p, length - 2);
+}
+
+/* Process a licence packet */
+void
+licence_process(STREAM s)
+{
+ uint16 tag;
+
+ in_uint16_le(s, tag);
+ in_uint8s(s, 2); /* length */
+
+ switch (tag)
+ {
+ case LICENCE_TAG_DEMAND:
+ licence_process_demand(s);
+ break;
+
+ case LICENCE_TAG_AUTHREQ:
+ licence_process_authreq(s);
+ break;
+
+ case LICENCE_TAG_ISSUE:
+ licence_process_issue(s);
+ break;
+
+ case LICENCE_TAG_REISSUE:
+ break;
+
+ case LICENCE_TAG_RESULT:
+ break;
+
+ default:
+ unimpl("licence tag 0x%x\n", tag);
+ }
+}
diff --git a/noncore/net/opierdesktop/mcs.cpp b/noncore/net/opierdesktop/mcs.cpp
new file mode 100644
index 0000000..8877d62
--- a/dev/null
+++ b/noncore/net/opierdesktop/mcs.cpp
@@ -0,0 +1,394 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Protocol services - Multipoint Communications Service
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include "rdesktop.h"
+
+uint16 mcs_userid;
+
+/* Parse an ASN.1 BER header */
+static BOOL
+ber_parse_header(STREAM s, int tagval, unsigned int *length)
+{
+ 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);
+}
+
+/* Output an ASN.1 BER header */
+static void
+ber_out_header(STREAM s, int tagval, int length)
+{
+ 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);
+}
+
+/* Output an ASN.1 BER integer */
+static void
+ber_out_integer(STREAM s, int value)
+{
+ ber_out_header(s, BER_TAG_INTEGER, 2);
+ out_uint16_be(s, value);
+}
+
+/* Output a DOMAIN_PARAMS structure (ASN.1 BER) */
+static void
+mcs_out_domain_params(STREAM s, int max_channels, int max_users, int max_tokens, int max_pdusize)
+{
+ ber_out_header(s, MCS_TAG_DOMAIN_PARAMS, 32);
+ ber_out_integer(s, max_channels);
+ ber_out_integer(s, max_users);
+ ber_out_integer(s, max_tokens);
+ ber_out_integer(s, 1); /* num_priorities */
+ ber_out_integer(s, 0); /* min_throughput */
+ ber_out_integer(s, 1); /* max_height */
+ ber_out_integer(s, max_pdusize);
+ ber_out_integer(s, 2); /* ver_protocol */
+}
+
+/* Parse a DOMAIN_PARAMS structure (ASN.1 BER) */
+static BOOL
+mcs_parse_domain_params(STREAM s)
+{
+ unsigned int length;
+
+ ber_parse_header(s, MCS_TAG_DOMAIN_PARAMS, &length);
+ in_uint8s(s, length);
+
+ return s_check(s);
+}
+
+/* Send an MCS_CONNECT_INITIAL message (ASN.1 BER) */
+static void
+mcs_send_connect_initial(STREAM mcs_data)
+{
+ int datalen = mcs_data->end - mcs_data->data;
+ int length = 7 + 3 * 34 + 4 + datalen;
+ STREAM s;
+
+ s = iso_init(length + 5);
+
+ ber_out_header(s, MCS_CONNECT_INITIAL, length);
+ ber_out_header(s, BER_TAG_OCTET_STRING, 0); /* calling domain */
+ ber_out_header(s, BER_TAG_OCTET_STRING, 0); /* called domain */
+
+ ber_out_header(s, BER_TAG_BOOLEAN, 1);
+ out_uint8(s, 0xff); /* upward flag */
+
+ mcs_out_domain_params(s, 2, 2, 0, 0xffff); /* target params */
+ mcs_out_domain_params(s, 1, 1, 1, 0x420); /* min params */
+ mcs_out_domain_params(s, 0xffff, 0xfc17, 0xffff, 0xffff); /* max params */
+
+ ber_out_header(s, BER_TAG_OCTET_STRING, datalen);
+ out_uint8p(s, mcs_data->data, datalen);
+
+ s_mark_end(s);
+ iso_send(s);
+}
+
+/* Expect a MCS_CONNECT_RESPONSE message (ASN.1 BER) */
+static BOOL
+mcs_recv_connect_response(STREAM mcs_data)
+{
+ uint8 result;
+ unsigned int length;
+ STREAM s;
+
+ s = iso_recv();
+ if (s == NULL)
+ return False;
+
+ ber_parse_header(s, MCS_CONNECT_RESPONSE, &length);
+
+ ber_parse_header(s, BER_TAG_RESULT, &length);
+ in_uint8(s, result);
+ if (result != 0)
+ {
+ error("MCS connect: %d\n", result);
+ return False;
+ }
+
+ ber_parse_header(s, BER_TAG_INTEGER, &length);
+ in_uint8s(s, length); /* connect id */
+ mcs_parse_domain_params(s);
+
+ ber_parse_header(s, BER_TAG_OCTET_STRING, &length);
+ if (length > mcs_data->size)
+ {
+ error("MCS data length %d\n", length);
+ length = mcs_data->size;
+ }
+
+ in_uint8a(s, mcs_data->data, length);
+ mcs_data->p = mcs_data->data;
+ mcs_data->end = mcs_data->data + length;
+
+ return s_check_end(s);
+}
+
+/* Send an EDrq message (ASN.1 PER) */
+static void
+mcs_send_edrq(void)
+{
+ STREAM s;
+
+ s = iso_init(5);
+
+ out_uint8(s, (MCS_EDRQ << 2));
+ out_uint16_be(s, 1); /* height */
+ out_uint16_be(s, 1); /* interval */
+
+ s_mark_end(s);
+ iso_send(s);
+}
+
+/* Send an AUrq message (ASN.1 PER) */
+static void
+mcs_send_aurq(void)
+{
+ STREAM s;
+
+ s = iso_init(1);
+
+ out_uint8(s, (MCS_AURQ << 2));
+
+ s_mark_end(s);
+ iso_send(s);
+}
+
+/* Expect a AUcf message (ASN.1 PER) */
+static BOOL
+mcs_recv_aucf(uint16 * mcs_userid)
+{
+ uint8 opcode, result;
+ STREAM s;
+
+ s = iso_recv();
+ if (s == NULL)
+ return False;
+
+ in_uint8(s, opcode);
+ if ((opcode >> 2) != MCS_AUCF)
+ {
+ error("expected AUcf, got %d\n", opcode);
+ return False;
+ }
+
+ in_uint8(s, result);
+ if (result != 0)
+ {
+ error("AUrq: %d\n", result);
+ return False;
+ }
+
+ if (opcode & 2)
+ in_uint16_be(s, *mcs_userid);
+
+ return s_check_end(s);
+}
+
+/* Send a CJrq message (ASN.1 PER) */
+static void
+mcs_send_cjrq(uint16 chanid)
+{
+ STREAM s;
+
+ s = iso_init(5);
+
+ out_uint8(s, (MCS_CJRQ << 2));
+ out_uint16_be(s, mcs_userid);
+ out_uint16_be(s, chanid);
+
+ s_mark_end(s);
+ iso_send(s);
+}
+
+/* Expect a CJcf message (ASN.1 PER) */
+static BOOL
+mcs_recv_cjcf(void)
+{
+ uint8 opcode, result;
+ STREAM s;
+
+ s = iso_recv();
+ if (s == NULL)
+ return False;
+
+ in_uint8(s, opcode);
+ if ((opcode >> 2) != MCS_CJCF)
+ {
+ error("expected CJcf, got %d\n", opcode);
+ return False;
+ }
+
+ in_uint8(s, result);
+ if (result != 0)
+ {
+ error("CJrq: %d\n", result);
+ return False;
+ }
+
+ in_uint8s(s, 4); /* mcs_userid, req_chanid */
+ if (opcode & 2)
+ in_uint8s(s, 2); /* join_chanid */
+
+ return s_check_end(s);
+}
+
+/* Initialise an MCS transport data packet */
+STREAM
+mcs_init(int length)
+{
+ STREAM s;
+
+ s = iso_init(length + 8);
+ s_push_layer(s, mcs_hdr, 8);
+
+ return s;
+}
+
+/* Send an MCS transport data packet */
+void
+mcs_send(STREAM s)
+{
+ 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, mcs_userid);
+ out_uint16_be(s, MCS_GLOBAL_CHANNEL);
+ out_uint8(s, 0x70); /* flags */
+ out_uint16_be(s, length);
+
+ iso_send(s);
+}
+
+/* Receive an MCS transport data packet */
+STREAM
+mcs_recv(void)
+{
+ uint8 opcode, appid, length;
+ STREAM s;
+
+ s = iso_recv();
+ if (s == NULL)
+ return NULL;
+
+ 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, 5); /* userid, chanid, flags */
+ in_uint8(s, length);
+ if (length & 0x80)
+ in_uint8s(s, 1); /* second byte of length */
+
+ return s;
+}
+
+/* Establish a connection up to the MCS layer */
+BOOL
+mcs_connect(char *server, STREAM mcs_data)
+{
+ if (!iso_connect(server))
+ {
+ return False;
+ }
+
+ 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(&mcs_userid))
+ goto error;
+
+ mcs_send_cjrq(mcs_userid + 1001);
+ if (!mcs_recv_cjcf())
+ goto error;
+
+ mcs_send_cjrq(MCS_GLOBAL_CHANNEL);
+ if (!mcs_recv_cjcf())
+ goto error;
+
+ return True;
+
+ error:
+ iso_disconnect();
+ return False;
+}
+
+/* Disconnect from the MCS layer */
+void
+mcs_disconnect(void)
+{
+ iso_disconnect();
+}
diff --git a/noncore/net/opierdesktop/opie-rdesktop.control b/noncore/net/opierdesktop/opie-rdesktop.control
new file mode 100644
index 0000000..3fe3705
--- a/dev/null
+++ b/noncore/net/opierdesktop/opie-rdesktop.control
@@ -0,0 +1,9 @@
+Package: opie-rdesktop
+Files: bin/ordesktop pics/opierdesktop apps/Applications/opierdesktop.desktop
+Priority: optional
+Section: opie/applications
+Maintainer: Michael 'Mickey' Lauer <mickeyl@handhelds.org>
+Architecture: arm
+Version: 1.2.0-$SUB_VERSION
+Depends: task-opie-minimal
+Description: Remote Desktop Protocol (RDP) Client
diff --git a/noncore/net/opierdesktop/opierdesktop.pro b/noncore/net/opierdesktop/opierdesktop.pro
new file mode 100644
index 0000000..7704855
--- a/dev/null
+++ b/noncore/net/opierdesktop/opierdesktop.pro
@@ -0,0 +1,26 @@
+TEMPLATE = app
+DESTDIR = $(OPIEDIR)/bin
+CONFIG = qt warn_on debug
+
+HEADERS += constants.h orders.h parse.h proto.h qtwin.h rdesktop.h types.h
+SOURCES += bitmap.cpp \
+ cache.cpp \
+ iso.cpp \
+ licence.cpp \
+ mcs.cpp \
+ orders.cpp \
+ qtwin.cpp \
+ rdesktop.cpp \
+ rdp.cpp \
+ secure.cpp \
+ tcp.cpp
+
+INCLUDEPATH += $(OPIEDIR)/include
+DEPENDPATH += $(OPIEDIR)/include
+LIBS += -lqpe -lm -lcrypto
+INTERFACES =
+TARGET = ordesktop
+QMAKE_CXXFLAGS += -DSHARP=1 -DWITH_OPENSSL=1
+
+include ( $(OPIEDIR)/include.pro )
+
diff --git a/noncore/net/opierdesktop/orders.cpp b/noncore/net/opierdesktop/orders.cpp
new file mode 100644
index 0000000..194b043
--- a/dev/null
+++ b/noncore/net/opierdesktop/orders.cpp
@@ -0,0 +1,940 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ RDP order processing
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include "rdesktop.h"
+#include "orders.h"
+
+extern uint8 *next_packet;
+static RDP_ORDER_STATE order_state;
+
+/* Read field indicating which parameters are present */
+static void
+rdp_in_present(STREAM s, uint32 * present, uint8 flags, int size)
+{
+ uint8 bits;
+ int i;
+
+ if (flags & RDP_ORDER_SMALL)
+ {
+ size--;
+ }
+
+ if (flags & RDP_ORDER_TINY)
+ {
+ if (size < 2)
+ size = 0;
+ else
+ size -= 2;
+ }
+
+ *present = 0;
+ for (i = 0; i < size; i++)
+ {
+ in_uint8(s, bits);
+ *present |= bits << (i * 8);
+ }
+}
+
+/* Read a co-ordinate (16-bit, or 8-bit delta) */
+static void
+rdp_in_coord(STREAM s, sint16 * coord, BOOL delta)
+{
+ sint8 change;
+
+ if (delta)
+ {
+ in_uint8(s, change);
+ *coord += change;
+ }
+ else
+ {
+ in_uint16_le(s, *coord);
+ }
+}
+
+/* Read a colour entry */
+static void
+rdp_in_colour(STREAM s, uint32 * colour)
+{
+ uint32 i;
+ in_uint8(s, i);
+ *colour = i;
+ in_uint8(s, i);
+ *colour |= i << 8;
+ in_uint8(s, i);
+ *colour |= i << 16;
+}
+
+/* Parse bounds information */
+static BOOL
+rdp_parse_bounds(STREAM s, BOUNDS * bounds)
+{
+ uint8 present;
+
+ in_uint8(s, present);
+
+ if (present & 1)
+ rdp_in_coord(s, &bounds->left, False);
+ else if (present & 16)
+ rdp_in_coord(s, &bounds->left, True);
+
+ if (present & 2)
+ rdp_in_coord(s, &bounds->top, False);
+ else if (present & 32)
+ rdp_in_coord(s, &bounds->top, True);
+
+ if (present & 4)
+ rdp_in_coord(s, &bounds->right, False);
+ else if (present & 64)
+ rdp_in_coord(s, &bounds->right, True);
+
+ if (present & 8)
+ rdp_in_coord(s, &bounds->bottom, False);
+ else if (present & 128)
+ rdp_in_coord(s, &bounds->bottom, True);
+
+ return s_check(s);
+}
+
+/* Parse a pen */
+static BOOL
+rdp_parse_pen(STREAM s, PEN * pen, uint32 present)
+{
+ if (present & 1)
+ in_uint8(s, pen->style);
+
+ if (present & 2)
+ in_uint8(s, pen->width);
+
+ if (present & 4)
+ rdp_in_colour(s, &pen->colour);
+
+ return s_check(s);
+}
+
+/* Parse a brush */
+static BOOL
+rdp_parse_brush(STREAM s, BRUSH * brush, uint32 present)
+{
+ if (present & 1)
+ in_uint8(s, brush->xorigin);
+
+ if (present & 2)
+ in_uint8(s, brush->yorigin);
+
+ if (present & 4)
+ in_uint8(s, brush->style);
+
+ if (present & 8)
+ in_uint8(s, brush->pattern[0]);
+
+ if (present & 16)
+ in_uint8a(s, &brush->pattern[1], 7);
+
+ return s_check(s);
+}
+
+/* Process a destination blt order */
+static void
+process_destblt(STREAM s, DESTBLT_ORDER * os, uint32 present, BOOL delta)
+{
+ if (present & 0x01)
+ rdp_in_coord(s, &os->x, delta);
+
+ if (present & 0x02)
+ rdp_in_coord(s, &os->y, delta);
+
+ if (present & 0x04)
+ rdp_in_coord(s, &os->cx, delta);
+
+ if (present & 0x08)
+ rdp_in_coord(s, &os->cy, delta);
+
+ if (present & 0x10)
+ in_uint8(s, os->opcode);
+
+ DEBUG(("DESTBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d)\n",
+ os->opcode, os->x, os->y, os->cx, os->cy));
+
+ ui_destblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy);
+}
+
+/* Process a pattern blt order */
+static void
+process_patblt(STREAM s, PATBLT_ORDER * os, uint32 present, BOOL delta)
+{
+ if (present & 0x0001)
+ rdp_in_coord(s, &os->x, delta);
+
+ if (present & 0x0002)
+ rdp_in_coord(s, &os->y, delta);
+
+ if (present & 0x0004)
+ rdp_in_coord(s, &os->cx, delta);
+
+ if (present & 0x0008)
+ rdp_in_coord(s, &os->cy, delta);
+
+ if (present & 0x0010)
+ in_uint8(s, os->opcode);
+
+ if (present & 0x0020)
+ rdp_in_colour(s, &os->bgcolour);
+
+ if (present & 0x0040)
+ rdp_in_colour(s, &os->fgcolour);
+
+ rdp_parse_brush(s, &os->brush, present >> 7);
+
+ DEBUG(("PATBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,bs=%d,bg=0x%x,fg=0x%x)\n", os->opcode, os->x,
+ os->y, os->cx, os->cy, os->brush.style, os->bgcolour, os->fgcolour));
+
+ ui_patblt(ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy,
+ &os->brush, os->bgcolour, os->fgcolour);
+}
+
+/* Process a screen blt order */
+static void
+process_screenblt(STREAM s, SCREENBLT_ORDER * os, uint32 present, BOOL delta)
+{
+ if (present & 0x0001)
+ rdp_in_coord(s, &os->x, delta);
+
+ if (present & 0x0002)
+ rdp_in_coord(s, &os->y, delta);
+
+ if (present & 0x0004)
+ rdp_in_coord(s, &os->cx, delta);
+
+ if (present & 0x0008)
+ rdp_in_coord(s, &os->cy, delta);
+
+ if (present & 0x0010)
+ in_uint8(s, os->opcode);
+
+ if (present & 0x0020)
+ rdp_in_coord(s, &os->srcx, delta);
+
+ if (present & 0x0040)
+ rdp_in_coord(s, &os->srcy, delta);
+
+ DEBUG(("SCREENBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,srcx=%d,srcy=%d)\n",
+ os->opcode, os->x, os->y, os->cx, os->cy, os->srcx, os->srcy));
+
+ ui_screenblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, os->srcx, os->srcy);
+}
+
+/* Process a line order */
+static void
+process_line(STREAM s, LINE_ORDER * os, uint32 present, BOOL delta)
+{
+ if (present & 0x0001)
+ in_uint16_le(s, os->mixmode);
+
+ if (present & 0x0002)
+ rdp_in_coord(s, &os->startx, delta);
+
+ if (present & 0x0004)
+ rdp_in_coord(s, &os->starty, delta);
+
+ if (present & 0x0008)
+ rdp_in_coord(s, &os->endx, delta);
+
+ if (present & 0x0010)
+ rdp_in_coord(s, &os->endy, delta);
+
+ if (present & 0x0020)
+ rdp_in_colour(s, &os->bgcolour);
+
+ if (present & 0x0040)
+ in_uint8(s, os->opcode);
+
+ rdp_parse_pen(s, &os->pen, present >> 7);
+
+ DEBUG(("LINE(op=0x%x,sx=%d,sy=%d,dx=%d,dx=%d,fg=0x%x)\n",
+ os->opcode, os->startx, os->starty, os->endx, os->endy, os->pen.colour));
+
+ if (os->opcode < 0x01 || os->opcode > 0x10)
+ {
+ error("bad ROP2 0x%x\n", os->opcode);
+ return;
+ }
+
+ ui_line(os->opcode - 1, os->startx, os->starty, os->endx, os->endy, &os->pen);
+}
+
+/* Process an opaque rectangle order */
+static void
+process_rect(STREAM s, RECT_ORDER * os, uint32 present, BOOL delta)
+{
+ uint32 i;
+ if (present & 0x01)
+ rdp_in_coord(s, &os->x, delta);
+
+ if (present & 0x02)
+ rdp_in_coord(s, &os->y, delta);
+
+ if (present & 0x04)
+ rdp_in_coord(s, &os->cx, delta);
+
+ if (present & 0x08)
+ rdp_in_coord(s, &os->cy, delta);
+
+ if (present & 0x10)
+ {
+ in_uint8(s, i);
+ os->colour = (os->colour & 0xffffff00) | i;
+ }
+
+ if (present & 0x20)
+ {
+ in_uint8(s, i);
+ os->colour = (os->colour & 0xffff00ff) | (i << 8);
+ }
+
+ if (present & 0x40)
+ {
+ in_uint8(s, i);
+ os->colour = (os->colour & 0xff00ffff) | (i << 16);
+ }
+
+ DEBUG(("RECT(x=%d,y=%d,cx=%d,cy=%d,fg=0x%x)\n", os->x, os->y, os->cx, os->cy, os->colour));
+
+ ui_rect(os->x, os->y, os->cx, os->cy, os->colour);
+}
+
+/* Process a desktop save order */
+static void
+process_desksave(STREAM s, DESKSAVE_ORDER * os, uint32 present, BOOL delta)
+{
+ int width, height;
+
+ if (present & 0x01)
+ in_uint32_le(s, os->offset);
+
+ if (present & 0x02)
+ rdp_in_coord(s, &os->left, delta);
+
+ if (present & 0x04)
+ rdp_in_coord(s, &os->top, delta);
+
+ if (present & 0x08)
+ rdp_in_coord(s, &os->right, delta);
+
+ if (present & 0x10)
+ rdp_in_coord(s, &os->bottom, delta);
+
+ if (present & 0x20)
+ in_uint8(s, os->action);
+
+ DEBUG(("DESKSAVE(l=%d,t=%d,r=%d,b=%d,off=%d,op=%d)\n",
+ os->left, os->top, os->right, os->bottom, os->offset, os->action));
+
+ width = os->right - os->left + 1;
+ height = os->bottom - os->top + 1;
+
+ if (os->action == 0)
+ ui_desktop_save(os->offset, os->left, os->top, width, height);
+ else
+ ui_desktop_restore(os->offset, os->left, os->top, width, height);
+}
+
+/* Process a memory blt order */
+static void
+process_memblt(STREAM s, MEMBLT_ORDER * os, uint32 present, BOOL delta)
+{
+ HBITMAP bitmap;
+
+ if (present & 0x0001)
+ {
+ in_uint8(s, os->cache_id);
+ in_uint8(s, os->colour_table);
+ }
+
+ if (present & 0x0002)
+ rdp_in_coord(s, &os->x, delta);
+
+ if (present & 0x0004)
+ rdp_in_coord(s, &os->y, delta);
+
+ if (present & 0x0008)
+ rdp_in_coord(s, &os->cx, delta);
+
+ if (present & 0x0010)
+ rdp_in_coord(s, &os->cy, delta);
+
+ if (present & 0x0020)
+ in_uint8(s, os->opcode);
+
+ if (present & 0x0040)
+ rdp_in_coord(s, &os->srcx, delta);
+
+ if (present & 0x0080)
+ rdp_in_coord(s, &os->srcy, delta);
+
+ if (present & 0x0100)
+ in_uint16_le(s, os->cache_idx);
+
+ DEBUG(("MEMBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d)\n",
+ os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx));
+
+ bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);
+ if (bitmap == NULL)
+ return;
+
+ ui_memblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, bitmap, os->srcx, os->srcy);
+}
+
+/* Process a 3-way blt order */
+static void
+process_triblt(STREAM s, TRIBLT_ORDER * os, uint32 present, BOOL delta)
+{
+ HBITMAP bitmap;
+
+ if (present & 0x000001)
+ {
+ in_uint8(s, os->cache_id);
+ in_uint8(s, os->colour_table);
+ }
+
+ if (present & 0x000002)
+ rdp_in_coord(s, &os->x, delta);
+
+ if (present & 0x000004)
+ rdp_in_coord(s, &os->y, delta);
+
+ if (present & 0x000008)
+ rdp_in_coord(s, &os->cx, delta);
+
+ if (present & 0x000010)
+ rdp_in_coord(s, &os->cy, delta);
+
+ if (present & 0x000020)
+ in_uint8(s, os->opcode);
+
+ if (present & 0x000040)
+ rdp_in_coord(s, &os->srcx, delta);
+
+ if (present & 0x000080)
+ rdp_in_coord(s, &os->srcy, delta);
+
+ if (present & 0x000100)
+ rdp_in_colour(s, &os->bgcolour);
+
+ if (present & 0x000200)
+ rdp_in_colour(s, &os->fgcolour);
+
+ rdp_parse_brush(s, &os->brush, present >> 10);
+
+ if (present & 0x008000)
+ in_uint16_le(s, os->cache_idx);
+
+ if (present & 0x010000)
+ in_uint16_le(s, os->unknown);
+
+ DEBUG(("TRIBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
+ os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx,
+ os->brush.style, os->bgcolour, os->fgcolour));
+
+ bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);
+ if (bitmap == NULL)
+ return;
+
+ ui_triblt(os->opcode, os->x, os->y, os->cx, os->cy,
+ bitmap, os->srcx, os->srcy, &os->brush, os->bgcolour, os->fgcolour);
+}
+
+/* Parse a delta co-ordinate in polyline order form */
+static int
+parse_delta(uint8 * buffer, int *offset)
+{
+ int value = buffer[(*offset)++];
+ int two_byte = value & 0x80;
+
+ if (value & 0x40) /* sign bit */
+ value |= ~0x3f;
+ else
+ value &= 0x3f;
+
+ if (two_byte)
+ value = (value << 8) | buffer[(*offset)++];
+
+ return value;
+}
+
+/* Process a polyline order */
+static void
+process_polyline(STREAM s, POLYLINE_ORDER * os, uint32 present, BOOL delta)
+{
+ int index, line, data;
+ int x, y, xfrom, yfrom;
+ uint8 flags = 0;
+ PEN pen;
+ uint8 opcode;
+
+ if (present & 0x01)
+ rdp_in_coord(s, &os->x, delta);
+
+ if (present & 0x02)
+ rdp_in_coord(s, &os->y, delta);
+
+ if (present & 0x04)
+ in_uint8(s, os->opcode);
+
+ if (present & 0x10)
+ rdp_in_colour(s, &os->fgcolour);
+
+ if (present & 0x20)
+ in_uint8(s, os->lines);
+
+ if (present & 0x40)
+ {
+ in_uint8(s, os->datasize);
+ in_uint8a(s, os->data, os->datasize);
+ }
+
+ DEBUG(("POLYLINE(x=%d,y=%d,op=0x%x,fg=0x%x,n=%d,sz=%d)\n",
+ os->x, os->y, os->opcode, os->fgcolour, os->lines, os->datasize));
+
+ DEBUG(("Data: "));
+
+ for (index = 0; index < os->datasize; index++)
+ DEBUG(("%02x ", os->data[index]));
+
+ DEBUG(("\n"));
+
+ if (os->opcode < 0x01 || os->opcode > 0x10)
+ {
+ error("bad ROP2 0x%x\n", os->opcode);
+ return;
+ }
+
+ opcode = os->opcode - 1;
+ x = os->x;
+ y = os->y;
+ pen.style = pen.width = 0;
+ pen.colour = os->fgcolour;
+
+ index = 0;
+ data = ((os->lines - 1) / 4) + 1;
+ for (line = 0; (line < os->lines) && (data < os->datasize); line++)
+ {
+ xfrom = x;
+ yfrom = y;
+
+ if (line % 4 == 0)
+ flags = os->data[index++];
+
+ if ((flags & 0xc0) == 0)
+ flags |= 0xc0; /* none = both */
+
+ if (flags & 0x40)
+ x += parse_delta(os->data, &data);
+
+ if (flags & 0x80)
+ y += parse_delta(os->data, &data);
+
+ ui_line(opcode, xfrom, yfrom, x, y, &pen);
+
+ flags <<= 2;
+ }
+}
+
+/* Process a text order */
+static void
+process_text2(STREAM s, TEXT2_ORDER * os, uint32 present, BOOL delta)
+{
+ int i;
+
+ if (present & 0x000001)
+ in_uint8(s, os->font);
+
+ if (present & 0x000002)
+ in_uint8(s, os->flags);
+
+ if (present & 0x000004)
+ in_uint8(s, os->unknown);
+
+ if (present & 0x000008)
+ in_uint8(s, os->mixmode);
+
+ if (present & 0x000010)
+ rdp_in_colour(s, &os->fgcolour);
+
+ if (present & 0x000020)
+ rdp_in_colour(s, &os->bgcolour);
+
+ if (present & 0x000040)
+ in_uint16_le(s, os->clipleft);
+
+ if (present & 0x000080)
+ in_uint16_le(s, os->cliptop);
+
+ if (present & 0x000100)
+ in_uint16_le(s, os->clipright);
+
+ if (present & 0x000200)
+ in_uint16_le(s, os->clipbottom);
+
+ if (present & 0x000400)
+ in_uint16_le(s, os->boxleft);
+
+ if (present & 0x000800)
+ in_uint16_le(s, os->boxtop);
+
+ if (present & 0x001000)
+ in_uint16_le(s, os->boxright);
+
+ if (present & 0x002000)
+ in_uint16_le(s, os->boxbottom);
+
+ if (present & 0x004000) /* fix for connecting to a server that */
+ in_uint8s(s, 10); /* was disconnected with mstsc.exe */
+ /* 0x008000, 0x020000, and 0x040000 are present too ??? */
+
+ if (present & 0x080000)
+ in_uint16_le(s, os->x);
+
+ if (present & 0x100000)
+ in_uint16_le(s, os->y);
+
+ if (present & 0x200000)
+ {
+ in_uint8(s, os->length);
+ in_uint8a(s, os->text, os->length);
+ }
+
+ DEBUG(("TEXT2(x=%d,y=%d,cl=%d,ct=%d,cr=%d,cb=%d,bl=%d,bt=%d,bb=%d,br=%d,fg=0x%x,bg=0x%x,font=%d,fl=0x%x,mix=%d,unk=0x%x,n=%d)\n", os->x, os->y, os->clipleft, os->cliptop, os->clipright, os->clipbottom, os->boxleft, os->boxtop, os->boxright, os->boxbottom, os->fgcolour, os->bgcolour, os->font, os->flags, os->mixmode, os->unknown, os->length));
+
+ DEBUG(("Text: "));
+
+ for (i = 0; i < os->length; i++)
+ DEBUG(("%02x ", os->text[i]));
+
+ DEBUG(("\n"));
+
+ ui_draw_text(os->font, os->flags, os->mixmode, os->x, os->y,
+ os->clipleft, os->cliptop,
+ os->clipright - os->clipleft,
+ os->clipbottom - os->cliptop,
+ os->boxleft, os->boxtop,
+ os->boxright - os->boxleft,
+ os->boxbottom - os->boxtop, os->bgcolour, os->fgcolour, os->text, os->length);
+}
+
+/* Process a raw bitmap cache order */
+static void
+process_raw_bmpcache(STREAM s)
+{
+ HBITMAP bitmap;
+ uint16 cache_idx, bufsize;
+ uint8 cache_id, width, height, bpp, Bpp;
+ uint8 *data, *inverted;
+ int y;
+
+ in_uint8(s, cache_id);
+ in_uint8s(s, 1); /* pad */
+ in_uint8(s, width);
+ in_uint8(s, height);
+ in_uint8(s, bpp);
+ Bpp = (bpp + 7) / 8;
+ in_uint16_le(s, bufsize);
+ in_uint16_le(s, cache_idx);
+ in_uint8p(s, data, bufsize);
+
+ DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));
+ inverted = (uint8*)xmalloc(width * height * Bpp);
+ for (y = 0; y < height; y++)
+ {
+ memcpy(&inverted[(height - y - 1) * (width * Bpp)], &data[y * (width * Bpp)],
+ width * Bpp);
+ }
+
+ bitmap = ui_create_bitmap(width, height, inverted);
+ xfree(inverted);
+ cache_put_bitmap(cache_id, cache_idx, bitmap);
+}
+
+/* Process a bitmap cache order */
+static void
+process_bmpcache(STREAM s)
+{
+ HBITMAP bitmap;
+ uint16 cache_idx, size;
+ uint8 cache_id, width, height, bpp, Bpp;
+ uint8 *data, *bmpdata;
+
+ in_uint8(s, cache_id);
+ in_uint8s(s, 1); /* pad */
+ in_uint8(s, width);
+ in_uint8(s, height);
+ in_uint8(s, bpp);
+ Bpp = (bpp + 7) / 8;
+ in_uint8s(s, 2); /* bufsize */
+ in_uint16_le(s, cache_idx);
+ in_uint8s(s, 2); /* pad */
+ in_uint16_le(s, size);
+ in_uint8s(s, 4); /* row_size, final_size */
+ in_uint8p(s, data, size);
+ DEBUG(("BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));
+ bmpdata = (uint8*)xmalloc(width * height * Bpp);
+ if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
+ {
+ bitmap = ui_create_bitmap(width, height, bmpdata);
+ cache_put_bitmap(cache_id, cache_idx, bitmap);
+ }
+ xfree(bmpdata);
+}
+
+/* Process a colourmap cache order */
+static void
+process_colcache(STREAM s)
+{
+ COLOURENTRY *entry;
+ COLOURMAP map;
+ HCOLOURMAP hmap;
+ uint8 cache_id;
+ int i;
+ in_uint8(s, cache_id);
+ in_uint16_le(s, map.ncolours);
+
+ map.colours = (COLOURENTRY*)xmalloc(3 * map.ncolours);
+
+ for (i = 0; i < map.ncolours; i++)
+ {
+ entry = &map.colours[i];
+ in_uint8(s, entry->blue);
+ in_uint8(s, entry->green);
+ in_uint8(s, entry->red);
+ in_uint8s(s, 1); /* pad */
+ }
+
+ DEBUG(("COLCACHE(id=%d,n=%d)\n", cache_id, map.ncolours));
+
+ hmap = ui_create_colourmap(&map);
+ ui_set_colourmap(hmap);
+
+ xfree(map.colours);
+}
+
+/* Process a font cache order */
+static void
+process_fontcache(STREAM s)
+{
+ HGLYPH bitmap;
+ uint8 font, nglyphs;
+ uint16 character, offset, baseline, width, height;
+ int i, datasize;
+ uint8 *data;
+
+ in_uint8(s, font);
+ in_uint8(s, nglyphs);
+
+ DEBUG(("FONTCACHE(font=%d,n=%d)\n", font, nglyphs));
+
+ for (i = 0; i < nglyphs; i++)
+ {
+ in_uint16_le(s, character);
+ in_uint16_le(s, offset);
+ in_uint16_le(s, baseline);
+ in_uint16_le(s, width);
+ in_uint16_le(s, height);
+
+ datasize = (height * ((width + 7) / 8) + 3) & ~3;
+ in_uint8p(s, data, datasize);
+
+ bitmap = ui_create_glyph(width, height, data);
+ cache_put_font(font, character, offset, baseline, width, height, bitmap);
+ }
+}
+
+/* Process a secondary order */
+static void
+process_secondary_order(STREAM s)
+{
+ uint16 length;
+ uint8 type;
+ uint8 *next_order;
+
+ in_uint16_le(s, length);
+ in_uint8s(s, 2); /* flags */
+ in_uint8(s, type);
+
+ next_order = s->p + length + 7;
+
+ switch (type)
+ {
+ case RDP_ORDER_RAW_BMPCACHE:
+ process_raw_bmpcache(s);
+ break;
+
+ case RDP_ORDER_COLCACHE:
+ process_colcache(s);
+ break;
+
+ case RDP_ORDER_BMPCACHE:
+ process_bmpcache(s);
+ break;
+
+ case RDP_ORDER_FONTCACHE:
+ process_fontcache(s);
+ break;
+
+ default:
+ unimpl("secondary order %d\n", type);
+ }
+
+ s->p = next_order;
+}
+
+/* Process an order PDU */
+void
+process_orders(STREAM s)
+{
+ RDP_ORDER_STATE *os = &order_state;
+ uint32 present;
+ uint16 num_orders;
+ uint8 order_flags;
+ int size, processed = 0;
+ BOOL delta;
+
+ in_uint8s(s, 2); /* pad */
+ in_uint16_le(s, num_orders);
+ in_uint8s(s, 2); /* pad */
+
+ 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:
+ 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_POLYLINE:
+ process_polyline(s, &os->polyline, 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 (s->p != next_packet)
+ error("%d bytes remaining\n", (int) (next_packet - s->p));
+}
+
+/* Reset order state */
+void
+reset_order_state(void)
+{
+ memset(&order_state, 0, sizeof(order_state));
+ order_state.order_type = RDP_ORDER_PATBLT;
+}
diff --git a/noncore/net/opierdesktop/orders.h b/noncore/net/opierdesktop/orders.h
new file mode 100644
index 0000000..be862c6
--- a/dev/null
+++ b/noncore/net/opierdesktop/orders.h
@@ -0,0 +1,286 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ RDP order processing
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#define RDP_ORDER_STANDARD 0x01
+#define RDP_ORDER_SECONDARY 0x02
+#define RDP_ORDER_BOUNDS 0x04
+#define RDP_ORDER_CHANGE 0x08
+#define RDP_ORDER_DELTA 0x10
+#define RDP_ORDER_LASTBOUNDS 0x20
+#define RDP_ORDER_SMALL 0x40
+#define RDP_ORDER_TINY 0x80
+
+enum RDP_ORDER_TYPE
+{
+ RDP_ORDER_DESTBLT = 0,
+ RDP_ORDER_PATBLT = 1,
+ RDP_ORDER_SCREENBLT = 2,
+ RDP_ORDER_LINE = 9,
+ RDP_ORDER_RECT = 10,
+ RDP_ORDER_DESKSAVE = 11,
+ RDP_ORDER_MEMBLT = 13,
+ RDP_ORDER_TRIBLT = 14,
+ RDP_ORDER_POLYLINE = 22,
+ RDP_ORDER_TEXT2 = 27
+};
+
+enum RDP_SECONDARY_ORDER_TYPE
+{
+ RDP_ORDER_RAW_BMPCACHE = 0,
+ RDP_ORDER_COLCACHE = 1,
+ RDP_ORDER_BMPCACHE = 2,
+ RDP_ORDER_FONTCACHE = 3
+};
+
+typedef struct _DESTBLT_ORDER
+{
+ sint16 x;
+ sint16 y;
+ sint16 cx;
+ sint16 cy;
+ uint8 opcode;
+
+}
+DESTBLT_ORDER;
+
+typedef struct _PATBLT_ORDER
+{
+ sint16 x;
+ sint16 y;
+ sint16 cx;
+ sint16 cy;
+ uint8 opcode;
+ uint32 bgcolour;
+ uint32 fgcolour;
+ BRUSH brush;
+
+}
+PATBLT_ORDER;
+
+typedef struct _SCREENBLT_ORDER
+{
+ sint16 x;
+ sint16 y;
+ sint16 cx;
+ sint16 cy;
+ uint8 opcode;
+ sint16 srcx;
+ sint16 srcy;
+
+}
+SCREENBLT_ORDER;
+
+typedef struct _LINE_ORDER
+{
+ uint16 mixmode;
+ sint16 startx;
+ sint16 starty;
+ sint16 endx;
+ sint16 endy;
+ uint32 bgcolour;
+ uint8 opcode;
+ PEN pen;
+
+}
+LINE_ORDER;
+
+typedef struct _RECT_ORDER
+{
+ sint16 x;
+ sint16 y;
+ sint16 cx;
+ sint16 cy;
+ uint32 colour;
+
+}
+RECT_ORDER;
+
+typedef struct _DESKSAVE_ORDER
+{
+ uint32 offset;
+ sint16 left;
+ sint16 top;
+ sint16 right;
+ sint16 bottom;
+ uint8 action;
+
+}
+DESKSAVE_ORDER;
+
+typedef struct _TRIBLT_ORDER
+{
+ uint8 colour_table;
+ uint8 cache_id;
+ sint16 x;
+ sint16 y;
+ sint16 cx;
+ sint16 cy;
+ uint8 opcode;
+ sint16 srcx;
+ sint16 srcy;
+ uint32 bgcolour;
+ uint32 fgcolour;
+ BRUSH brush;
+ uint16 cache_idx;
+ uint16 unknown;
+
+}
+TRIBLT_ORDER;
+
+typedef struct _MEMBLT_ORDER
+{
+ uint8 colour_table;
+ uint8 cache_id;
+ sint16 x;
+ sint16 y;
+ sint16 cx;
+ sint16 cy;
+ uint8 opcode;
+ sint16 srcx;
+ sint16 srcy;
+ uint16 cache_idx;
+
+}
+MEMBLT_ORDER;
+
+#define MAX_DATA 256
+
+typedef struct _POLYLINE_ORDER
+{
+ sint16 x;
+ sint16 y;
+ uint8 opcode;
+ uint32 fgcolour;
+ uint8 lines;
+ uint8 datasize;
+ uint8 data[MAX_DATA];
+
+}
+POLYLINE_ORDER;
+
+#define MAX_TEXT 256
+
+typedef struct _TEXT2_ORDER
+{
+ uint8 font;
+ uint8 flags;
+ uint8 mixmode;
+ uint8 unknown;
+ uint32 fgcolour;
+ uint32 bgcolour;
+ sint16 clipleft;
+ sint16 cliptop;
+ sint16 clipright;
+ sint16 clipbottom;
+ sint16 boxleft;
+ sint16 boxtop;
+ sint16 boxright;
+ sint16 boxbottom;
+ sint16 x;
+ sint16 y;
+ uint8 length;
+ uint8 text[MAX_TEXT];
+
+}
+TEXT2_ORDER;
+
+typedef struct _RDP_ORDER_STATE
+{
+ uint8 order_type;
+ BOUNDS bounds;
+
+ DESTBLT_ORDER destblt;
+ PATBLT_ORDER patblt;
+ SCREENBLT_ORDER screenblt;
+ LINE_ORDER line;
+ RECT_ORDER rect;
+ DESKSAVE_ORDER desksave;
+ MEMBLT_ORDER memblt;
+ TRIBLT_ORDER triblt;
+ POLYLINE_ORDER polyline;
+ TEXT2_ORDER text2;
+
+}
+RDP_ORDER_STATE;
+
+typedef struct _RDP_RAW_BMPCACHE_ORDER
+{
+ uint8 cache_id;
+ uint8 pad1;
+ uint8 width;
+ uint8 height;
+ uint8 bpp;
+ uint16 bufsize;
+ uint16 cache_idx;
+ uint8 *data;
+
+}
+RDP_RAW_BMPCACHE_ORDER;
+
+typedef struct _RDP_BMPCACHE_ORDER
+{
+ uint8 cache_id;
+ uint8 pad1;
+ uint8 width;
+ uint8 height;
+ uint8 bpp;
+ uint16 bufsize;
+ uint16 cache_idx;
+ uint16 pad2;
+ uint16 size;
+ uint16 row_size;
+ uint16 final_size;
+ uint8 *data;
+
+}
+RDP_BMPCACHE_ORDER;
+
+#define MAX_GLYPH 32
+
+typedef struct _RDP_FONT_GLYPH
+{
+ uint16 character;
+ uint16 unknown;
+ uint16 baseline;
+ uint16 width;
+ uint16 height;
+ uint8 data[MAX_GLYPH];
+
+}
+RDP_FONT_GLYPH;
+
+#define MAX_GLYPHS 256
+
+typedef struct _RDP_FONTCACHE_ORDER
+{
+ uint8 font;
+ uint8 nglyphs;
+ RDP_FONT_GLYPH glyphs[MAX_GLYPHS];
+
+}
+RDP_FONTCACHE_ORDER;
+
+typedef struct _RDP_COLCACHE_ORDER
+{
+ uint8 cache_id;
+ COLOURMAP map;
+
+}
+RDP_COLCACHE_ORDER;
diff --git a/noncore/net/opierdesktop/parse.h b/noncore/net/opierdesktop/parse.h
new file mode 100644
index 0000000..f54c05f
--- a/dev/null
+++ b/noncore/net/opierdesktop/parse.h
@@ -0,0 +1,108 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Parsing primitives
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+/* Parser state */
+typedef struct stream
+{
+ unsigned char *p;
+ unsigned char *end;
+ unsigned char *data;
+ unsigned int size;
+// unsigned char *next_packet;
+
+
+ /* Offsets of various headers */
+ unsigned char *iso_hdr;
+ unsigned char *mcs_hdr;
+ unsigned char *sec_hdr;
+ unsigned char *rdp_hdr;
+
+}
+ *STREAM;
+
+#define s_push_layer(s,h,n) { (s)->h = (s)->p; (s)->p += n; }
+#define s_pop_layer(s,h) (s)->p = (s)->h;
+#define s_mark_end(s) (s)->end = (s)->p;
+#define s_check(s) ((s)->p <= (s)->end)
+#define s_check_rem(s,n) ((s)->p + n <= (s)->end)
+#define s_check_end(s) ((s)->p == (s)->end)
+
+#if defined(L_ENDIAN) && !defined(NEED_ALIGN)
+#define in_uint16_le(s,v) { v = *(uint16 *)((s)->p); (s)->p += 2; }
+#define in_uint32_le(s,v) { v = *(uint32 *)((s)->p); (s)->p += 4; }
+#define out_uint16_le(s,v) { *(uint16 *)((s)->p) = v; (s)->p += 2; }
+#define out_uint32_le(s,v) { *(uint32 *)((s)->p) = v; (s)->p += 4; }
+
+#else
+#define in_uint16_le(s,v) { v = *((s)->p++); v += *((s)->p++) << 8; }
+#define in_uint32_le(s,v) { in_uint16_le(s,v) \
+ v += *((s)->p++) << 16; v += *((s)->p++) << 24; }
+#define out_uint16_le(s,v) { *((s)->p++) = (v) & 0xff; *((s)->p++) = ((v) >> 8) & 0xff; }
+#define out_uint32_le(s,v) { out_uint16_le(s, (v) & 0xffff); out_uint16_le(s, ((v) >> 16) & 0xffff); }
+#endif
+
+#if defined(B_ENDIAN) && !defined(NEED_ALIGN)
+#define in_uint16_be(s,v) { v = *(uint16 *)((s)->p); (s)->p += 2; }
+#define in_uint32_be(s,v) { v = *(uint32 *)((s)->p); (s)->p += 4; }
+#define out_uint16_be(s,v) { *(uint16 *)((s)->p) = v; (s)->p += 2; }
+#define out_uint32_be(s,v) { *(uint32 *)((s)->p) = v; (s)->p += 4; }
+
+#define B_ENDIAN_PREFERRED
+#define in_uint16(s,v) in_uint16_be(s,v)
+#define in_uint32(s,v) in_uint32_be(s,v)
+#define out_uint16(s,v) out_uint16_be(s,v)
+#define out_uint32(s,v) out_uint32_be(s,v)
+
+#else
+#define next_be(s,v) v = ((v) << 8) + *((s)->p++);
+#define in_uint16_be(s,v) { v = *((s)->p++); next_be(s,v); }
+#define in_uint32_be(s,v) { in_uint16_be(s,v); next_be(s,v); next_be(s,v); }
+#define out_uint16_be(s,v) { *((s)->p++) = ((v) >> 8) & 0xff; *((s)->p++) = (v) & 0xff; }
+#define out_uint32_be(s,v) { out_uint16_be(s, ((v) >> 16) & 0xffff); out_uint16_be(s, (v) & 0xffff); }
+#endif
+
+#ifndef B_ENDIAN_PREFERRED
+#define in_uint16(s,v) in_uint16_le(s,v)
+#define in_uint32(s,v) in_uint32_le(s,v)
+#define out_uint16(s,v) out_uint16_le(s,v)
+#define out_uint32(s,v) out_uint32_le(s,v)
+#endif
+
+#define in_uint8(s,v) v = *((s)->p++);
+#define in_uint8p(s,v,n) { v = (s)->p; (s)->p += n; }
+#define in_uint8a(s,v,n) { memcpy(v,(s)->p,n); (s)->p += n; }
+#define in_uint8s(s,n) (s)->p += n;
+#define out_uint8(s,v) *((s)->p++) = v;
+#define out_uint8p(s,v,n) { memcpy((s)->p,v,n); (s)->p += n; }
+#define out_uint8a(s,v,n) out_uint8p(s,v,n);
+#define out_uint8s(s,n) { memset((s)->p,0,n); (s)->p += n; }
+
+#if defined(B_ENDIAN)
+
+#endif
+#if defined(B_ENDIAN_PREFERRED)
+
+#endif
+#if defined(NEED_ALIGN)
+
+#endif
+#if defined(L_ENDIAN)
+
+#endif
diff --git a/noncore/net/opierdesktop/proto.h b/noncore/net/opierdesktop/proto.h
new file mode 100644
index 0000000..6bc5b13
--- a/dev/null
+++ b/noncore/net/opierdesktop/proto.h
@@ -0,0 +1,121 @@
+/* bitmap.c */
+BOOL bitmap_decompress(unsigned char *output, int width, int height, unsigned char *input, int size,
+ int Bpp);
+/* cache.c */
+HBITMAP cache_get_bitmap(uint8 cache_id, uint16 cache_idx);
+void cache_put_bitmap(uint8 cache_id, uint16 cache_idx, HBITMAP bitmap);
+FONTGLYPH *cache_get_font(uint8 font, uint16 character);
+void cache_put_font(uint8 font, uint16 character, uint16 offset, uint16 baseline, uint16 width,
+ uint16 height, 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);
+HCURSOR cache_get_cursor(uint16 cache_idx);
+void cache_put_cursor(uint16 cache_idx, HCURSOR cursor);
+/* ewmhints.c */
+int get_current_workarea(uint32 * x, uint32 * y, uint32 * width, uint32 * height);
+/* iso.c */
+STREAM iso_init(int length);
+void iso_send(STREAM s);
+STREAM iso_recv(void);
+BOOL iso_connect(char *server);
+void iso_disconnect(void);
+/* licence.c */
+void licence_process(STREAM s);
+/* mcs.c */
+STREAM mcs_init(int length);
+void mcs_send(STREAM s);
+STREAM mcs_recv(void);
+BOOL mcs_connect(char *server, STREAM mcs_data);
+void mcs_disconnect(void);
+/* orders.c */
+void process_orders(STREAM s);
+void reset_order_state(void);
+/* rdesktop.c */
+int main(int argc, char *argv[]);
+void generate_random(uint8 * random);
+void *xmalloc(int size);
+void *xrealloc(void *oldmem, int 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);
+int load_licence(unsigned char **data);
+void save_licence(unsigned char *data, int length);
+/* rdp.c */
+void rdp_out_unistr(STREAM s, char *string, int len);
+void rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags, uint16 param1,
+ uint16 param2);
+BOOL rdp_main_loop(void);
+BOOL rdp_connect(char *server, uint32 flags, char *domain, char *password, char *command,
+ char *directory);
+void rdp_disconnect(void);
+/* secure.c */
+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);
+STREAM sec_init(uint32 flags, int maxlen);
+void sec_send(STREAM s, uint32 flags);
+STREAM sec_recv(void);
+BOOL sec_connect(char *server);
+void sec_disconnect(void);
+/* tcp.c */
+STREAM tcp_init(unsigned int maxlen);
+void tcp_send(STREAM s);
+STREAM tcp_recv(unsigned int length);
+BOOL tcp_connect(char *server);
+void tcp_disconnect(void);
+/* xkeymap.c */
+void xkeymap_init(void);
+BOOL handle_special_keys(uint32 keysym, unsigned int state, uint32 ev_time, BOOL pressed);
+key_translation xkeymap_translate_key(uint32 keysym, unsigned int keycode, unsigned int state);
+uint16 xkeymap_translate_button(unsigned int button);
+char *get_ksname(uint32 keysym);
+void ensure_remote_modifiers(uint32 ev_time, key_translation tr);
+void reset_modifier_keys(unsigned int state);
+void rdp_send_scancode(uint32 time, uint16 flags, uint8 scancode);
+/* xwin.c */
+BOOL get_key_state(unsigned int state, uint32 keysym);
+BOOL ui_init(void);
+void ui_deinit(void);
+BOOL ui_create_window(void);
+void ui_destroy_window(void);
+void xwin_toggle_fullscreen(void);
+int ui_select(int rdp_socket);
+void ui_move_pointer(int x, int y);
+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(HBITMAP bmp);
+HGLYPH ui_create_glyph(int width, int height, uint8 * data);
+void ui_destroy_glyph(HGLYPH glyph);
+HCURSOR ui_create_cursor(unsigned int x, unsigned int y, int width, int height, uint8 * andmask,
+ uint8 * xormask);
+void ui_set_cursor(HCURSOR cursor);
+void ui_destroy_cursor(HCURSOR cursor);
+HCOLOURMAP ui_create_colourmap(COLOURMAP * colours);
+void ui_destroy_colourmap(HCOLOURMAP map);
+void ui_set_colourmap(HCOLOURMAP map);
+void ui_begin_update(void);
+void ui_end_update(void);
+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, HBITMAP src, int srcx, int srcy);
+void ui_triblt(uint8 opcode, int x, int y, int cx, int cy, 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_draw_text(uint8 font, uint8 flags, int mixmode, int x, int y, int clipx, int clipy,
+ int clipcx, int clipcy, int boxx, int boxy, int boxcx, int boxcy, 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);
diff --git a/noncore/net/opierdesktop/qtwin.cpp b/noncore/net/opierdesktop/qtwin.cpp
new file mode 100644
index 0000000..d2a5ef1
--- a/dev/null
+++ b/noncore/net/opierdesktop/qtwin.cpp
@@ -0,0 +1,1725 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ User interface services - X Window System
+ Copyright (C) Matthew Chapman 1999-2002
+ qt.cpp by Jay Sorg
+
+ 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.
+*/
+
+#include "rdesktop.h"
+#ifdef SHARP
+#include <qpe/qpeapplication.h>
+#else
+#include <qapplication.h>
+#endif
+#include <qmainwindow.h>
+#include <qwidget.h>
+#include <qpainter.h>
+#include <qimage.h>
+#include <qsocketnotifier.h>
+#include <qscrollview.h>
+#include <qmessagebox.h>
+#include <qpushbutton.h>
+#include <qlineedit.h>
+#include <qcombobox.h>
+#include <qlabel.h>
+#include <qfile.h>
+#include <qcheckbox.h>
+#include <qpopupmenu.h>
+#include "qtwin.h"
+#include <stdlib.h>
+
+uint32 flags;
+char server[64] = "";
+char domain[16] = "";
+char password[16] = "";
+char shell[128] = "";
+char directory[32] = "";
+
+extern int g_width;
+extern int g_height;
+extern int server_bpp;
+extern BOOL fullscreen;
+extern char username[];
+int global_sock;
+
+QSocketNotifier* SocketNotifier;
+#ifdef SHARP
+QPEApplication* App;
+#else
+QApplication* App;
+#endif
+QMyMainWindow* MW;
+QMyScrollView* SV;
+struct QColorMap
+{
+ uint32 RGBColors[256];
+ int NumColors;
+};
+QColorMap* CM;
+uint8* BS;
+int clipx;
+int clipy;
+int clipcx;
+int clipcy;
+
+struct bitmap
+{
+ int w;
+ int h;
+ uint8* data;
+};
+
+BOOL owncolmap = False;
+
+//*****************************************************************************
+void CleanString(QString* Item)
+{
+ int i;
+
+ i = Item->length() - 1;
+ while (i >= 0)
+ {
+ if (Item->at(i) == 10 || Item->at(i) == 13)
+ Item->remove(i, 1);
+ i--;
+ }
+}
+
+//*****************************************************************************
+QMyDialog::QMyDialog(QWidget* parent) : QDialog(parent, "Settings", true)
+{
+ int i, j;
+ char* home;
+ char Text[256];
+ QString Line;
+ QString ItemName;
+ QString ItemValue;
+
+ // resize dialog
+ resize(230, 270);
+ // main list box
+ ListBox = new QListBox(this);
+ ListBox->move(10, 10);
+ ListBox->resize(200, 100);
+ connect(ListBox, SIGNAL(selectionChanged()), this, SLOT(ListBoxChanged()));
+ connect(ListBox, SIGNAL(selected(int)), this, SLOT(ListBoxSelected(int)));
+ // server
+ Label1 = new QLabel(this);
+ Label1->setText("Server Desc");
+ Label1->move(10, 120);
+ Label1->resize(100, 20);
+ ServerNameEdit = new QLineEdit(this);
+ ServerNameEdit->move(75, 120);
+ ServerNameEdit->resize(100, 20);
+ // username
+ Label2 = new QLabel(this);
+ Label2->setText("User Name");
+ Label2->move(10, 150);
+ Label2->resize(100, 20);
+ UserNameEdit = new QLineEdit(this);
+ UserNameEdit->move(75, 150);
+ UserNameEdit->resize(100, 20);
+ // ip
+ Label3 = new QLabel(this);
+ Label3->setText("Server IP");
+ Label3->move(10, 180);
+ Label3->resize(100, 20);
+ IPEdit = new QLineEdit(this);
+ IPEdit->move(75, 180);
+ IPEdit->resize(100, 20);
+ // width and height
+ WidthHeightBox = new QComboBox(this);
+ WidthHeightBox->move(10, 210);
+ WidthHeightBox->resize(100, 20);
+ WidthHeightBox->insertItem("240x320");
+ WidthHeightBox->insertItem("640x480");
+ WidthHeightBox->insertItem("800x600");
+ connect(WidthHeightBox, SIGNAL(activated(int)), this, SLOT(ComboChanged(int)));
+ WidthHeightBox->setCurrentItem(1);
+ WidthEdit = new QLineEdit(this);
+ WidthEdit->move(110, 210);
+ WidthEdit->resize(30, 20);
+ WidthEdit->setText("800");
+ HeightEdit = new QLineEdit(this);
+ HeightEdit->move(140, 210);
+ HeightEdit->resize(30, 20);
+ HeightEdit->setText("600");
+ // add to list button
+ AddButton = new QPushButton(this);
+ AddButton->move(180, 120);
+ AddButton->resize(50, 20);
+ AddButton->setText("Add");
+ connect(AddButton, SIGNAL(clicked()), this, SLOT(AddClicked()));
+ // change list item button
+ EditButton = new QPushButton(this);
+ EditButton->move(180, 140);
+ EditButton->resize(50, 20);
+ EditButton->setText("Edit");
+ connect(EditButton, SIGNAL(clicked()), this, SLOT(EditClicked()));
+ // save to file button
+ SaveButton = new QPushButton(this);
+ SaveButton->move(180, 160);
+ SaveButton->resize(50, 20);
+ SaveButton->setText("Save");
+ connect(SaveButton, SIGNAL(clicked()), this, SLOT(SaveClicked()));
+ // remove an item button
+ RemoveButton = new QPushButton(this);
+ RemoveButton->move(180, 180);
+ RemoveButton->resize(50, 20);
+ RemoveButton->setText("Remove");
+ connect(RemoveButton, SIGNAL(clicked()), this, SLOT(RemoveClicked()));
+ // full screen check box
+ FullScreenCheckBox = new QCheckBox(this, "Full Screen");
+ FullScreenCheckBox->setText("Full Screen");
+ FullScreenCheckBox->move(10, 230);
+ // ok button
+ OKButton = new QPushButton(this);
+ OKButton->setText("OK");
+ OKButton->move(100, 240);
+ OKButton->resize(50, 20);
+ connect(OKButton, SIGNAL(clicked()), this, SLOT(OKClicked()));
+ // cancel button
+ CancelButton = new QPushButton(this);
+ CancelButton->setText("Cancel");
+ CancelButton->move(160, 240);
+ CancelButton->resize(50, 20);
+ connect(CancelButton, SIGNAL(clicked()), this, SLOT(CancelClicked()));
+
+ for (i = 0; i < 10; i++)
+ {
+ ConnectionList[i] = new QMyConnectionItem;
+ ConnectionList[i]->ServerName = "";
+ ConnectionList[i]->UserName = "";
+ ConnectionList[i]->ServerIP = "";
+ ConnectionList[i]->Width = 0;
+ ConnectionList[i]->Height = 0;
+ ConnectionList[i]->FullScreen = 0;
+ }
+ home = getenv("HOME");
+ if (home != NULL)
+ {
+ sprintf(Text, "%s/rdesktop.ini", home);
+ QFile* File = new QFile(Text);
+ if (File->open(IO_ReadOnly))
+ {
+ i = -1;
+ while (!File->atEnd())
+ {
+ File->readLine(Line, 255);
+ j = Line.find("=");
+ if (j > 0)
+ {
+ ItemName = Line.mid(0, j);
+ CleanString(&ItemName);
+ ItemValue = Line.mid(j + 1);
+ CleanString(&ItemValue);
+ if (ItemName == "Server")
+ {
+ i++;
+ ConnectionList[i]->ServerName = ItemValue;
+ ListBox->insertItem(ItemValue);
+ }
+ else if (ItemName == "UserName")
+ ConnectionList[i]->UserName = ItemValue;
+ else if (ItemName == "Width")
+ ConnectionList[i]->Width = ItemValue.toInt();
+ else if (ItemName == "Height")
+ ConnectionList[i]->Height = ItemValue.toInt();
+ else if (ItemName == "IP")
+ ConnectionList[i]->ServerIP = ItemValue;
+ else if (ItemName == "FullScreen")
+ ConnectionList[i]->FullScreen = (ItemValue != "0");
+ }
+ }
+ }
+ delete File;
+ }
+}
+
+//*****************************************************************************
+QMyDialog::~QMyDialog()
+{
+ QMyConnectionItem* Item;
+ int i;
+
+ for (i = 0; i < 10; i++)
+ {
+ Item = ConnectionList[i];
+ delete Item;
+ }
+}
+
+//*****************************************************************************
+void QMyDialog::ComboChanged(int index)
+{
+ if (index == 0)
+ {
+ WidthEdit->setText("240");
+ HeightEdit->setText("320");
+ }
+ if (index == 1)
+ {
+ WidthEdit->setText("640");
+ HeightEdit->setText("480");
+ }
+ else if (index == 2)
+ {
+ WidthEdit->setText("800");
+ HeightEdit->setText("600");
+ }
+}
+
+//*****************************************************************************
+void QMyDialog::OKClicked()
+{
+ ServerName = ServerNameEdit->text();
+ UserName = UserNameEdit->text();
+ Width = WidthEdit->text().toInt();
+ Height = HeightEdit->text().toInt();
+ ServerIP = IPEdit->text();
+ FullScreen = FullScreenCheckBox->isChecked();
+ done(1);
+}
+
+//*****************************************************************************
+void QMyDialog::CancelClicked()
+{
+ done(0);
+}
+
+//*****************************************************************************
+void QMyDialog::AddClicked()
+{
+ int i;
+ QMyConnectionItem* Item;
+
+ i = ListBox->count();
+ if (i < 10)
+ {
+ ListBox->insertItem(ServerNameEdit->text());
+ Item = ConnectionList[i];
+ Item->ServerName = ServerNameEdit->text();
+ Item->UserName = UserNameEdit->text();
+ Item->Width = WidthEdit->text().toInt();
+ Item->Height = HeightEdit->text().toInt();
+ Item->ServerIP = IPEdit->text();
+ Item->FullScreen = FullScreenCheckBox->isChecked();
+ }
+}
+
+//*****************************************************************************
+void QMyDialog::EditClicked()
+{
+ int i;
+ QMyConnectionItem* Item;
+
+ i = ListBox->currentItem();
+ if (i >= 0)
+ {
+ Item = ConnectionList[i];
+ Item->ServerName = ServerNameEdit->text();
+ Item->UserName = UserNameEdit->text();
+ Item->Width = WidthEdit->text().toInt();
+ Item->Height = HeightEdit->text().toInt();
+ Item->ServerIP = IPEdit->text();
+ Item->FullScreen = FullScreenCheckBox->isChecked();
+ ListBox->changeItem(ServerNameEdit->text(), i);
+ }
+}
+
+//*****************************************************************************
+void WriteString(QFile* File, QString* Line)
+{
+ File->writeBlock((const char*)(*Line), Line->length());
+}
+
+//*****************************************************************************
+void QMyDialog::SaveClicked()
+{
+ int i, j;
+ QMyConnectionItem* Item;
+ QString Line;
+ char* home;
+ char Text[256];
+ QFile* File;
+
+ home = getenv("HOME");
+ if (home != NULL)
+ {
+ sprintf(Text, "%s/rdesktop.ini", home);
+ File = new QFile(Text);
+ if (File->open(IO_Truncate | IO_ReadWrite))
+ {
+ i = ListBox->count();
+ for (j = 0; j < i; j++)
+ {
+ Item = ConnectionList[j];
+ Line = "Server=";
+ Line += Item->ServerName;
+ Line += (char)10;
+ WriteString(File, &Line);
+ Line = "UserName=";
+ Line += Item->UserName;
+ Line += (char)10;
+ WriteString(File, &Line);
+ Line = "Width=";
+ sprintf(Text, "%d", Item->Width);
+ Line += Text;
+ Line += (char)10;
+ WriteString(File, &Line);
+ Line = "Height=";
+ sprintf(Text, "%d", Item->Height);
+ Line += Text;
+ Line += (char)10;
+ WriteString(File, &Line);
+ Line = "IP=";
+ Line += Item->ServerIP;
+ Line += (char)10;
+ WriteString(File, &Line);
+ Line = "FullScreen=";
+ if (Item->FullScreen)
+ Line += "1";
+ else
+ Line += "0";
+ Line += (char)10;
+ WriteString(File, &Line);
+ }
+ }
+ File->flush();
+ File->close();
+ delete File;
+ }
+}
+
+//*****************************************************************************
+void QMyDialog::RemoveClicked()
+{
+ int i, j, c;
+ QMyConnectionItem* Item1;
+ QMyConnectionItem* Item2;
+
+ i = ListBox->currentItem();
+ if (i >= 0)
+ {
+ c = ListBox->count();
+ for (j = i; j < c - 1; j++)
+ {
+ Item1 = ConnectionList[i];
+ Item2 = ConnectionList[i + 1];
+ Item1->ServerName = Item2->ServerName;
+ Item1->UserName = Item2->UserName;
+ Item1->Width = Item2->Width;
+ Item1->Height = Item2->Height;
+ Item1->ServerIP = Item2->ServerIP;
+ Item1->FullScreen = Item2->FullScreen;
+ }
+ ListBox->removeItem(i);
+ }
+}
+
+//*****************************************************************************
+void QMyDialog::ListBoxChanged()
+{
+ int i;
+ QMyConnectionItem* Item;
+ char Text[100];
+
+ i = ListBox->currentItem();
+ if (i >= 0 && i < 10)
+ {
+ Item = ConnectionList[i];
+ ServerNameEdit->setText(Item->ServerName);
+ UserNameEdit->setText(Item->UserName);
+ sprintf(Text, "%d", Item->Width);
+ WidthEdit->setText(Text);
+ sprintf(Text, "%d", Item->Height);
+ HeightEdit->setText(Text);
+ IPEdit->setText(Item->ServerIP);
+ FullScreenCheckBox->setChecked(Item->FullScreen != 0);
+ }
+}
+
+//*****************************************************************************
+void QMyDialog::ListBoxSelected(int /*index*/)
+{
+}
+
+//*****************************************************************************
+void GetScanCode(QKeyEvent* e, int* ScanCode, int* code)
+{
+ int key;
+ int mod;
+ int ascii;
+
+ key = e->key();
+ mod = e->state();
+ ascii = e->ascii();
+
+ *ScanCode = 0;
+ *code = mod; // 8 shift, 16 control, 32 alt
+
+ switch (key)
+ {
+ case 4096: // esc
+ case 4097: // tab
+ case 4099: // backspace
+ case 4100: // enter
+ case 4101: // enter
+ case 4103: // delete
+ ascii = 0;
+ }
+
+ if (ascii == 0)
+ {
+ switch (key)
+ {
+ case 4096: *ScanCode = 0x01; break; // esc
+ case 4097: *ScanCode = 0x0f; break; // tab
+ case 4099: *ScanCode = 0x0e; break; // backspace
+ case 4100: *ScanCode = 0x1c; break; // enter
+ case 4101: *ScanCode = 0x1c; break; // enter
+ case 4112: *ScanCode = 0xc7; break; // home
+ case 4113: *ScanCode = 0xcf; break; // end
+ case 4102: *ScanCode = 0xd2; break; // insert
+ case 4103: *ScanCode = 0xd3; break; // delete
+ case 4118: *ScanCode = 0xc9; break; // page up
+ case 4119: *ScanCode = 0xd1; break; // page down
+ case 4117: *ScanCode = 0xd0; break; // down arrow
+ case 4115: *ScanCode = 0xc8; break; // up arrow
+ case 4114: *ScanCode = 0xcb; break; // left arrow
+ case 4116: *ScanCode = 0xcd; break; // right arrow
+ case 4128: *ScanCode = 0x2a; break; // shift
+ case 4131: *ScanCode = 0x38; break; // alt
+ case 4129: *ScanCode = 0x1d; break; // ctrl
+ }
+ if (*ScanCode != 0)
+ return;
+ }
+
+ switch (ascii)
+ {
+ // first row
+ case 'q': *ScanCode = 0x10; break;
+ case 'Q': *ScanCode = 0x10; *code |= 8; break;
+ case '1': *ScanCode = 0x02; break;
+ case 'w': *ScanCode = 0x11; break;
+ case 'W': *ScanCode = 0x11; *code |= 8; break;
+ case '2': *ScanCode = 0x03; break;
+ case 'e': *ScanCode = 0x12; break;
+ case 'E': *ScanCode = 0x12; *code |= 8; break;
+ case '3': *ScanCode = 0x04; break;
+ case 'r': *ScanCode = 0x13; break;
+ case 'R': *ScanCode = 0x13; *code |= 8; break;
+ case '4': *ScanCode = 0x05; break;
+ case 't': *ScanCode = 0x14; break;
+ case 'T': *ScanCode = 0x14; *code |= 8; break;
+ case '5': *ScanCode = 0x06; break;
+ case 'y': *ScanCode = 0x15; break;
+ case 'Y': *ScanCode = 0x15; *code |= 8; break;
+ case '6': *ScanCode = 0x07; break;
+ case 'u': *ScanCode = 0x16; break;
+ case 'U': *ScanCode = 0x16; *code |= 8; break;
+ case '7': *ScanCode = 0x08; break;
+ case 'i': *ScanCode = 0x17; break;
+ case 'I': *ScanCode = 0x17; *code |= 8; break;
+ case '8': *ScanCode = 0x09; break;
+ case 'o': *ScanCode = 0x18; break;
+ case 'O': *ScanCode = 0x18; *code |= 8; break;
+ case '9': *ScanCode = 0x0a; break;
+ case 'p': *ScanCode = 0x19; break;
+ case 'P': *ScanCode = 0x19; *code |= 8; break;
+ case '0': *ScanCode = 0x0b; break;
+ // second row
+ case 'a': *ScanCode = 0x1e; break;
+ case 'A': *ScanCode = 0x1e; *code |= 8; break;
+ case '!': *ScanCode = 0x02; *code |= 8; break;
+ case 's': *ScanCode = 0x1f; break;
+ case 'S': *ScanCode = 0x1f; *code |= 8; break;
+ case '@': *ScanCode = 0x03; *code |= 8; break;
+ case 'd': *ScanCode = 0x20; break;
+ case 'D': *ScanCode = 0x20; *code |= 8; break;
+ case '#': *ScanCode = 0x04; *code |= 8; break;
+ case 'f': *ScanCode = 0x21; break;
+ case 'F': *ScanCode = 0x21; *code |= 8; break;
+ case '$': *ScanCode = 0x05; *code |= 8; break;
+ case 'g': *ScanCode = 0x22; break;
+ case 'G': *ScanCode = 0x22; *code |= 8; break;
+ case '%': *ScanCode = 0x06; *code |= 8; break;
+ case 'h': *ScanCode = 0x23; break;
+ case 'H': *ScanCode = 0x23; *code |= 8; break;
+ case '_': *ScanCode = 0x0c; *code |= 8; break;
+ case 'j': *ScanCode = 0x24; break;
+ case 'J': *ScanCode = 0x24; *code |= 8; break;
+ case '&': *ScanCode = 0x08; *code |= 8; break;
+ case 'k': *ScanCode = 0x25; break;
+ case 'K': *ScanCode = 0x25; *code |= 8; break;
+ case '*': *ScanCode = 0x09; *code |= 8; break;
+ case 'l': *ScanCode = 0x26; break;
+ case 'L': *ScanCode = 0x26; *code |= 8; break;
+ case '(': *ScanCode = 0x0a; *code |= 8; break;
+// case 8: *ScanCode = 0x0e; break; // backspace
+ // third row
+ case 'z': *ScanCode = 0x2c; break;
+ case 'Z': *ScanCode = 0x2c; *code |= 8; break;
+ case 'x': *ScanCode = 0x2d; break;
+ case 'X': *ScanCode = 0x2d; *code |= 8; break;
+ case 'c': *ScanCode = 0x2e; break;
+ case 'C': *ScanCode = 0x2e; *code |= 8; break;
+ case 'v': *ScanCode = 0x2f; break;
+ case 'V': *ScanCode = 0x2f; *code |= 8; break;
+ case 'b': *ScanCode = 0x30; break;
+ case 'B': *ScanCode = 0x30; *code |= 8; break;
+ case '-': *ScanCode = 0x0c; break;
+ case 'n': *ScanCode = 0x31; break;
+ case 'N': *ScanCode = 0x31; *code |= 8; break;
+ case '+': *ScanCode = 0x0d; *code |= 8; break;
+ case 'm': *ScanCode = 0x32; break;
+ case 'M': *ScanCode = 0x32; *code |= 8; break;
+ case '=': *ScanCode = 0x0d; break;
+ case ',': *ScanCode = 0x33; break;
+ case ';': *ScanCode = 0x27; break;
+ case ')': *ScanCode = 0x0b; *code |= 8; break;
+ // fourth row
+// case 9: *ScanCode = 0x0f; break; // tab
+ case '/': *ScanCode = 0x35; break;
+ case '?': *ScanCode = 0x35; *code |= 8; break;
+ case ' ': *ScanCode = 0x39; break;
+ case '\'': *ScanCode = 0x28; break;
+ case '"': *ScanCode = 0x28; *code |= 8; break;
+ case '~': *ScanCode = 0x29; *code |= 8; break;
+ case '.': *ScanCode = 0x34; break;
+ case ':': *ScanCode = 0x27; *code |= 8; break;
+ case '<': *ScanCode = 0x33; *code |= 8; break;
+// case 13: *ScanCode = 0x1c; break; // enter
+ case '>': *ScanCode = 0x34; *code |= 8; break;
+ // others
+// case 27: *ScanCode = 0x01; break; // esc
+ case '`': *ScanCode = 0x29; break;
+ case '^': *ScanCode = 0x07; *code |= 8; break;
+ case '[': *ScanCode = 0x1a; break;
+ case '{': *ScanCode = 0x1a; *code |= 8; break;
+ case ']': *ScanCode = 0x1b; break;
+ case '}': *ScanCode = 0x1b; *code |= 8; break;
+ case '\\': *ScanCode = 0x2b; break;
+ case '|': *ScanCode = 0x2b; *code |= 8; break;
+ // ctrl keys
+ case 1: *ScanCode = 0x1e; *code |= 16; break; // a
+ case 2: *ScanCode = 0x30; *code |= 16; break; // b
+ }
+
+ if (*ScanCode == 0 && key < 3000)
+ printf("unknown key %d mod %d ascii %d\n", key, mod, ascii);
+
+}
+
+//*****************************************************************************
+QMyScrollView::QMyScrollView() : QScrollView()
+{
+}
+
+//*****************************************************************************
+QMyScrollView::~QMyScrollView()
+{
+}
+
+//*****************************************************************************
+void QMyScrollView::keyPressEvent(QKeyEvent* e)
+{
+ int ScanCode, code;
+ GetScanCode(e, &ScanCode, &code);
+ if (ScanCode != 0)
+ {
+ if (code & 8) // send shift
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x2a, 0);
+ if (code & 16) // send control
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x1d, 0);
+ if (code & 32) // send alt
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x38, 0);
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYPRESS, ScanCode, 0);
+ e->accept();
+ }
+}
+
+//*****************************************************************************
+void QMyScrollView::keyReleaseEvent(QKeyEvent* e)
+{
+ int ScanCode, code;
+ GetScanCode(e, &ScanCode, &code);
+ if (ScanCode != 0)
+ {
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, ScanCode, 0);
+ if (code & 8) // send shift
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x2a, 0);
+ if (code & 16) // send control
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x1d, 0);
+ if (code & 32) // send alt
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x38, 0);
+ e->accept();
+ }
+}
+
+//*****************************************************************************
+void QMyScrollView::showEvent(QShowEvent* e)
+{
+ QScrollView::showEvent(e);
+}
+
+//*****************************************************************************
+void QMyScrollView::show()
+{
+ QScrollView::show();
+}
+
+//*****************************************************************************
+void QMyScrollView::polish()
+{
+ QScrollView::polish();
+}
+
+//*****************************************************************************
+void QMyScrollView::timerEvent(QTimerEvent* e)
+{
+ QScrollView::timerEvent(e);
+ killTimer(timer_id);
+ QMyDialog* d;
+ QWidget* Desktop;
+ int dw;
+ int dh;
+
+ d = new QMyDialog(this);
+ if (d->exec() == 1) // ok clicked
+ {
+ flags = RDP_LOGON_NORMAL;
+ g_width = d->Width;
+ g_height = d->Height;
+ fullscreen = d->FullScreen;
+ sprintf(server, "%s", (const char*)d->ServerIP);
+ sprintf(username, "%s", (const char*)d->UserName);
+ if (!rdp_connect(server, flags, domain, password, shell, directory))
+ {
+ delete d;
+ SV->close();
+ return;
+ }
+ BS = (uint8*)xmalloc(g_width * g_height);
+ memset(BS, 0, g_width * g_height);
+ clipx = 0;
+ clipy = 0;
+ clipcx = g_width;
+ clipcy = g_height;
+ CM = (QColorMap*)xmalloc(sizeof(struct QColorMap));
+ memset(CM, 0, sizeof(struct QColorMap));
+ CM->NumColors = 256;
+ MW = new QMyMainWindow();
+ MW->resize(g_width, g_height);
+ MW->show();
+ SV->addChild(MW);
+ MW->setMouseTracking(true);
+ SocketNotifier = new QSocketNotifier(global_sock, QSocketNotifier::Read, MW);
+ MW->connect(SocketNotifier, SIGNAL(activated(int)), MW, SLOT(dataReceived()));
+ if (fullscreen)
+ {
+ Desktop = App->desktop();
+ dw = Desktop->width();
+ dh = Desktop->height();
+ if (dw == g_width && dh == g_height)
+ MW->resize(g_width - 4, g_height - 4);
+ SV->showFullScreen();
+ }
+ delete d;
+ }
+ else // cancel clicked
+ {
+ delete d;
+ SV->close();
+ }
+}
+
+//*****************************************************************************
+QMyMainWindow::QMyMainWindow() : QWidget(SV->viewport())
+{
+ PopupMenu = new QPopupMenu(this);
+ PopupMenu->insertItem("Right click", 1, 0);
+ PopupMenu->insertItem("Toggle fullscreen", 2, 1);
+ PopupMenu->insertItem("Reset keyboard", 3, 2);
+ PopupMenu->insertItem("Double click", 4, 3);
+ connect(PopupMenu, SIGNAL(activated(int)), this, SLOT(MemuClicked(int)));
+}
+
+//*****************************************************************************
+QMyMainWindow::~QMyMainWindow()
+{
+ delete PopupMenu;
+}
+
+//*****************************************************************************
+void QMyMainWindow::timerEvent(QTimerEvent* e)
+{
+ QWidget::timerEvent(e);
+ if (e->timerId() == timer_id)
+ {
+ // send mouse up
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1, mx, my);
+ // if in fullscreen, take it out or the menu won't work
+ if (fullscreen)
+ {
+ fullscreen = 0;
+ SV->showNormal();
+ SV->showMaximized();
+ }
+ else
+ PopupMenu->popup(mapToGlobal(QPoint(mx, my)));
+ }
+ killTimer(timer_id);
+}
+
+//*****************************************************************************
+void QMyMainWindow::MemuClicked(int MenuID)
+{
+ QWidget* Desktop;
+ int dw;
+ int dh;
+
+ if (MenuID == 1) // right click
+ {
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_DOWN | MOUSE_FLAG_BUTTON2, mx, my);
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2, mx, my);
+ }
+ else if (MenuID == 2) // toggle full screen
+ {
+ fullscreen = ~fullscreen;
+ if (fullscreen)
+ {
+ Desktop = App->desktop();
+ dw = Desktop->width();
+ dh = Desktop->height();
+ if (dw == g_width && dh == g_height)
+ MW->resize(g_width - 4, g_height - 4);
+ SV->showFullScreen();
+ }
+ else
+ {
+ SV->showNormal();
+ SV->showMaximized();
+ MW->resize(g_width, g_height);
+ }
+ }
+ else if (MenuID == 3) // reset keyboard
+ {
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x2a, 0); // shift
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x1d, 0); // control
+ rdp_send_input(0, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x38, 0); // alt
+ }
+ else if (MenuID == 4) // double click
+ {
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_DOWN | MOUSE_FLAG_BUTTON1, mx, my);
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1, mx, my);
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_DOWN | MOUSE_FLAG_BUTTON1, mx, my);
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1, mx, my);
+ }
+}
+
+//*****************************************************************************
+void QMyMainWindow::mouseMoveEvent(QMouseEvent* e)
+{
+ int x;
+ int y;
+
+ x = e->x();
+ y = e->y();
+
+ if (timer_id)
+ {
+ x = x - mx;
+ y = y - my;
+ if (x < -10 || x > 10 || y < -10 || y > 10)
+ {
+ killTimer(timer_id);
+ timer_id = 0;
+ }
+ }
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE, e->x(), e->y());
+}
+
+//*****************************************************************************
+void QMyMainWindow::mousePressEvent(QMouseEvent* e)
+{
+ timer_id = startTimer(1000);
+ mx = e->x();
+ my = e->y();
+ if (e->button() == LeftButton)
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_DOWN | MOUSE_FLAG_BUTTON1, e->x(), e->y());
+ else if (e->button() == RightButton)
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_DOWN | MOUSE_FLAG_BUTTON2, e->x(), e->y());
+ else if (e->button() == MidButton)
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_DOWN | MOUSE_FLAG_BUTTON3, e->x(), e->y());
+}
+
+//*****************************************************************************
+void QMyMainWindow::mouseReleaseEvent(QMouseEvent* e)
+{
+ killTimer(timer_id);
+ timer_id = 0;
+ if (e->button() == LeftButton)
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1, e->x(), e->y());
+ else if (e->button() == RightButton)
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2, e->x(), e->y());
+ else if (e->button() == MidButton)
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3, e->x(), e->y());
+}
+
+//*****************************************************************************
+void QMyMainWindow::wheelEvent(QWheelEvent* e)
+{
+ if (e->delta() > 0)
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON4, e->x(), e->y());
+ else if (e->delta() < 0)
+ rdp_send_input(0, RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON5, e->x(), e->y());
+}
+
+#define NOT(x) (255-(x))
+
+//*****************************************************************************
+uint8 rop(int rop, uint8 src, uint8 dst)
+{
+ switch (rop)
+ {
+ case 0x0: return 0;
+ case 0x1: return NOT (src | dst);
+ case 0x2: return NOT (src) & dst;
+ case 0x3: return NOT (src);
+ case 0x4: return src & NOT (dst);
+ case 0x5: return NOT (dst);
+ case 0x6: return src ^ dst;
+ case 0x7: return NOT (src & dst);
+ case 0x8: return src & dst;
+ case 0x9: return NOT (src) ^ dst;
+ case 0xa: return dst;
+ case 0xb: return NOT (src) | dst;
+ case 0xc: return src;
+ case 0xd: return src | NOT (dst);
+ case 0xe: return src | dst;
+ case 0xf: return NOT (0);
+ }
+ return dst;
+}
+
+//*****************************************************************************
+uint8 get_pixel(int x, int y)
+{
+ if (x >= 0 && x < g_width && y >= 0 && y < g_height)
+ return BS[y * g_width + x];
+ else
+ return 0;
+}
+
+//*****************************************************************************
+void set_pixel(int x, int y, uint8 pixel, int op = 0xc)
+{
+ if (x >= clipx && x < (clipx + clipcx) && y >= clipy && y < (clipy + clipcy))
+ if (x >= 0 && x < g_width && y >= 0 && y < g_height)
+ if (op == 0xc)
+ BS[y * g_width + x] = pixel;
+ else
+ BS[y * g_width + x] = rop(op, pixel, BS[y * g_width + x]);
+}
+
+//******************************************************************************
+// adjust coordinates for cliping rect
+bool WarpCoords(int* x, int* y, int* cx, int* cy, int* srcx, int* srcy)
+{
+ int dx, dy;
+ QRect InRect(*x, *y, *cx, *cy);
+ QRect OutRect;
+ QRect CRect(clipx, clipy, clipcx, clipcy);
+ OutRect = InRect.intersect(CRect);
+ if (OutRect.isEmpty())
+ return false;
+ dx = OutRect.x() - InRect.x();
+ dy = OutRect.y() - InRect.y();
+ *x = OutRect.x();
+ *y = OutRect.y();
+ *cx = OutRect.width();
+ *cy = OutRect.height();
+ if (srcx != NULL)
+ *srcx = *srcx + dx;
+ if (srcy != NULL)
+ *srcy = *srcy + dy;
+ return true;
+}
+
+//*****************************************************************************
+void QMyMainWindow::paintEvent(QPaintEvent* pe)
+{
+ QImage* Image;
+ QPainter* Painter;
+ QRect Rect;
+ int i, j, w, h, l, t;
+ uint8* data;
+
+ if (!testWFlags(WRepaintNoErase))
+ setWFlags(WRepaintNoErase);
+ if (CM != NULL)
+ {
+ Rect = pe->rect();
+ l = Rect.left();
+ t = Rect.top();
+ w = Rect.width();
+ h = Rect.height();
+ if (w > 0 && h > 0 && CM->NumColors > 0)
+ {
+ data = (uint8*)xmalloc(w * h);
+ for (i = 0; i < h; i++)
+ for (j = 0; j < w; j++)
+ data[i * w + j] = get_pixel(l + j, t + i);
+ Image = new QImage(data, w, h, 8,(QRgb*)CM->RGBColors, CM->NumColors, QImage::IgnoreEndian);
+ Painter = new QPainter(this);
+ Painter->drawImage(l, t, *Image, 0, 0, w, h);
+ xfree(data);
+ delete Painter;
+ delete Image;
+ }
+ }
+}
+
+//*****************************************************************************
+void QMyMainWindow::closeEvent(QCloseEvent* e)
+{
+ e->accept();
+}
+
+//*****************************************************************************
+void QMyMainWindow::dataReceived()
+{
+ if (rdp_main_loop())
+ return;
+ else
+ SV->close();
+}
+
+//*****************************************************************************
+void redraw(int x, int y, int cx, int cy)
+{
+ if (WarpCoords(&x, &y, &cx, &cy, NULL, NULL))
+ {
+ MW->update(x, y, cx, cy);
+ }
+}
+
+/*
+BOOL ui_init(void)
+{
+ QWidget* d;
+
+ CM = NULL;
+ BS = NULL;
+#ifdef SHARP
+ App = new QPEApplication(g_argc, g_argv);
+#else
+ App = new QApplication(g_argc, g_argv, QApplication::GuiServer);
+#endif
+ if (fullscreen)
+ {
+ d = QApplication::desktop();
+ width = d->width(); // returns screen width
+ height = d->height(); // returns screen height
+ }
+ return True;
+}
+*/
+
+/*
+void ui_deinit(void)
+{
+ delete App;
+}
+*/
+
+/*
+BOOL ui_create_window(void)
+{
+ MW = new QMyMainWindow();
+ MW->resize(width, height);
+ SV = new QMyScrollView();
+ SV->resize(width + 4, height + 4);
+ App->setMainWidget(SV);
+ SV->addChild(MW);
+ MW->setMouseTracking(true);
+ SocketNotifier = new QSocketNotifier(global_sock, QSocketNotifier::Read, MW);
+ MW->connect(SocketNotifier, SIGNAL(activated(int)), MW, SLOT(dataReceived()));
+ if (fullscreen)
+ SV->showFullScreen();
+ else
+ SV->showMaximized();
+ BS = (uint8*)xmalloc(width * height);
+ memset(BS, 0, width * height);
+ clipx = 0;
+ clipy = 0;
+ clipcx = width;
+ clipcy = height;
+ CM = (QColorMap*)xmalloc(sizeof(struct QColorMap));
+ memset(CM, 0, sizeof(struct QColorMap));
+ SV->timer_id = SV->startTimer(1000);
+ return True;
+}
+*/
+
+/*
+void ui_destroy_window(void)
+{
+ delete MW;
+ delete SV;
+ xfree(BS);
+ xfree(CM);
+}
+*/
+
+//*****************************************************************************
+/* Returns 0 after user quit, 1 otherwise */
+int ui_select(int rdp_socket)
+{
+ global_sock = rdp_socket;
+ return 1;
+}
+
+//*****************************************************************************
+void ui_move_pointer(int /*x*/, int /*y*/)
+{
+}
+
+//*****************************************************************************
+HBITMAP ui_create_bitmap(int width, int height, uint8 * data)
+{
+ struct bitmap* the_bitmap;
+ uint8* bitmap_data;
+ int i, j;
+
+// printf("width %d height %d times %d\n", width, height, width * height);
+ bitmap_data = (uint8*)xmalloc(width * height);
+ the_bitmap = (struct bitmap*)xmalloc(sizeof(struct bitmap));
+ the_bitmap->w = width;
+ the_bitmap->h = height;
+ the_bitmap->data = bitmap_data;
+ for (i = 0; i < height; i++)
+ for (j = 0; j < width; j++)
+ bitmap_data[i * width + j] = data[i * width + j];
+ return the_bitmap;
+}
+
+//*****************************************************************************
+void ui_paint_bitmap(int x, int y, int cx, int cy, int width,
+ int height, uint8 * data)
+{
+ int i, j;
+
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ if (i < height)
+ if (j < width)
+ set_pixel(x + j, y + i, data[i * width + j]);
+ redraw(x, y, cx, cy);
+}
+
+//*****************************************************************************
+void ui_destroy_bitmap(HBITMAP bmp)
+{
+ struct bitmap* the_bitmap;
+
+ the_bitmap = (struct bitmap*)bmp;
+ if (the_bitmap != NULL)
+ {
+ if (the_bitmap->data != NULL)
+ xfree(the_bitmap->data);
+ xfree(the_bitmap);
+ }
+}
+
+//*****************************************************************************
+bool is_pixel_on(uint8* data, int x, int y, int width, int bpp)
+{
+ int start, shift;
+
+ if (bpp == 1)
+ {
+ width = (width + 7) / 8;
+ start = (y * width) + x / 8;
+ shift = x % 8;
+ return (data[start] & (0x80 >> shift)) != 0;
+ }
+ else if (bpp == 8)
+ return data[y * width + x] != 0;
+ else
+ return false;
+}
+
+//*****************************************************************************
+void set_pixel_on(uint8* data, int x, int y, int width, int bpp, uint8 pixel)
+{
+ if (bpp == 8)
+ data[y * width + x] = pixel;
+}
+
+//*****************************************************************************
+HGLYPH ui_create_glyph(int width, int height, uint8 * data)
+{
+ int i, j;
+ uint8* glyph_data;
+ struct bitmap* the_glyph;
+
+ glyph_data = (uint8*)xmalloc(width * height);
+ the_glyph = (struct bitmap*)xmalloc(sizeof(struct bitmap));
+ the_glyph->w = width;
+ the_glyph->h = height;
+ the_glyph->data = glyph_data;
+ memset(glyph_data, 0, width * height);
+ for (i = 0; i < height; i++)
+ for (j = 0; j < width; j++)
+ if (is_pixel_on(data, j, i, width, 1))
+ set_pixel_on(glyph_data, j, i, width, 8, 255);
+ return the_glyph;
+}
+
+//*****************************************************************************
+void ui_destroy_glyph(HGLYPH glyph)
+{
+ struct bitmap* the_glyph;
+
+ the_glyph = (struct bitmap*)glyph;
+ if (the_glyph != NULL)
+ {
+ if (the_glyph->data != NULL)
+ xfree(the_glyph->data);
+ xfree(the_glyph);
+ }
+}
+
+//*****************************************************************************
+HCURSOR ui_create_cursor(unsigned int /*x*/, unsigned int /*y*/,
+ int /*width*/, int /*height*/, uint8 * /*andmask*/,
+ uint8 * /*xormask*/)
+{
+ return (void*)1;
+}
+
+//*****************************************************************************
+void ui_set_cursor(HCURSOR /*cursor*/)
+{
+}
+
+//*****************************************************************************
+void ui_destroy_cursor(HCURSOR /*cursor*/)
+{
+}
+
+//*****************************************************************************
+HCOLOURMAP ui_create_colourmap(COLOURMAP * colours)
+{
+ int i;
+ int x;
+ uint8 r, g, b;
+ i = 0;
+ while (i < colours->ncolours && i < 256)
+ {
+ r = colours->colours[i].red;
+ g = colours->colours[i].green;
+ b = colours->colours[i].blue;
+ x = (r << 16) | (g << 8) | b;
+ CM->RGBColors[i] = x;
+ i++;
+ }
+ CM->NumColors = colours->ncolours;
+ return CM;
+}
+
+//*****************************************************************************
+void ui_destroy_colourmap(HCOLOURMAP /*map*/)
+{
+}
+
+//*****************************************************************************
+void ui_set_colourmap(HCOLOURMAP /*map*/)
+{
+}
+
+//*****************************************************************************
+void ui_begin_update(void)
+{
+}
+
+//*****************************************************************************
+void ui_end_update(void)
+{
+}
+
+//*****************************************************************************
+void ui_set_clip(int x, int y, int cx, int cy)
+{
+ clipx = x;
+ clipy = y;
+ clipcx = cx;
+ clipcy = cy;
+}
+
+//*****************************************************************************
+void ui_reset_clip(void)
+{
+ clipx = 0;
+ clipy = 0;
+ clipcx = g_width;
+ clipcy = g_height;
+}
+
+//*****************************************************************************
+void ui_bell(void)
+{
+ App->beep();
+}
+
+//*****************************************************************************
+void ui_destblt(uint8 opcode, int x, int y, int cx, int cy)
+{
+ int i, j;
+
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ set_pixel(x + j, y + i, get_pixel(x + j, y + i), opcode);
+ redraw(x, y, cx, cy);
+}
+
+//*****************************************************************************
+// does not repaint
+void fill_rect(int x, int y, int cx, int cy, int colour, int opcode = 0xc)
+{
+ int i, j;
+
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ set_pixel(x + j, y + i, colour, opcode);
+}
+
+//*****************************************************************************
+void ui_rect(int x, int y, int cx, int cy, int colour)
+{
+ fill_rect(x, y, cx, cy, colour);
+ redraw(x, y, cx, cy);
+}
+
+//*****************************************************************************
+void ui_patblt(uint8 opcode, int x, int y, int cx, int cy,
+ BRUSH * brush, int bgcolour, int fgcolour)
+{
+ int i, j;
+ uint8 ipattern[8];
+
+ switch (brush->style)
+ {
+ case 0:
+ fill_rect(x, y, cx, cy, fgcolour, opcode);
+ break;
+ case 3:
+ for (i = 0; i < 8; i++)
+ ipattern[i] = ~brush->pattern[7 - i];
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ if (is_pixel_on(ipattern, (x + j + brush->xorigin) % 8,
+ (y + i + brush->yorigin) % 8, 8, 1))
+ set_pixel(x + j, y + i, fgcolour, opcode);
+ else
+ set_pixel(x + j, y + i, bgcolour, opcode);
+ break;
+ }
+ redraw(x, y, cx, cy);
+}
+
+//*****************************************************************************
+void ui_screenblt(uint8 opcode, int x, int y, int cx, int cy,
+ int srcx, int srcy)
+{
+ int i, j;
+ uint8* temp;
+
+ temp = (uint8*)xmalloc(cx * cy);
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ temp[i * cx + j] = get_pixel(srcx + j, srcy + i);
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ set_pixel(x + j, y + i, temp[i * cx + j], opcode);
+ xfree(temp);
+ redraw(x, y, cx, cy);
+}
+
+//*****************************************************************************
+void ui_memblt(uint8 opcode, int x, int y, int cx, int cy,
+ HBITMAP src, int srcx, int srcy)
+{
+ int i, j;
+ struct bitmap* the_bitmap;
+
+ the_bitmap = (struct bitmap*)src;
+ if (the_bitmap == NULL)
+ return;
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ if ((i + srcy) < the_bitmap->h && (j + srcx) < the_bitmap->w)
+ set_pixel(x + j, y + i, the_bitmap->data[(i + srcy) * the_bitmap->w + (j + srcx)], opcode);
+ redraw(x, y, cx, cy);
+}
+
+//*****************************************************************************
+// not used
+void ui_triblt(uint8 /*opcode*/, int /*x*/, int /*y*/, int /*cx*/, int /*cy*/,
+ HBITMAP /*src*/, int /*srcx*/, int /*srcy*/, BRUSH * /*brush*/,
+ int /*bgcolour*/, int /*fgcolour*/)
+{
+}
+
+//*****************************************************************************
+// Bresenham's line drawing algorithm
+void ui_line(uint8 opcode, int startx, int starty, int endx,
+ int endy, PEN * pen)
+{
+ int dx, dy, incx, incy, dpr, dpru, p, left, top, right, bottom;
+
+ if (startx > endx)
+ {
+ dx = startx - endx;
+ incx = -1;
+ left = endx;
+ right = startx;
+ }
+ else
+ {
+ dx = endx - startx;
+ incx = 1;
+ left = startx;
+ right = endx;
+ }
+ if (starty > endy)
+ {
+ dy = starty - endy;
+ incy = -1;
+ top = endy;
+ bottom = starty;
+ }
+ else
+ {
+ dy = endy - starty;
+ incy = 1;
+ top = starty;
+ bottom = endy;
+ }
+ if (dx >= dy)
+ {
+ dpr = dy << 1;
+ dpru = dpr - (dx << 1);
+ p = dpr - dx;
+ for (; dx >= 0; dx--)
+ {
+ set_pixel(startx, starty, pen->colour, opcode);
+ if (p > 0)
+ {
+ startx += incx;
+ starty += incy;
+ p += dpru;
+ }
+ else
+ {
+ startx += incx;
+ p += dpr;
+ }
+ }
+ }
+ else
+ {
+ dpr = dx << 1;
+ dpru = dpr - (dy << 1);
+ p = dpr - dy;
+ for (; dy >= 0; dy--)
+ {
+ set_pixel(startx, starty, pen->colour, opcode);
+ if (p > 0)
+ {
+ startx += incx;
+ starty += incy;
+ p += dpru;
+ }
+ else
+ {
+ starty += incy;
+ p += dpr;
+ }
+ }
+ }
+ redraw(left, top, (right - left) + 1, (bottom - top) + 1);
+}
+
+//*****************************************************************************
+void draw_glyph (int x, int y, HGLYPH glyph, int fgcolour)
+{
+ struct bitmap* the_glyph;
+ int i, j;
+
+ the_glyph = (struct bitmap*)glyph;
+ if (the_glyph == NULL)
+ return;
+ for (i = 0; i < the_glyph->h; i++)
+ for (j = 0; j < the_glyph->w; j++)
+ if (is_pixel_on(the_glyph->data, j, i, the_glyph->w, 8))
+ set_pixel(x + j, y + i, fgcolour);
+}
+
+#define DO_GLYPH(ttext,idx) \
+{\
+ glyph = cache_get_font (font, ttext[idx]);\
+ if (!(flags & TEXT2_IMPLICIT_X))\
+ {\
+ xyoffset = ttext[++idx];\
+ if ((xyoffset & 0x80))\
+ {\
+ if (flags & TEXT2_VERTICAL) \
+ y += ttext[idx+1] | (ttext[idx+2] << 8);\
+ else\
+ x += ttext[idx+1] | (ttext[idx+2] << 8);\
+ idx += 2;\
+ }\
+ else\
+ {\
+ if (flags & TEXT2_VERTICAL) \
+ y += xyoffset;\
+ else\
+ x += xyoffset;\
+ }\
+ }\
+ if (glyph != NULL)\
+ {\
+ draw_glyph (x + glyph->offset, y + glyph->baseline, glyph->pixmap, fgcolour);\
+ if (flags & TEXT2_IMPLICIT_X)\
+ x += glyph->width;\
+ }\
+}
+
+//*****************************************************************************
+void ui_draw_text(uint8 font, uint8 flags, int mixmode,
+ int x, int y, int clipx, int clipy,
+ int clipcx, int clipcy, int boxx,
+ int boxy, int boxcx, int boxcy, int bgcolour,
+ int fgcolour, uint8 * text, uint8 length)
+{
+ FONTGLYPH *glyph;
+ int i, j, xyoffset;
+ DATABLOB *entry;
+
+ if (boxcx > 1)
+ fill_rect(boxx, boxy, boxcx, boxcy, bgcolour);
+ else if (mixmode == MIX_OPAQUE)
+ fill_rect(clipx, clipy, clipcx, clipcy, bgcolour);
+
+ /* Paint text, character by character */
+ for (i = 0; i < length;)
+ {
+ switch (text[i])
+ {
+ case 0xff:
+ if (i + 2 < length)
+ cache_put_text(text[i + 1], text, text[i + 2]);
+ else
+ {
+ error("this shouldn't be happening\n");
+ exit(1);
+ }
+ /* this will move pointer from start to first character after FF command */
+ length -= i + 3;
+ text = &(text[i + 3]);
+ i = 0;
+ break;
+
+ case 0xfe:
+ entry = cache_get_text(text[i + 1]);
+ if (entry != NULL)
+ {
+ if ((((uint8 *) (entry->data))[1] == 0) && (!(flags & TEXT2_IMPLICIT_X)))
+ {
+ if (flags & TEXT2_VERTICAL)
+ y += text[i + 2];
+ else
+ x += text[i + 2];
+ }
+ for (j = 0; j < entry->size; j++)
+ DO_GLYPH(((uint8 *) (entry->data)), j);
+ }
+ if (i + 2 < length)
+ i += 3;
+ else
+ i += 2;
+ length -= i;
+ /* this will move pointer from start to first character after FE command */
+ text = &(text[i]);
+ i = 0;
+ break;
+
+ default:
+ DO_GLYPH(text, i);
+ i++;
+ break;
+ }
+ }
+ if (boxcx > 1)
+ redraw(boxx, boxy, boxcx, boxcy);
+ else
+ redraw(clipx, clipy, clipcx, clipcy);
+}
+
+//*****************************************************************************
+void ui_desktop_save(uint32 offset, int x, int y, int cx, int cy)
+{
+ uint8* data;
+ int i, j;
+
+ data = (uint8*)xmalloc(cx * cy);
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ data[i * cx + j] = get_pixel(x + j, y + i);
+ cache_put_desktop(offset, cx, cy, cx, 1, data);
+ xfree(data);
+}
+
+//*****************************************************************************
+void ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy)
+{
+ uint8* data;
+ int i, j;
+
+ data = cache_get_desktop(offset, cx, cy, 1);
+ for (i = 0; i < cy; i++)
+ for (j = 0; j < cx; j++)
+ set_pixel(x + j, y + i, data[i * cx + j]);
+ redraw(x, y, cx, cy);
+}
+
+//*****************************************************************************
+int main(int argc, char** argv)
+{
+ CM = NULL;
+ BS = NULL;
+#ifdef SHARP
+ App = new QPEApplication(argc, argv);
+#else
+ App = new QApplication(argc, argv, QApplication::GuiServer);
+#endif
+ SV = new QMyScrollView();
+ App->setMainWidget(SV);
+ SV->showMaximized();
+ SV->timer_id = SV->startTimer(1000);
+ App->exec();
+ delete SV;
+ delete App;
+ if (CM != NULL)
+ xfree(CM);
+ if (BS !=NULL)
+ xfree(BS);
+ return 0;
+}
+
+/*
+ MW = new QMyMainWindow();
+ MW->resize(width, height);
+ SV->resize(width + 4, height + 4);
+ App->setMainWidget(SV);
+ SV->addChild(MW);
+ MW->setMouseTracking(true);
+ SocketNotifier = new QSocketNotifier(global_sock, QSocketNotifier::Read, MW);
+ MW->connect(SocketNotifier, SIGNAL(activated(int)), MW, SLOT(dataReceived()));
+ if (fullscreen)
+ SV->showFullScreen();
+ else
+ SV->showMaximized();
+ BS = (uint8*)xmalloc(width * height);
+ memset(BS, 0, width * height);
+ clipx = 0;
+ clipy = 0;
+ clipcx = width;
+ clipcy = height;
+ CM = (QColorMap*)xmalloc(sizeof(struct QColorMap));
+ memset(CM, 0, sizeof(struct QColorMap));
+ SV->timer_id = SV->startTimer(1000);
+ return True;
+
+
+
+
+
+int main(int argc, char ** argv)
+{
+ uint32 flags;
+ int i, total_params;
+ char server[64] = "192.168.0.164";
+ char domain[16] = "";
+ char password[16] = "";
+ char shell[128] = "";
+ char directory[32] = "";
+ char* p;
+ QString param, s1, s2, s3;
+
+ flags = RDP_LOGON_NORMAL;
+
+ g_argc = argc;
+ g_argv = argv;
+
+ if (!ui_init())
+ return 1;
+
+ total_params = App->argc();
+
+ for (i = 1; (i + 1) < total_params; i = i + 2)
+ {
+ s1 = App->argv()[i];
+ s2 = App->argv()[i + 1];
+ if (s1 == "-g")
+ {
+ width = strtol((const char*)s2, &p, 10);
+ if (*p == 'x')
+ height = strtol(p + 1, NULL, 10);
+ }
+ else if (s1 = "-u")
+ strcpy(username, (const char*)s2);
+ }
+ if (i < total_params)
+ strcpy(server, App->argv()[i]);
+
+// printf("server %s width %d height %d\n", server, width, height);
+
+ if (width == 0 || height == 0)
+ {
+ ui_deinit();
+ return 1;
+ }
+
+ if (!rdp_connect(server, flags, domain, password, shell, directory))
+ {
+ ui_deinit();
+ return 1;
+ }
+ if (ui_create_window())
+ {
+ ui_main_loop();
+ ui_destroy_window();
+ }
+ rdp_disconnect();
+ ui_deinit();
+}
+*/
diff --git a/noncore/net/opierdesktop/qtwin.h b/noncore/net/opierdesktop/qtwin.h
new file mode 100644
index 0000000..38ad190
--- a/dev/null
+++ b/noncore/net/opierdesktop/qtwin.h
@@ -0,0 +1,105 @@
+
+#include <qwidget.h>
+#include <qscrollview.h>
+#include <qdialog.h>
+#include <qlistbox.h>
+#include <qlineedit.h>
+#include <qcombobox.h>
+#include <qlabel.h>
+#include <qcheckbox.h>
+#include <qpopupmenu.h>
+
+class QMyConnectionItem
+{
+ public:
+ QString ServerName;
+ QString UserName;
+ QString ServerIP;
+ int Width;
+ int Height;
+ int FullScreen;
+};
+
+class QMyDialog: public QDialog
+{
+ Q_OBJECT
+ public:
+ QMyDialog(QWidget*);
+ ~QMyDialog();
+ public:
+ QListBox* ListBox;
+ QPushButton* OKButton;
+ QPushButton* CancelButton;
+ QLabel* Label1;
+ QLineEdit* ServerNameEdit;
+ QLabel* Label2;
+ QLineEdit* UserNameEdit;
+ QLabel* Label3;
+ QLineEdit* IPEdit;
+ QLineEdit* WidthEdit;
+ QLineEdit* HeightEdit;
+ QComboBox* WidthHeightBox;
+ QPushButton* AddButton;
+ QPushButton* EditButton;
+ QPushButton* SaveButton;
+ QPushButton* RemoveButton;
+ QCheckBox* FullScreenCheckBox;
+ public slots:
+ void ComboChanged(int);
+ void OKClicked();
+ void CancelClicked();
+ void AddClicked();
+ void EditClicked();
+ void SaveClicked();
+ void RemoveClicked();
+ void ListBoxChanged();
+ void ListBoxSelected(int);
+ public:
+ QString ServerName;
+ QString UserName;
+ QString ServerIP;
+ int Width;
+ int Height;
+ int FullScreen;
+ QMyConnectionItem* ConnectionList[10];
+};
+
+class QMyScrollView: public QScrollView
+{
+ Q_OBJECT
+ public:
+ QMyScrollView();
+ ~QMyScrollView();
+ void keyPressEvent(QKeyEvent*);
+ void keyReleaseEvent(QKeyEvent*);
+ void showEvent(QShowEvent*);
+ void show();
+ void polish();
+ void timerEvent(QTimerEvent*);
+ public:
+ int timer_id;
+};
+
+class QMyMainWindow: public QWidget
+{
+ Q_OBJECT
+ public:
+ QMyMainWindow();
+ ~QMyMainWindow();
+ void paintEvent(QPaintEvent*);
+ void mouseMoveEvent(QMouseEvent*);
+ void mousePressEvent(QMouseEvent*);
+ void mouseReleaseEvent(QMouseEvent*);
+ void wheelEvent(QWheelEvent*);
+ void closeEvent(QCloseEvent*);
+ void timerEvent(QTimerEvent*);
+ public slots:
+ void dataReceived();
+ void MemuClicked(int);
+ public:
+ QPopupMenu* PopupMenu;
+ int timer_id;
+ int mx;
+ int my;
+};
+
diff --git a/noncore/net/opierdesktop/rdesktop.cpp b/noncore/net/opierdesktop/rdesktop.cpp
new file mode 100644
index 0000000..1a9a087
--- a/dev/null
+++ b/noncore/net/opierdesktop/rdesktop.cpp
@@ -0,0 +1,313 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Entrypoint and utility functions
+ Copyright (C) Matthew Chapman 1999-2003
+
+ 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.
+*/
+
+//#include <stdarg.h> /* va_list va_start va_end */
+#include <unistd.h> /* read close getuid getgid getpid getppid gethostname */
+#include <fcntl.h> /* open */
+#include <pwd.h> /* getpwuid */
+//#include <termios.h> /* tcgetattr tcsetattr */
+#include <sys/stat.h> /* stat */
+#include <sys/time.h> /* gettimeofday */
+#include <sys/times.h> /* times */
+#include <errno.h>
+#include "rdesktop.h"
+
+#ifdef EGD_SOCKET
+#include <sys/socket.h> /* socket connect */
+#include <sys/un.h> /* sockaddr_un */
+#endif
+
+//#ifdef WITH_OPENSSL
+#include <openssl/md5.h>
+//#else
+//#include "crypto/md5.h"
+//#endif
+
+/*extern "C" */void ui_main_loop(void);
+
+int g_argc;
+char ** g_argv;
+
+char title[32] = "";
+char username[16] = "j";
+char hostname[16] = "sharp";
+char keymapname[16];
+int keylayout = 0x409; /* Defaults to US keyboard layout */
+int g_width = 800; /* If width or height are reset to zero, the geometry will
+ be fetched from _NET_WORKAREA */
+int g_height = 600;
+int tcp_port_rdp = TCP_PORT_RDP;
+int server_bpp = 8;
+int win_button_size = 0; /* If zero, disable single app mode */
+BOOL bitmap_compression = True;
+BOOL sendmotion = True;
+BOOL orders = True;
+BOOL encryption = True;
+BOOL desktop_save = True;
+BOOL fullscreen = False;
+BOOL grab_keyboard = True;
+BOOL hide_decorations = False;
+extern BOOL owncolmap;
+
+/* report an unimplemented protocol feature */
+void
+unimpl(char *format, ...)
+{
+}
+
+/* malloc; exit if out of memory */
+void *
+xmalloc(int size)
+{
+ void *mem = malloc(size);
+ if (mem == NULL)
+ {
+ error("xmalloc %d\n", size);
+ exit(1);
+ }
+ return mem;
+}
+
+/* realloc; exit if out of memory */
+void *
+xrealloc(void *oldmem, int size)
+{
+ void *mem = realloc(oldmem, size);
+ if (mem == NULL)
+ {
+ error("xrealloc %d\n", size);
+ exit(1);
+ }
+ return mem;
+}
+
+/* free */
+void
+xfree(void *mem)
+{
+ free(mem);
+}
+
+/* report an error */
+void
+error(char *format, ...)
+{
+}
+
+/* report a warning */
+void
+warning(char *format, ...)
+{
+}
+
+/* Generate a 32-byte random for the secure transport code. */
+void
+generate_random(uint8 * random)
+{
+ struct stat st;
+ struct tms tmsbuf;
+ MD5_CTX md5;
+ uint32 *r;
+ int fd, n;
+
+ /* If we have a kernel random device, try that first */
+ if (((fd = open("/dev/urandom", O_RDONLY)) != -1)
+ || ((fd = open("/dev/random", O_RDONLY)) != -1))
+ {
+ n = read(fd, random, 32);
+ close(fd);
+ if (n == 32)
+ return;
+ }
+ /* Otherwise use whatever entropy we can gather - ideas welcome. */
+ r = (uint32 *) random;
+ r[0] = (getpid()) | (getppid() << 16);
+ r[1] = (getuid()) | (getgid() << 16);
+ r[2] = times(&tmsbuf); /* system uptime (clocks) */
+ gettimeofday((struct timeval *) &r[3], NULL); /* sec and usec */
+ stat("/tmp", &st);
+ r[5] = st.st_atime;
+ r[6] = st.st_mtime;
+ r[7] = st.st_ctime;
+
+ /* Hash both halves with MD5 to obscure possible patterns */
+ MD5_Init(&md5);
+ MD5_Update(&md5, random, 16);
+ MD5_Final(random, &md5);
+ MD5_Update(&md5, random + 16, 16);
+ MD5_Final(random + 16, &md5);
+}
+
+int
+load_licence(unsigned char **data)
+{
+ char *path;
+ char *home;
+ struct stat st;
+ int fd;
+
+ home = getenv("HOME");
+ if (home == NULL)
+ return -1;
+
+ path = (char*)xmalloc(strlen(home) + strlen(hostname) + 20);
+ sprintf(path, "%s/.rdesktop/licence.%s", home, hostname);
+
+ fd = open(path, O_RDONLY);
+ if (fd == -1)
+ return -1;
+
+ if (fstat(fd, &st))
+ return -1;
+
+ *data = (unsigned char*)xmalloc(st.st_size);
+ return read(fd, *data, st.st_size);
+}
+
+void
+save_licence(unsigned char *data, int length)
+{
+ char *fpath; /* file path for licence */
+ char *fname, *fnamewrk; /* file name for licence .inkl path. */
+ char *home;
+ uint32 y;
+ struct flock fnfl;
+ int fnfd, fnwrkfd, i, wlen;
+ struct stream s, *s_ptr;
+ uint32 len;
+
+ /* Construct a stream, so that we can use macros to extract the
+ * licence.
+ */
+ s_ptr = &s;
+ s_ptr->p = data;
+ /* Skip first two bytes */
+ in_uint16(s_ptr, len);
+
+ /* Skip three strings */
+ for (i = 0; i < 3; i++)
+ {
+ in_uint32(s_ptr, len);
+ s_ptr->p += len;
+ /* Make sure that we won't be past the end of data after
+ * reading the next length value
+ */
+ if ((s_ptr->p) + 4 > data + length)
+ {
+ printf("Error in parsing licence key.\n");
+ printf("Strings %d end value %x > supplied length (%x)\n", i,
+ (unsigned int) s_ptr->p, (unsigned int) data + length);
+ return;
+ }
+ }
+ in_uint32(s_ptr, len);
+ if (s_ptr->p + len > data + length)
+ {
+ printf("Error in parsing licence key.\n");
+ printf("End of licence %x > supplied length (%x)\n",
+ (unsigned int) s_ptr->p + len, (unsigned int) data + length);
+ return;
+ }
+
+ home = getenv("HOME");
+ if (home == NULL)
+ return;
+
+ /* set and create the directory -- if it doesn't exist. */
+ fpath = (char*)xmalloc(strlen(home) + 11);
+ STRNCPY(fpath, home, strlen(home) + 1);
+
+ sprintf(fpath, "%s/.rdesktop", fpath);
+ if (mkdir(fpath, 0700) == -1 && errno != EEXIST)
+ {
+ perror("mkdir");
+ exit(1);
+ }
+
+ /* set the real licence filename, and put a write lock on it. */
+ fname = (char*)xmalloc(strlen(fpath) + strlen(hostname) + 10);
+ sprintf(fname, "%s/licence.%s", fpath, hostname);
+ fnfd = open(fname, O_RDONLY);
+ if (fnfd != -1)
+ {
+ fnfl.l_type = F_WRLCK;
+ fnfl.l_whence = SEEK_SET;
+ fnfl.l_start = 0;
+ fnfl.l_len = 1;
+ fcntl(fnfd, F_SETLK, &fnfl);
+ }
+
+ /* create a temporary licence file */
+ fnamewrk = (char*)xmalloc(strlen(fname) + 12);
+ for (y = 0;; y++)
+ {
+ sprintf(fnamewrk, "%s.%lu", fname, (long unsigned int) y);
+ fnwrkfd = open(fnamewrk, O_WRONLY | O_CREAT | O_EXCL, 0600);
+ if (fnwrkfd == -1)
+ {
+ if (errno == EINTR || errno == EEXIST)
+ continue;
+ perror("create");
+ exit(1);
+ }
+ break;
+ }
+ /* write to the licence file */
+ for (y = 0; y < len;)
+ {
+ do
+ {
+ wlen = write(fnwrkfd, s_ptr->p + y, len - y);
+ }
+ while (wlen == -1 && errno == EINTR);
+ if (wlen < 1)
+ {
+ perror("write");
+ unlink(fnamewrk);
+ exit(1);
+ }
+ y += wlen;
+ }
+
+ /* close the file and rename it to fname */
+ if (close(fnwrkfd) == -1)
+ {
+ perror("close");
+ unlink(fnamewrk);
+ exit(1);
+ }
+ if (rename(fnamewrk, fname) == -1)
+ {
+ perror("rename");
+ unlink(fnamewrk);
+ exit(1);
+ }
+ /* close the file lock on fname */
+ if (fnfd != -1)
+ {
+ fnfl.l_type = F_UNLCK;
+ fnfl.l_whence = SEEK_SET;
+ fnfl.l_start = 0;
+ fnfl.l_len = 1;
+ fcntl(fnfd, F_SETLK, &fnfl);
+ close(fnfd);
+ }
+
+}
diff --git a/noncore/net/opierdesktop/rdesktop.h b/noncore/net/opierdesktop/rdesktop.h
new file mode 100644
index 0000000..0fca123
--- a/dev/null
+++ b/noncore/net/opierdesktop/rdesktop.h
@@ -0,0 +1,66 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Master include file
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+//#define __LITTLE_ENDIAN 1234
+//#define __BIG_ENDIAN 4321
+//#define __BYTE_ORDER __BIG_ENDIAN
+
+//#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define L_ENDIAN
+#define NEED_ALIGN
+//#error le
+//#elif __BYTE_ORDER == __BIG_ENDIAN
+//#define B_ENDIAN
+//#error be
+//#else
+//#error Unknown endianness. Edit rdesktop.h.
+//#endif
+
+
+//#define B_ENDIAN
+//#define B_ENDIAN_PREFERRED
+
+#define VERSION "1.2.0"
+
+#ifdef WITH_DEBUG
+#define DEBUG(args) printf args;
+#else
+#define DEBUG(args)
+#endif
+
+#ifdef WITH_DEBUG_KBD
+#define DEBUG_KBD(args) printf args;
+#else
+#define DEBUG_KBD(args)
+#endif
+
+#define STRNCPY(dst,src,n) { strncpy(dst,src,n-1); dst[n-1] = 0; }
+
+#include "constants.h"
+#include "types.h"
+#include "parse.h"
+
+#ifndef MAKE_PROTO
+#include "proto.h"
+#endif
diff --git a/noncore/net/opierdesktop/rdp.cpp b/noncore/net/opierdesktop/rdp.cpp
new file mode 100644
index 0000000..bab8568
--- a/dev/null
+++ b/noncore/net/opierdesktop/rdp.cpp
@@ -0,0 +1,748 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Protocol services - RDP layer
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include "rdesktop.h"
+
+extern uint16 mcs_userid;
+extern char username[16];
+extern BOOL bitmap_compression;
+extern BOOL orders;
+extern BOOL encryption;
+extern BOOL desktop_save;
+
+uint8 *next_packet;
+uint32 rdp_shareid;
+
+/* Initialise an RDP packet */
+static STREAM
+rdp_init(int maxlen)
+{
+ STREAM s;
+
+ s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 6);
+ s_push_layer(s, rdp_hdr, 6);
+
+ return s;
+}
+
+/* Send an RDP packet */
+static void
+rdp_send(STREAM s, uint8 pdu_type)
+{
+ uint16 length;
+
+ s_pop_layer(s, rdp_hdr);
+ length = s->end - s->p;
+
+ out_uint16_le(s, length);
+ out_uint16_le(s, (pdu_type | 0x10)); /* Version 1 */
+ out_uint16_le(s, (mcs_userid + 1001));
+
+ sec_send(s, encryption ? SEC_ENCRYPT : 0);
+}
+
+/* Receive an RDP packet */
+STREAM
+rdp_recv(uint8 * type)
+{
+ static STREAM rdp_s;
+ uint16 length, pdu_type;
+
+ if ((rdp_s == NULL) || (next_packet >= rdp_s->end))
+ {
+ rdp_s = sec_recv();
+ if (rdp_s == NULL)
+ return NULL;
+
+ next_packet = rdp_s->p;
+ }
+ else
+ {
+ rdp_s->p = next_packet;
+ }
+
+ in_uint16_le(rdp_s, length);
+ /* 32k packets are really 8, keepalive fix */
+ if (length == 0x8000)
+ {
+ next_packet += 8;
+ *type = 0;
+ return rdp_s;
+ }
+ in_uint16_le(rdp_s, pdu_type);
+ in_uint8s(rdp_s, 2); /* userid */
+ *type = pdu_type & 0xf;
+
+#if WITH_DEBUG
+ DEBUG(("RDP packet (type %x):\n", *type));
+ hexdump(next_packet, length);
+#endif /* */
+
+ next_packet += length;
+ return rdp_s;
+}
+
+/* Initialise an RDP data packet */
+static STREAM
+rdp_init_data(int maxlen)
+{
+ STREAM s;
+
+ s = sec_init(encryption ? SEC_ENCRYPT : 0, maxlen + 18);
+ s_push_layer(s, rdp_hdr, 18);
+
+ return s;
+}
+
+/* Send an RDP data packet */
+static void
+rdp_send_data(STREAM s, uint8 data_pdu_type)
+{
+ uint16 length;
+
+ s_pop_layer(s, rdp_hdr);
+ length = s->end - s->p;
+
+ out_uint16_le(s, length);
+ out_uint16_le(s, (RDP_PDU_DATA | 0x10));
+ out_uint16_le(s, (mcs_userid + 1001));
+
+ out_uint32_le(s, rdp_shareid);
+ out_uint8(s, 0); /* pad */
+ out_uint8(s, 1); /* streamid */
+ out_uint16_le(s, (length - 14));
+ out_uint8(s, data_pdu_type);
+ out_uint8(s, 0); /* compress_type */
+ out_uint16(s, 0); /* compress_len */
+
+ sec_send(s, encryption ? SEC_ENCRYPT : 0);
+}
+
+/* Output a string in Unicode */
+void
+rdp_out_unistr(STREAM s, char *string, int len)
+{
+ int i = 0, j = 0;
+
+ len += 2;
+
+ while (i < len)
+ {
+ s->p[i++] = string[j++];
+ s->p[i++] = 0;
+ }
+
+ s->p += len;
+}
+
+/* Parse a logon info packet */
+static void
+rdp_send_logon_info(uint32 flags, char *domain, char *user,
+ char *password, char *program, char *directory)
+{
+ int len_domain = 2 * strlen(domain);
+ int len_user = 2 * strlen(user);
+ int len_password = 2 * strlen(password);
+ int len_program = 2 * strlen(program);
+ int len_directory = 2 * strlen(directory);
+ uint32 sec_flags = encryption ? (SEC_LOGON_INFO | SEC_ENCRYPT) : SEC_LOGON_INFO;
+ STREAM s;
+
+ s = sec_init(sec_flags, 18 + len_domain + len_user + len_password
+ + len_program + len_directory + 10);
+
+ out_uint32(s, 0);
+ out_uint32_le(s, flags);
+ out_uint16_le(s, len_domain);
+ out_uint16_le(s, len_user);
+ out_uint16_le(s, len_password);
+ out_uint16_le(s, len_program);
+ out_uint16_le(s, len_directory);
+ rdp_out_unistr(s, domain, len_domain);
+ rdp_out_unistr(s, user, len_user);
+ rdp_out_unistr(s, password, len_password);
+ rdp_out_unistr(s, program, len_program);
+ rdp_out_unistr(s, directory, len_directory);
+
+ s_mark_end(s);
+ sec_send(s, sec_flags);
+}
+
+/* Send a control PDU */
+static void
+rdp_send_control(uint16 action)
+{
+ STREAM s;
+
+ s = rdp_init_data(8);
+
+ out_uint16_le(s, action);
+ out_uint16(s, 0); /* userid */
+ out_uint32(s, 0); /* control id */
+
+ s_mark_end(s);
+ rdp_send_data(s, RDP_DATA_PDU_CONTROL);
+}
+
+/* Send a synchronisation PDU */
+static void
+rdp_send_synchronise(void)
+{
+ STREAM s;
+
+ s = rdp_init_data(4);
+
+ out_uint16_le(s, 1); /* type */
+ out_uint16_le(s, 1002);
+
+ s_mark_end(s);
+ rdp_send_data(s, RDP_DATA_PDU_SYNCHRONISE);
+}
+
+/* Send a single input event */
+void
+rdp_send_input(uint32 time, uint16 message_type, uint16 device_flags, uint16 param1, uint16 param2)
+{
+ STREAM s;
+
+ s = rdp_init_data(16);
+
+ out_uint16_le(s, 1); /* number of events */
+ out_uint16(s, 0); /* pad */
+
+ out_uint32_le(s, time);
+ out_uint16_le(s, message_type);
+ out_uint16_le(s, device_flags);
+ out_uint16_le(s, param1);
+ out_uint16_le(s, param2);
+
+ s_mark_end(s);
+ rdp_send_data(s, RDP_DATA_PDU_INPUT);
+}
+
+/* Send an (empty) font information PDU */
+static void
+rdp_send_fonts(uint16 seq)
+{
+ STREAM s;
+
+ s = rdp_init_data(8);
+
+ out_uint16(s, 0); /* number of fonts */
+ out_uint16_le(s, 0x3e); /* unknown */
+ out_uint16_le(s, seq); /* unknown */
+ out_uint16_le(s, 0x32); /* entry size */
+
+ s_mark_end(s);
+ rdp_send_data(s, RDP_DATA_PDU_FONT2);
+}
+
+/* Output general capability set */
+static void
+rdp_out_general_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_GENERAL);
+ out_uint16_le(s, RDP_CAPLEN_GENERAL);
+
+ out_uint16_le(s, 1); /* OS major type */
+ out_uint16_le(s, 3); /* OS minor type */
+ out_uint16_le(s, 0x200); /* Protocol version */
+ out_uint16(s, 0); /* Pad */
+ out_uint16(s, 0); /* Compression types */
+ out_uint16(s, 0); /* Pad */
+ out_uint16(s, 0); /* Update capability */
+ out_uint16(s, 0); /* Remote unshare capability */
+ out_uint16(s, 0); /* Compression level */
+ out_uint16(s, 0); /* Pad */
+}
+
+/* Output bitmap capability set */
+static void
+rdp_out_bitmap_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_BITMAP);
+ out_uint16_le(s, RDP_CAPLEN_BITMAP);
+
+ out_uint16_le(s, 8); /* Preferred BPP */
+ out_uint16_le(s, 1); /* Receive 1 BPP */
+ out_uint16_le(s, 1); /* Receive 4 BPP */
+ out_uint16_le(s, 1); /* Receive 8 BPP */
+ out_uint16_le(s, 800); /* Desktop width */
+ out_uint16_le(s, 600); /* Desktop height */
+ out_uint16(s, 0); /* Pad */
+ out_uint16(s, 0); /* Allow resize */
+ out_uint16_le(s, bitmap_compression ? 1 : 0); /* Support compression */
+ out_uint16(s, 0); /* Unknown */
+ out_uint16_le(s, 1); /* Unknown */
+ out_uint16(s, 0); /* Pad */
+}
+
+/* Output order capability set */
+static void
+rdp_out_order_caps(STREAM s)
+{
+ uint8 order_caps[32];
+
+
+ memset(order_caps, 0, 32);
+ order_caps[0] = 1; /* dest blt */
+ order_caps[1] = 1; /* pat blt */
+ order_caps[2] = 1; /* screen blt */
+// order_caps[3] = 1; /* required for memblt? */
+ order_caps[8] = 1; /* line */
+ order_caps[9] = 1; /* line */
+ order_caps[10] = 1; /* rect */
+ order_caps[11] = (desktop_save == False ? 0 : 1); /* desksave */
+ order_caps[13] = 1; /* memblt */
+ order_caps[14] = 1; /* triblt */
+ order_caps[22] = 1; /* polyline */
+ order_caps[27] = 1; /* text2 */
+ out_uint16_le(s, RDP_CAPSET_ORDER);
+ out_uint16_le(s, RDP_CAPLEN_ORDER);
+
+ out_uint8s(s, 20); /* Terminal desc, pad */
+ out_uint16_le(s, 1); /* Cache X granularity */
+ out_uint16_le(s, 20); /* Cache Y granularity */
+ out_uint16(s, 0); /* Pad */
+ out_uint16_le(s, 1); /* Max order level */
+ out_uint16_le(s, 0x147); /* Number of fonts */
+ out_uint16_le(s, 0x2a); /* Capability flags */
+ out_uint8p(s, order_caps, 32); /* Orders supported */
+ out_uint16_le(s, 0x6a1); /* Text capability flags */
+ out_uint8s(s, 6); /* Pad */
+ out_uint32_le(s, desktop_save == False ? 0 : 0x38400); /* Desktop cache size */
+// out_uint32_le(s, 0); // desktop cache set to 0
+ out_uint32(s, 0); /* Unknown */
+ out_uint32_le(s, 0x4e4); /* Unknown */
+}
+
+/* Output bitmap cache capability set */
+static void
+rdp_out_bmpcache_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_BMPCACHE);
+ out_uint16_le(s, RDP_CAPLEN_BMPCACHE);
+
+ out_uint8s(s, 24); /* unused */
+ out_uint16_le(s, 0x258); /* entries */
+ out_uint16_le(s, 0x100); /* max cell size */
+ out_uint16_le(s, 0x12c); /* entries */
+ out_uint16_le(s, 0x400); /* max cell size */
+ out_uint16_le(s, 0x106); /* entries */
+ out_uint16_le(s, 0x1000); /* max cell size */
+}
+
+/* Output control capability set */
+static void
+rdp_out_control_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_CONTROL);
+ out_uint16_le(s, RDP_CAPLEN_CONTROL);
+
+ out_uint16(s, 0); /* Control capabilities */
+ out_uint16(s, 0); /* Remote detach */
+ out_uint16_le(s, 2); /* Control interest */
+ out_uint16_le(s, 2); /* Detach interest */
+}
+
+/* Output activation capability set */
+static void
+rdp_out_activate_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_ACTIVATE);
+ out_uint16_le(s, RDP_CAPLEN_ACTIVATE);
+
+ out_uint16(s, 0); /* Help key */
+ out_uint16(s, 0); /* Help index key */
+ out_uint16(s, 0); /* Extended help key */
+ out_uint16(s, 0); /* Window activate */
+}
+
+/* Output pointer capability set */
+static void
+rdp_out_pointer_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_POINTER);
+ out_uint16_le(s, RDP_CAPLEN_POINTER);
+
+ out_uint16(s, 0); /* Colour pointer */
+ out_uint16_le(s, 20); /* Cache size */
+}
+
+/* Output share capability set */
+static void
+rdp_out_share_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_SHARE);
+ out_uint16_le(s, RDP_CAPLEN_SHARE);
+
+ out_uint16(s, 0); /* userid */
+ out_uint16(s, 0); /* pad */
+}
+
+/* Output colour cache capability set */
+static void
+rdp_out_colcache_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_COLCACHE);
+ out_uint16_le(s, RDP_CAPLEN_COLCACHE);
+
+ out_uint16_le(s, 6); /* cache size */
+ out_uint16(s, 0); /* pad */
+}
+
+static uint8 canned_caps[] = {
+ 0x01, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x04,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x0C, 0x00, 0x08, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00,
+ 0x10, 0x00, 0x34, 0x00, 0xFE,
+ 0x00, 0x04, 0x00, 0xFE, 0x00, 0x04, 0x00, 0xFE, 0x00, 0x08, 0x00,
+ 0xFE, 0x00, 0x08, 0x00, 0xFE,
+ 0x00, 0x10, 0x00, 0xFE, 0x00, 0x20, 0x00, 0xFE, 0x00, 0x40, 0x00,
+ 0xFE, 0x00, 0x80, 0x00, 0xFE,
+ 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x01,
+ 0x02, 0x00, 0x00, 0x00
+};
+
+/* Output unknown capability set */
+static void
+rdp_out_unknown_caps(STREAM s)
+{
+ out_uint16_le(s, RDP_CAPSET_UNKNOWN);
+ out_uint16_le(s, 0x58);
+
+ out_uint8p(s, canned_caps, RDP_CAPLEN_UNKNOWN - 4);
+}
+
+/* Send a confirm active PDU */
+static void
+rdp_send_confirm_active(void)
+{
+ STREAM s;
+ uint16 caplen =
+ RDP_CAPLEN_GENERAL + RDP_CAPLEN_BITMAP + RDP_CAPLEN_ORDER +
+ RDP_CAPLEN_BMPCACHE + RDP_CAPLEN_COLCACHE +
+ RDP_CAPLEN_ACTIVATE + RDP_CAPLEN_CONTROL +
+ RDP_CAPLEN_POINTER + RDP_CAPLEN_SHARE + RDP_CAPLEN_UNKNOWN + 4 /* w2k fix, why? */ ;
+
+ s = rdp_init(14 + caplen + sizeof(RDP_SOURCE));
+
+ out_uint32_le(s, rdp_shareid);
+ out_uint16_le(s, 0x3ea); /* userid */
+ out_uint16_le(s, sizeof(RDP_SOURCE));
+ out_uint16_le(s, caplen);
+
+ out_uint8p(s, RDP_SOURCE, sizeof(RDP_SOURCE));
+ out_uint16_le(s, 0xd); /* num_caps */
+ out_uint8s(s, 2); /* pad */
+
+ rdp_out_general_caps(s);
+ rdp_out_bitmap_caps(s);
+ rdp_out_order_caps(s);
+ rdp_out_bmpcache_caps(s);
+ rdp_out_colcache_caps(s);
+ rdp_out_activate_caps(s);
+ rdp_out_control_caps(s);
+ rdp_out_pointer_caps(s);
+ rdp_out_share_caps(s);
+ rdp_out_unknown_caps(s);
+
+ s_mark_end(s);
+ rdp_send(s, RDP_PDU_CONFIRM_ACTIVE);
+}
+
+/* Respond to a demand active PDU */
+void
+process_demand_active(STREAM s)
+{
+ uint8 type;
+
+ in_uint32_le(s, rdp_shareid);
+
+ DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", rdp_shareid));
+
+ rdp_send_confirm_active();
+ rdp_send_synchronise();
+ rdp_send_control(RDP_CTL_COOPERATE);
+ rdp_send_control(RDP_CTL_REQUEST_CONTROL);
+ rdp_recv(&type); /* RDP_PDU_SYNCHRONIZE */
+ rdp_recv(&type); /* RDP_CTL_COOPERATE */
+ rdp_recv(&type); /* RDP_CTL_GRANT_CONTROL */
+ rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, 0, 0);
+ rdp_send_fonts(1);
+ rdp_send_fonts(2);
+ rdp_recv(&type); /* RDP_PDU_UNKNOWN 0x28 */
+ reset_order_state();
+}
+
+/* Process a pointer PDU */
+static void
+process_pointer_pdu(STREAM s)
+{
+ uint16 message_type;
+ uint16 x, y, width, height, cache_idx, masklen, datalen;
+ uint8 *mask, *data;
+ HCURSOR cursor;
+
+ in_uint16_le(s, message_type);
+ in_uint8s(s, 2); /* pad */
+
+ switch (message_type)
+ {
+ case RDP_POINTER_MOVE:
+ in_uint16_le(s, x);
+ in_uint16_le(s, y);
+ if (s_check(s))
+ ui_move_pointer(x, y);
+ break;
+
+ case RDP_POINTER_COLOR:
+ in_uint16_le(s, cache_idx);
+ in_uint16_le(s, x);
+ in_uint16_le(s, y);
+ in_uint16_le(s, width);
+ in_uint16_le(s, height);
+ in_uint16_le(s, masklen);
+ in_uint16_le(s, datalen);
+ in_uint8p(s, data, datalen);
+ in_uint8p(s, mask, masklen);
+ cursor = ui_create_cursor(x, y, width, height, mask, data);
+ ui_set_cursor(cursor);
+ cache_put_cursor(cache_idx, cursor);
+ break;
+
+ case RDP_POINTER_CACHED:
+ in_uint16_le(s, cache_idx);
+ ui_set_cursor(cache_get_cursor(cache_idx));
+ break;
+
+ default:
+ DEBUG(("Pointer message 0x%x\n", message_type));
+ }
+}
+
+/* Process bitmap updates */
+static void
+process_bitmap_updates(STREAM s)
+{
+ 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(("UPDATE(l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,cmp=%d)\n",
+ left, top, right, bottom, width, height, 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;
+ }
+
+ 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);
+ }
+ xfree(bmpdata);
+ }
+}
+
+/* Process a palette update */
+static void
+process_palette(STREAM s)
+{
+ COLOURENTRY *entry;
+ COLOURMAP map;
+ HCOLOURMAP hmap;
+ int i;
+ uint8 data[1536];
+
+ in_uint8s(s, 2); /* pad */
+ in_uint16_le(s, map.ncolours);
+ in_uint8s(s, 2); /* pad */
+
+ map.colours = (COLOURENTRY*)data;
+
+ 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);
+}
+
+/* Process an update PDU */
+static void
+process_update_pdu(STREAM s)
+{
+ uint16 update_type;
+
+ in_uint16_le(s, update_type);
+ ui_begin_update();
+ switch (update_type)
+ {
+ case RDP_UPDATE_ORDERS:
+ process_orders(s);
+ break;
+
+ case RDP_UPDATE_BITMAP:
+ process_bitmap_updates(s);
+ break;
+
+ case RDP_UPDATE_PALETTE:
+ process_palette(s);
+ break;
+
+ case RDP_UPDATE_SYNCHRONIZE:
+ break;
+
+ default:
+ unimpl("update %d\n", update_type);
+ }
+ ui_end_update();
+}
+
+/* Process data PDU */
+void
+process_data_pdu(STREAM s)
+{
+ uint8 data_pdu_type;
+
+ in_uint8s(s, 8); /* shareid, pad, streamid, length */
+ in_uint8(s, data_pdu_type);
+ in_uint8s(s, 3); /* compress_type, compress_len */
+
+ switch (data_pdu_type)
+ {
+ case RDP_DATA_PDU_UPDATE:
+ process_update_pdu(s);
+ break;
+
+ case RDP_DATA_PDU_POINTER:
+ process_pointer_pdu(s);
+ break;
+
+ case RDP_DATA_PDU_BELL:
+ ui_bell();
+ break;
+
+ case RDP_DATA_PDU_LOGON:
+ /* User logged on */
+ break;
+
+ default:
+ unimpl("data PDU %d\n", data_pdu_type);
+ }
+}
+
+/* Process incoming packets */
+BOOL
+rdp_main_loop(void)
+{
+ uint8 type;
+ STREAM s;
+ BOOL cont = True;
+ while (cont)
+ {
+ s = rdp_recv(&type);
+ if (s == NULL)
+ return False;
+ switch (type)
+ {
+ case RDP_PDU_DEMAND_ACTIVE:
+ process_demand_active(s);
+ break;
+ case RDP_PDU_DEACTIVATE:
+ break;
+ case RDP_PDU_DATA:
+ process_data_pdu(s);
+ break;
+ case 0:
+ break;
+ default:
+ unimpl("PDU %d\n", type);
+ }
+ cont = next_packet < s->end;
+ }
+ return True;
+}
+
+/* Establish a connection up to the RDP layer */
+BOOL
+rdp_connect(char *server, uint32 flags, char *domain, char *password,
+ char *command, char *directory)
+{
+ if (!sec_connect(server))
+ return False;
+
+ rdp_send_logon_info(flags, domain, username, password, command, directory);
+ return True;
+}
+
+/* Disconnect from the RDP layer */
+void
+rdp_disconnect(void)
+{
+ sec_disconnect();
+}
diff --git a/noncore/net/opierdesktop/secure.cpp b/noncore/net/opierdesktop/secure.cpp
new file mode 100644
index 0000000..5e50f8d
--- a/dev/null
+++ b/noncore/net/opierdesktop/secure.cpp
@@ -0,0 +1,658 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Protocol services - RDP encryption and licensing
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include "rdesktop.h"
+
+//#ifdef WITH_OPENSSL
+#include <openssl/rc4.h>
+#include <openssl/md5.h>
+#include <openssl/sha.h>
+#include <openssl/bn.h>
+//#else
+//#include "crypto/rc4.h"
+//#include "crypto/md5.h"
+//#include "crypto/sha.h"
+//#include "crypto/bn.h"
+//#endif
+
+extern char hostname[16];
+extern int g_width;
+extern int g_height;
+extern int keylayout;
+extern BOOL encryption;
+extern BOOL licence_issued;
+extern int server_bpp;
+
+static int rc4_key_len;
+static RC4_KEY rc4_decrypt_key;
+static RC4_KEY rc4_encrypt_key;
+
+static uint8 sec_sign_key[16];
+static uint8 sec_decrypt_key[16];
+static uint8 sec_encrypt_key[16];
+static uint8 sec_decrypt_update_key[16];
+static uint8 sec_encrypt_update_key[16];
+static uint8 sec_crypted_random[SEC_MODULUS_SIZE];
+
+/*
+ * General purpose 48-byte transformation, using two 32-byte salts (generally,
+ * a client and server salt) and a global salt value used for padding.
+ * Both SHA1 and MD5 algorithms are used.
+ */
+void
+sec_hash_48(uint8 * out, uint8 * in, uint8 * salt1, uint8 * salt2, uint8 salt)
+{
+ uint8 shasig[20];
+ uint8 pad[4];
+ SHA_CTX sha;
+ MD5_CTX md5;
+ int i;
+
+ for (i = 0; i < 3; i++)
+ {
+ memset(pad, salt + i, i + 1);
+
+ SHA1_Init(&sha);
+ SHA1_Update(&sha, pad, i + 1);
+ SHA1_Update(&sha, in, 48);
+ SHA1_Update(&sha, salt1, 32);
+ SHA1_Update(&sha, salt2, 32);
+ SHA1_Final(shasig, &sha);
+
+ MD5_Init(&md5);
+ MD5_Update(&md5, in, 48);
+ MD5_Update(&md5, shasig, 20);
+ MD5_Final(&out[i * 16], &md5);
+ }
+}
+
+/*
+ * Weaker 16-byte transformation, also using two 32-byte salts, but
+ * only using a single round of MD5.
+ */
+void
+sec_hash_16(uint8 * out, uint8 * in, uint8 * salt1, uint8 * salt2)
+{
+ MD5_CTX md5;
+
+ MD5_Init(&md5);
+ MD5_Update(&md5, in, 16);
+ MD5_Update(&md5, salt1, 32);
+ MD5_Update(&md5, salt2, 32);
+ MD5_Final(out, &md5);
+}
+
+/* Reduce key entropy from 64 to 40 bits */
+static void
+sec_make_40bit(uint8 * key)
+{
+ key[0] = 0xd1;
+ key[1] = 0x26;
+ key[2] = 0x9e;
+}
+
+/* Generate a session key and RC4 keys, given client and server randoms */
+static void
+sec_generate_keys(uint8 * client_key, uint8 * server_key, int rc4_key_size)
+{
+ uint8 session_key[48];
+ uint8 temp_hash[48];
+ uint8 input[48];
+
+ /* Construct input data to hash */
+ memcpy(input, client_key, 24);
+ memcpy(input + 24, server_key, 24);
+
+ /* Generate session key - two rounds of sec_hash_48 */
+ sec_hash_48(temp_hash, input, client_key, server_key, 65);
+ sec_hash_48(session_key, temp_hash, client_key, server_key, 88);
+
+ /* Store first 16 bytes of session key, for generating signatures */
+ memcpy(sec_sign_key, session_key, 16);
+
+ /* Generate RC4 keys */
+ sec_hash_16(sec_decrypt_key, &session_key[16], client_key, server_key);
+ sec_hash_16(sec_encrypt_key, &session_key[32], client_key, server_key);
+
+ if (rc4_key_size == 1)
+ {
+ DEBUG(("40-bit encryption enabled\n"));
+ sec_make_40bit(sec_sign_key);
+ sec_make_40bit(sec_decrypt_key);
+ sec_make_40bit(sec_encrypt_key);
+ rc4_key_len = 8;
+ }
+ else
+ {
+ DEBUG(("128-bit encryption enabled\n"));
+ rc4_key_len = 16;
+ }
+
+ /* Save initial RC4 keys as update keys */
+ memcpy(sec_decrypt_update_key, sec_decrypt_key, 16);
+ memcpy(sec_encrypt_update_key, sec_encrypt_key, 16);
+
+ /* Initialise RC4 state arrays */
+ RC4_set_key(&rc4_decrypt_key, rc4_key_len, sec_decrypt_key);
+ RC4_set_key(&rc4_encrypt_key, rc4_key_len, sec_encrypt_key);
+}
+
+static uint8 pad_54[40] = {
+ 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
+ 54, 54, 54,
+ 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
+ 54, 54, 54
+};
+
+static uint8 pad_92[48] = {
+ 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
+ 92, 92, 92, 92, 92, 92, 92,
+ 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
+ 92, 92, 92, 92, 92, 92, 92
+};
+
+/* Output a uint32 into a buffer (little-endian) */
+void
+buf_out_uint32(uint8 * buffer, uint32 value)
+{
+ buffer[0] = (value) & 0xff;
+ buffer[1] = (value >> 8) & 0xff;
+ buffer[2] = (value >> 16) & 0xff;
+ buffer[3] = (value >> 24) & 0xff;
+}
+
+/* Generate a signature hash, using a combination of SHA1 and MD5 */
+void
+sec_sign(uint8 * signature, int siglen, uint8 * session_key, int keylen, uint8 * data, int datalen)
+{
+ uint8 shasig[20];
+ uint8 md5sig[16];
+ uint8 lenhdr[4];
+ SHA_CTX sha;
+ MD5_CTX md5;
+
+ buf_out_uint32(lenhdr, datalen);
+
+ SHA1_Init(&sha);
+ SHA1_Update(&sha, session_key, keylen);
+ SHA1_Update(&sha, pad_54, 40);
+ SHA1_Update(&sha, lenhdr, 4);
+ SHA1_Update(&sha, data, datalen);
+ SHA1_Final(shasig, &sha);
+
+ MD5_Init(&md5);
+ MD5_Update(&md5, session_key, keylen);
+ MD5_Update(&md5, pad_92, 48);
+ MD5_Update(&md5, shasig, 20);
+ MD5_Final(md5sig, &md5);
+
+ memcpy(signature, md5sig, siglen);
+}
+
+/* Update an encryption key - similar to the signing process */
+static void
+sec_update(uint8 * key, uint8 * update_key)
+{
+ uint8 shasig[20];
+ SHA_CTX sha;
+ MD5_CTX md5;
+ RC4_KEY update;
+
+ SHA1_Init(&sha);
+ SHA1_Update(&sha, update_key, rc4_key_len);
+ SHA1_Update(&sha, pad_54, 40);
+ SHA1_Update(&sha, key, rc4_key_len);
+ SHA1_Final(shasig, &sha);
+
+ MD5_Init(&md5);
+ MD5_Update(&md5, update_key, rc4_key_len);
+ MD5_Update(&md5, pad_92, 48);
+ MD5_Update(&md5, shasig, 20);
+ MD5_Final(key, &md5);
+
+ RC4_set_key(&update, rc4_key_len, key);
+ RC4(&update, rc4_key_len, key, key);
+
+ if (rc4_key_len == 8)
+ sec_make_40bit(key);
+}
+
+/* Encrypt data using RC4 */
+static void
+sec_encrypt(uint8 * data, int length)
+{
+ static int use_count;
+
+ if (use_count == 4096)
+ {
+ sec_update(sec_encrypt_key, sec_encrypt_update_key);
+ RC4_set_key(&rc4_encrypt_key, rc4_key_len, sec_encrypt_key);
+ use_count = 0;
+ }
+
+ RC4(&rc4_encrypt_key, length, data, data);
+ use_count++;
+}
+
+/* Decrypt data using RC4 */
+static void
+sec_decrypt(uint8 * data, int length)
+{
+ static int use_count;
+
+ if (use_count == 4096)
+ {
+ sec_update(sec_decrypt_key, sec_decrypt_update_key);
+ RC4_set_key(&rc4_decrypt_key, rc4_key_len, sec_decrypt_key);
+ use_count = 0;
+ }
+
+ RC4(&rc4_decrypt_key, length, data, data);
+ use_count++;
+}
+
+static void
+reverse(uint8 * p, int len)
+{
+ int i, j;
+ uint8 temp;
+
+ for (i = 0, j = len - 1; i < j; i++, j--)
+ {
+ temp = p[i];
+ p[i] = p[j];
+ p[j] = temp;
+ }
+}
+
+/* Perform an RSA public key encryption operation */
+static void
+sec_rsa_encrypt(uint8 * out, uint8 * in, int len, uint8 * modulus, uint8 * exponent)
+{
+ BN_CTX *ctx;
+ BIGNUM mod, exp, x, y;
+ uint8 inr[SEC_MODULUS_SIZE];
+ int outlen;
+
+ reverse(modulus, SEC_MODULUS_SIZE);
+ reverse(exponent, SEC_EXPONENT_SIZE);
+ memcpy(inr, in, len);
+ reverse(inr, len);
+
+ ctx = BN_CTX_new();
+ BN_init(&mod);
+ BN_init(&exp);
+ BN_init(&x);
+ BN_init(&y);
+
+ BN_bin2bn(modulus, SEC_MODULUS_SIZE, &mod);
+ BN_bin2bn(exponent, SEC_EXPONENT_SIZE, &exp);
+ BN_bin2bn(inr, len, &x);
+ BN_mod_exp(&y, &x, &exp, &mod, ctx);
+ outlen = BN_bn2bin(&y, out);
+ reverse(out, outlen);
+ if (outlen < SEC_MODULUS_SIZE)
+ memset(out + outlen, 0, SEC_MODULUS_SIZE - outlen);
+
+ BN_free(&y);
+ BN_clear_free(&x);
+ BN_free(&exp);
+ BN_free(&mod);
+ BN_CTX_free(ctx);
+}
+
+/* Initialise secure transport packet */
+STREAM
+sec_init(uint32 flags, int maxlen)
+{
+ int hdrlen;
+ STREAM s;
+
+ if (!licence_issued)
+ hdrlen = (flags & SEC_ENCRYPT) ? 12 : 4;
+ else
+ hdrlen = (flags & SEC_ENCRYPT) ? 12 : 0;
+ s = mcs_init(maxlen + hdrlen);
+ s_push_layer(s, sec_hdr, hdrlen);
+
+ return s;
+}
+
+/* Transmit secure transport packet */
+void
+sec_send(STREAM s, uint32 flags)
+{
+ int datalen;
+
+ s_pop_layer(s, sec_hdr);
+ if (!licence_issued || (flags & SEC_ENCRYPT))
+ out_uint32_le(s, flags);
+
+ if (flags & SEC_ENCRYPT)
+ {
+ flags &= ~SEC_ENCRYPT;
+ datalen = s->end - s->p - 8;
+
+#if WITH_DEBUG
+ DEBUG(("Sending encrypted packet:\n"));
+ hexdump(s->p + 8, datalen);
+#endif
+
+ sec_sign(s->p, 8, sec_sign_key, rc4_key_len, s->p + 8, datalen);
+ sec_encrypt(s->p + 8, datalen);
+ }
+
+ mcs_send(s);
+}
+
+/* Transfer the client random to the server */
+static void
+sec_establish_key(void)
+{
+ uint32 length = SEC_MODULUS_SIZE + SEC_PADDING_SIZE;
+ uint32 flags = SEC_CLIENT_RANDOM;
+ STREAM s;
+
+ s = sec_init(flags, 76);
+
+ out_uint32_le(s, length);
+ out_uint8p(s, sec_crypted_random, SEC_MODULUS_SIZE);
+ out_uint8s(s, SEC_PADDING_SIZE);
+
+ s_mark_end(s);
+ sec_send(s, flags);
+}
+
+/* Output connect initial data blob */
+static void
+sec_out_mcs_data(STREAM s)
+{
+ int hostlen = 2 * strlen(hostname);
+
+ if (hostlen > 30)
+ hostlen = 30;
+
+ out_uint16_be(s, 5); /* unknown */
+ out_uint16_be(s, 0x14);
+ out_uint8(s, 0x7c);
+ out_uint16_be(s, 1);
+
+ out_uint16_be(s, (158 | 0x8000)); /* remaining length */
+
+ out_uint16_be(s, 8); /* length? */
+ out_uint16_be(s, 16);
+ out_uint8(s, 0);
+ out_uint16_le(s, 0xc001);
+ out_uint8(s, 0);
+
+ out_uint32_le(s, 0x61637544); /* "Duca" ?! */
+ out_uint16_be(s, (144 | 0x8000)); /* remaining length */
+
+ /* Client information */
+ out_uint16_le(s, SEC_TAG_CLI_INFO);
+ out_uint16_le(s, 136); /* length */
+ out_uint16_le(s, 1);
+ out_uint16_le(s, 8);
+ out_uint16_le(s, g_width);
+ out_uint16_le(s, g_height);
+ out_uint16_le(s, 0xca01);
+ out_uint16_le(s, 0xaa03);
+ out_uint32_le(s, keylayout);
+ out_uint32_le(s, 419); /* client build? we are 419 compatible :-) */
+
+ /* Unicode name of client, padded to 32 bytes */
+ rdp_out_unistr(s, hostname, hostlen);
+ out_uint8s(s, 30 - hostlen);
+
+ out_uint32_le(s, 4);
+ out_uint32(s, 0);
+ out_uint32_le(s, 12);
+ out_uint8s(s, 64); /* reserved? 4 + 12 doublewords */
+
+ switch (server_bpp)
+ {
+ case 8:
+ out_uint16_le(s, 0xca01);
+ break;
+ case 15:
+ out_uint16_le(s, 0xca02);
+ break;
+ case 16:
+ out_uint16_le(s, 0xca03);
+ break;
+ case 24:
+ out_uint16_le(s, 0xca04);
+ break;
+ }
+ out_uint16(s, 0);
+
+ /* Client encryption settings */
+ out_uint16_le(s, SEC_TAG_CLI_CRYPT);
+ out_uint16_le(s, 8); /* length */
+ out_uint32_le(s, encryption ? 0x3 : 0); /* encryption supported, 128-bit supported */
+ s_mark_end(s);
+}
+
+/* Parse a public key structure */
+static BOOL
+sec_parse_public_key(STREAM s, uint8 ** modulus, uint8 ** exponent)
+{
+ uint32 magic, modulus_len;
+
+ in_uint32_le(s, magic);
+ if (magic != SEC_RSA_MAGIC)
+ {
+ error("RSA magic 0x%x\n", magic);
+ return False;
+ }
+
+ in_uint32_le(s, modulus_len);
+ if (modulus_len != SEC_MODULUS_SIZE + SEC_PADDING_SIZE)
+ {
+ error("modulus len 0x%x\n", modulus_len);
+ return False;
+ }
+
+ in_uint8s(s, 8); /* modulus_bits, unknown */
+ in_uint8p(s, *exponent, SEC_EXPONENT_SIZE);
+ in_uint8p(s, *modulus, SEC_MODULUS_SIZE);
+ in_uint8s(s, SEC_PADDING_SIZE);
+
+ return s_check(s);
+}
+
+/* Parse a crypto information structure */
+static BOOL
+sec_parse_crypt_info(STREAM s, uint32 * rc4_key_size,
+ uint8 ** server_random, uint8 ** modulus, uint8 ** exponent)
+{
+ uint32 crypt_level, random_len, rsa_info_len;
+ uint16 tag, length;
+ uint8 *next_tag, *end;
+
+ in_uint32_le(s, *rc4_key_size); /* 1 = 40-bit, 2 = 128-bit */
+ in_uint32_le(s, crypt_level); /* 1 = low, 2 = medium, 3 = high */
+ if (crypt_level == 0) /* no encryptation */
+ return False;
+ in_uint32_le(s, random_len);
+ in_uint32_le(s, rsa_info_len);
+
+ if (random_len != SEC_RANDOM_SIZE)
+ {
+ error("random len %d\n", random_len);
+ return False;
+ }
+
+ in_uint8p(s, *server_random, random_len);
+
+ /* RSA info */
+ end = s->p + rsa_info_len;
+ if (end > s->end)
+ return False;
+
+ in_uint8s(s, 12); /* unknown */
+
+ while (s->p < end)
+ {
+ in_uint16_le(s, tag);
+ in_uint16_le(s, length);
+
+ next_tag = s->p + length;
+
+ switch (tag)
+ {
+ case SEC_TAG_PUBKEY:
+ if (!sec_parse_public_key(s, modulus, exponent))
+ return False;
+
+ break;
+
+ case SEC_TAG_KEYSIG:
+ /* Is this a Microsoft key that we just got? */
+ /* Care factor: zero! */
+ break;
+
+ default:
+ unimpl("crypt tag 0x%x\n", tag);
+ }
+
+ s->p = next_tag;
+ }
+
+ return s_check_end(s);
+}
+
+/* Process crypto information blob */
+static void
+sec_process_crypt_info(STREAM s)
+{
+ uint8 *server_random, *modulus, *exponent;
+ uint8 client_random[SEC_RANDOM_SIZE];
+ uint32 rc4_key_size;
+
+ if (!sec_parse_crypt_info(s, &rc4_key_size, &server_random, &modulus, &exponent))
+ return;
+
+ /* Generate a client random, and hence determine encryption keys */
+ generate_random(client_random);
+ sec_rsa_encrypt(sec_crypted_random, client_random, SEC_RANDOM_SIZE, modulus, exponent);
+ sec_generate_keys(client_random, server_random, rc4_key_size);
+}
+
+/* Process connect response data blob */
+static void
+sec_process_mcs_data(STREAM s)
+{
+ uint16 tag, length;
+ uint8 *next_tag;
+ uint8 len;
+
+ in_uint8s(s, 21); /* header */
+ in_uint8(s, len);
+ if (len & 0x80)
+ in_uint8(s, len);
+
+ while (s->p < s->end)
+ {
+ in_uint16_le(s, tag);
+ in_uint16_le(s, length);
+
+ if (length <= 4)
+ return;
+
+ next_tag = s->p + length - 4;
+
+ switch (tag)
+ {
+ case SEC_TAG_SRV_INFO:
+ case SEC_TAG_SRV_3:
+ break;
+
+ case SEC_TAG_SRV_CRYPT:
+ sec_process_crypt_info(s);
+ break;
+
+ default:
+ unimpl("response tag 0x%x\n", tag);
+ }
+
+ s->p = next_tag;
+ }
+}
+
+/* Receive secure transport packet */
+STREAM
+sec_recv(void)
+{
+ uint32 sec_flags;
+ STREAM s;
+
+ while ((s = mcs_recv()) != NULL)
+ {
+ if (encryption || !licence_issued)
+ {
+ in_uint32_le(s, sec_flags);
+
+ if (sec_flags & SEC_LICENCE_NEG)
+ {
+ licence_process(s);
+ continue;
+ }
+
+ if (sec_flags & SEC_ENCRYPT)
+ {
+ in_uint8s(s, 8); /* signature */
+ sec_decrypt(s->p, s->end - s->p);
+ }
+ }
+
+ return s;
+ }
+
+ return NULL;
+}
+
+/* Establish a secure connection */
+BOOL
+sec_connect(char *server)
+{
+ struct stream mcs_data;
+
+ /* We exchange some RDP data during the MCS-Connect */
+ mcs_data.size = 512;
+ mcs_data.p = mcs_data.data = (unsigned char*)xmalloc(mcs_data.size);
+ sec_out_mcs_data(&mcs_data);
+
+ if (!mcs_connect(server, &mcs_data))
+ return False;
+
+ sec_process_mcs_data(&mcs_data);
+ if (encryption)
+ sec_establish_key();
+ xfree(mcs_data.data);
+ return True;
+}
+
+/* Disconnect a connection */
+void
+sec_disconnect(void)
+{
+ mcs_disconnect();
+}
diff --git a/noncore/net/opierdesktop/tcp.cpp b/noncore/net/opierdesktop/tcp.cpp
new file mode 100644
index 0000000..0a2ca3e
--- a/dev/null
+++ b/noncore/net/opierdesktop/tcp.cpp
@@ -0,0 +1,181 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Protocol services - TCP layer
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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.
+*/
+
+#include <unistd.h> /* select read write close */
+#include <sys/socket.h> /* socket connect setsockopt */
+#include <sys/time.h> /* timeval */
+#include <netdb.h> /* gethostbyname */
+#include <netinet/in.h> /* sockaddr_in */
+#include <netinet/tcp.h> /* TCP_NODELAY */
+#include <arpa/inet.h> /* inet_addr */
+#include <fcntl.h>
+#include <errno.h> /* errno */
+#include "rdesktop.h"
+
+#ifndef INADDR_NONE
+#define INADDR_NONE ((unsigned long) -1)
+#endif
+
+static int sock;
+static struct stream in;
+static struct stream out;
+extern int tcp_port_rdp;
+
+/* Initialise TCP transport data packet */
+STREAM
+tcp_init(unsigned int maxlen)
+{
+ if (maxlen > out.size)
+ {
+ out.data = (unsigned char*)xrealloc(out.data, maxlen);
+ out.size = maxlen;
+ }
+
+ out.p = out.data;
+ out.end = out.data + out.size;
+ return &out;
+}
+
+/* Send TCP transport data packet */
+void
+tcp_send(STREAM s)
+{
+ int length = s->end - s->data;
+ int sent, total = 0;
+
+ while (total < length)
+ {
+ sent = send(sock, s->data + total, length - total, 0);
+ if (sent == -1 && errno == EWOULDBLOCK)
+ {
+ usleep(1000);
+ }
+ else if (sent <= 0)
+ {
+ error("send: %s\n", strerror(errno));
+ return;
+ }
+ else
+ total += sent;
+ }
+}
+
+/* Receive a message on the TCP layer */
+STREAM
+tcp_recv(unsigned int length)
+{
+ int rcvd = 0;
+
+ if (length > in.size)
+ {
+ in.data = (unsigned char*)xrealloc(in.data, length);
+ in.size = length;
+ }
+
+ in.end = in.p = in.data;
+
+ while (length > 0)
+ {
+ if (!ui_select(sock))
+ /* User quit */
+ return NULL;
+
+ rcvd = recv(sock, in.end, length, 0);
+ if (rcvd == -1 && errno == EWOULDBLOCK)
+ {
+ usleep(1000);
+ }
+ else if (rcvd == -1)
+ {
+ error("recv: %s\n", strerror(errno));
+ return NULL;
+ }
+ else if (rcvd == 0)
+ return NULL;
+ else
+ {
+ in.end += rcvd;
+ length -= rcvd;
+ }
+ }
+
+ return &in;
+}
+
+/* Establish a connection on the TCP layer */
+BOOL
+tcp_connect(char *server)
+{
+ struct hostent *nslookup;
+ struct sockaddr_in servaddr;
+ int l_true = 1;
+
+ if ((nslookup = gethostbyname(server)) != NULL)
+ {
+ memcpy(&servaddr.sin_addr, nslookup->h_addr, sizeof(servaddr.sin_addr));
+ }
+ else if ((servaddr.sin_addr.s_addr = inet_addr(server)) == INADDR_NONE)
+ {
+ error("%s: unable to resolve host\n", server);
+ return False;
+ }
+
+ if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+ {
+ error("socket: %s\n", strerror(errno));
+ return False;
+ }
+
+ servaddr.sin_family = AF_INET;
+ servaddr.sin_port = htons(tcp_port_rdp);
+
+ if (connect(sock, (struct sockaddr *) &servaddr, sizeof(struct sockaddr)) < 0)
+ {
+ error("connect: %s\n", strerror(errno));
+ close(sock);
+ return False;
+ }
+
+ /* set non blocking */
+ {
+ int op;
+ op = fcntl(sock, F_GETFL);
+ op |= O_NONBLOCK;
+ fcntl(sock, F_SETFL, op);
+ }
+
+// fcntl(sock, O_NONBLOCK);
+ setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (void *) &l_true, sizeof(l_true));
+
+ in.size = 4096;
+ in.data = (unsigned char*)xmalloc(in.size);
+
+ out.size = 4096;
+ out.data = (unsigned char*)xmalloc(out.size);
+
+ return True;
+}
+
+/* Disconnect on the TCP layer */
+void
+tcp_disconnect(void)
+{
+ close(sock);
+}
diff --git a/noncore/net/opierdesktop/types.h b/noncore/net/opierdesktop/types.h
new file mode 100644
index 0000000..4cb59e6
--- a/dev/null
+++ b/noncore/net/opierdesktop/types.h
@@ -0,0 +1,110 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Common data types
+ Copyright (C) Matthew Chapman 1999-2002
+
+ 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;