internal static int berParseHeader(RdpPacket data, BER_Header eTagVal)
{
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = (int)eTagVal;
if (num4 > 0xff)
{
num = data.ReadBigEndian16();
}
else
{
num = data.ReadByte();
}
if (num != num4)
{
throw new RDFatalException("Bad tag " + num.ToString() + " but need " + eTagVal.ToString());
}
num3 = data.ReadByte();
if (num3 <= 0x80)
{
return(num3);
}
num3 -= 0x80;
num2 = 0;
while (num3-- != 0)
{
num2 = (num2 << 8) + data.ReadByte();
}
return(num2);
}
private static void parseBrush(RdpPacket data, BrushOrder brush, int present)
{
if ((present & 1) != 0)
{
brush.XOrigin = data.ReadByte();
}
if ((present & 2) != 0)
{
brush.YOrigin = data.ReadByte();
}
if ((present & 4) != 0)
{
brush.Style = data.ReadByte();
}
byte[] pattern = brush.Pattern;
if ((present & 8) != 0)
{
pattern[0] = (byte)data.ReadByte();
}
if ((present & 0x10) != 0)
{
for (int i = 1; i < 8; i++)
{
pattern[i] = (byte)data.ReadByte();
}
}
}
protected static int ReadInteger(RdpPacket packet)
{
if (packet.ReadByte() != 2)
{
throw new Exception("Data Error!");
}
int num2 = packet.ReadByte();
byte[] buffer = new byte[4];
switch (num2)
{
case 4:
packet.Read(buffer, 0, 4);
return(BitConverter.ToInt32(buffer, 0));
case 3:
packet.Read(buffer, 0, 3);
return(BitConverter.ToInt32(buffer, 0));
case 2:
packet.Read(buffer, 0, 2);
return(BitConverter.ToInt32(buffer, 0));
}
packet.Read(buffer, 0, 1);
return(BitConverter.ToInt32(buffer, 0));
}
/// <summary>
/// Server MCS Attach User Confirm PDU
/// </summary>
private static int receive_AttachUserConfirm()
{
int num, num2, num3, num4 = 0;
RdpPacket packet = ISO.ReceiveTPKTOrFastPath(out num);
num2 = packet.ReadByte();
if ((num2 >> 2) != AUCF)
{
throw new RDFatalException("Bad AUCF " + num2);
}
num3 = packet.ReadByte();
if (num3 != 0)
{
throw new RDFatalException("Bad AURQ got " + num3);
}
if ((num2 & 2) != 0)
{
num4 = packet.ReadBigEndian16();
}
if (packet.Position != packet.Length)
{
throw new RDFatalException("Illegal Aucf packet length");
}
return(num4);
}
/// <summary>
/// Server MCS Channel Join Confirm PDU
/// </summary>
private static void receive_ChannelJoinConfirm()
{
int num, num2, num3 = 0;
RdpPacket packet = ISO.ReceiveTPKTOrFastPath(out num);
num2 = packet.ReadByte();
if ((num2 >> 2) != CJCF)
{
throw new RDFatalException("Bad CJCF " + num2);
}
num3 = packet.ReadByte();
if (num3 != 0)
{
throw new RDFatalException("Bad CJRQ " + num3);
}
packet.Position += 4L;
if ((num2 & 2) != 0)
{
packet.Position += 2L;
}
if (packet.Position != packet.Length)
{
throw new RDFatalException("Incorrect CJCF length");
}
}
private static void processLine(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
LineOrder.Mixmode = data.ReadLittleEndian16();
}
if ((present & 2) != 0)
{
LineOrder.StartX = setCoordinate(data, LineOrder.StartX, delta);
}
if ((present & 4) != 0)
{
LineOrder.StartY = setCoordinate(data, LineOrder.StartY, delta);
}
if ((present & 8) != 0)
{
LineOrder.EndX = setCoordinate(data, LineOrder.EndX, delta);
}
if ((present & 0x10) != 0)
{
LineOrder.EndY = setCoordinate(data, LineOrder.EndY, delta);
}
if ((present & 0x20) != 0)
{
LineOrder.BackgroundColor = setColor(data);
}
if ((present & 0x40) != 0)
{
LineOrder.Opcode = data.ReadByte();
}
present = present >> 7;
if ((present & 1) != 0)
{
LineOrder.PenStyle = data.ReadByte();
}
if ((present & 2) != 0)
{
LineOrder.PenWidth = data.ReadByte();
}
if ((present & 4) != 0)
{
LineOrder.PenColor = setColor(data);
}
LineOrder.drawLineOrder();
}
private static int setColor(RdpPacket data)
{
int num = 0;
int num2 = 0;
num = data.ReadByte();
num2 = data.ReadByte();
num |= num2 << 8;
num2 = data.ReadByte();
return(num | (num2 << 0x10));
}
/// <summary>
/// Server MCS Connect Response PDU with GCC Conference Create Response
/// Part 2.
///
/// serverCoreData
/// serverSecurityData
/// serverNetworkData
/// serverMessageChannelData
/// </summary>
private static void processMcsData(RdpPacket mcsData)
{
int num = 0;
int num2 = 0;
int num3 = 0;
mcsData.Position += 0x15L;
if ((mcsData.ReadByte() & 0x80) != 0)
{
mcsData.ReadByte();
}
while (mcsData.Position < mcsData.Length)
{
num = mcsData.ReadLittleEndian16();
num2 = mcsData.ReadLittleEndian16();
if (num2 <= 4)
{
return;
}
num3 = (int)((mcsData.Position + num2) - 4L);
switch ((SERVER)num)
{
case SERVER.SC_CORE:
processSrvCoreInfo(mcsData);
break;
case SERVER.SC_SECURITY:
Secure.processCryptInfo(mcsData);
break;
case SERVER.SC_NET:
processSrvNetInfo(mcsData);
break;
case SERVER.SC_MCS_MSGCHANNEL:
int channel = mcsData.ReadLittleEndian16();
Debug.WriteLine("Network Characteristics Detection channel: " + channel);
//Channels.RegisteredChannels.Add(new NetworkCharacteristicsDetection(channel));
break;
default:
throw new RDFatalException("MSC data incorrect tag " + num.ToString());
}
mcsData.Position = num3;
}
}
private static void processMultiPatBlt(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
MultiPatBltOrder.X = setCoordinate(data, MultiPatBltOrder.X, delta);
}
if ((present & 2) != 0)
{
MultiPatBltOrder.Y = setCoordinate(data, MultiPatBltOrder.Y, delta);
}
if ((present & 4) != 0)
{
MultiPatBltOrder.CX = setCoordinate(data, MultiPatBltOrder.CX, delta);
}
if ((present & 8) != 0)
{
MultiPatBltOrder.CY = setCoordinate(data, MultiPatBltOrder.CY, delta);
}
if ((present & 0x10) != 0)
{
MultiPatBltOrder.Opcode = ROP2_P(data.ReadByte());
}
if ((present & 0x20) != 0)
{
MultiPatBltOrder.BackgroundColor = setColor(data);
}
if ((present & 0x40) != 0)
{
MultiPatBltOrder.ForegroundColor = setColor(data);
}
parseBrush(data, MultiPatBltOrder.Brush, present >> 7);
if ((present & 0x1000) != 0)
{
MultiPatBltOrder.DeltaEntries = data.ReadByte();
}
if ((present & 0x2000) != 0)
{
MultiPatBltOrder.DeltaList = readEncodedDeltaRects(data, MultiPatBltOrder.DeltaEntries);
}
MultiPatBltOrder.drawMultiPatBltOrder();
}
internal static RdpPacket ReceiveMCS(out int channel, out int type)
{
int num = 0;
int num2 = 0;
RdpPacket packet = ReceiveTPKTOrFastPath(out type);
//Debug.WriteLine("ReceiveTPKTO Type: " + type.ToString());
if ((type == 0xff) || (type == 0xfe))
{
channel = MCS.MSC_GLOBAL_CHANNEL;
return(packet);
}
if (type != 240)
{
throw new RDFatalException("Illegal data type " + ((int)type).ToString());
}
if (packet == null)
{
channel = -1;
return(null);
}
num = packet.ReadByte();
num2 = num >> 2;
if (num2 != MCS.SDIN)
{
if (num2 != MCS.DPUM)
{
throw new RDFatalException("Illegal data opcode " + num.ToString());
}
throw new EndOfTransmissionException("End of transmission!");
}
packet.Position += 2L;
channel = packet.ReadBigEndian16();
packet.ReadByte();
if ((packet.ReadByte() & 0x80) != 0)
{
packet.Position += 1L;
}
//Debug.WriteLine("Packet recived. Channel: " + channel);
return(packet);
}
private static void processFontCache(RdpPacket data, int extraFlags)
{
int font = 0;
int num2 = 0;
int character = 0;
int offset = 0;
int baseline = 0;
int width = 0;
int height = 0;
int count = 0;
byte[] buffer = null;
int num9 = (extraFlags >> 4) & 15;
if ((num9 & 2) != 0)
{
font = extraFlags & 15;
num2 = extraFlags >> 8;
}
else
{
font = data.ReadByte();
num2 = data.ReadByte();
}
for (int i = 0; i < num2; i++)
{
if ((num9 & 2) != 0)
{
character = data.ReadByte();
offset = data.ReadEncodedSigned16();
baseline = data.ReadEncodedSigned16();
width = data.ReadEncodedUnsigned16();
height = data.ReadEncodedUnsigned16();
}
else
{
character = data.ReadLittleEndian16();
offset = data.ReadLittleEndian16();
baseline = data.ReadLittleEndian16();
width = data.ReadLittleEndian16();
height = data.ReadLittleEndian16();
}
count = ((height * ((width + 7) / 8)) + 3) & -4;
buffer = new byte[count];
data.Read(buffer, 0, count);
Glyph glyph = new Glyph(font, character, offset, baseline, width, height, buffer);
Cache.putFont(glyph);
}
}
private static void processMemBlt(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
MemBltOrder.CacheID = data.ReadByte();
MemBltOrder.ColorTable = data.ReadByte();
}
if ((present & 2) != 0)
{
MemBltOrder.X = setCoordinate(data, MemBltOrder.X, delta);
}
if ((present & 4) != 0)
{
MemBltOrder.Y = setCoordinate(data, MemBltOrder.Y, delta);
}
if ((present & 8) != 0)
{
MemBltOrder.CX = setCoordinate(data, MemBltOrder.CX, delta);
}
if ((present & 0x10) != 0)
{
MemBltOrder.CY = setCoordinate(data, MemBltOrder.CY, delta);
}
if ((present & 0x20) != 0)
{
MemBltOrder.Opcode = ROP2_S(data.ReadByte());
}
if ((present & 0x40) != 0)
{
MemBltOrder.SrcX = setCoordinate(data, MemBltOrder.SrcX, delta);
}
if ((present & 0x80) != 0)
{
MemBltOrder.SrcY = setCoordinate(data, MemBltOrder.SrcY, delta);
}
if ((present & 0x100) != 0)
{
MemBltOrder.CacheIDX = data.ReadLittleEndian16();
}
MemBltOrder.drawMemBltOrder();
}
/// <summary>
/// Server MCS Connect Response PDU with GCC Conference Create Response
/// Part 1
/// </summary>
private static void receiveConnectResponse()
{
string[] strArray = new string[]
{
"Successful",
"Domain Merging",
"Domain not Hierarchical",
"No Such Channel",
"No Such Domain",
"No Such User",
"Not Admitted",
"Other User ID",
"Parameters Unacceptable",
"Token Not Available",
"Token Not Possessed",
"Too Many Channels",
"Too Many Tokens",
"Too Many Users",
"Unspecified Failure",
"User Rejected"
};
RdpPacket data = ISO.Receive();
data.ReadByte();
int num = data.ReadByte();
if (num != 240)
{
throw new RDFatalException("Bad connection response packet type " + num.ToString());
}
data.ReadByte();
int index = 0;
index = BER.berParseHeader(data, BER.BER_Header.CONNECT_RESPONSE);
index = BER.berParseHeader(data, BER.BER_Header.BER_TAG_RESULT);
index = data.ReadByte();
if (index != 0)
{
throw new RDFatalException("MCS failed " + strArray[index].ToString());
}
index = BER.berParseHeader(data, BER.BER_Header.BER_TAG_INTEGER);
index = data.ReadByte();
parseDomainParams(data);
index = BER.berParseHeader(data, BER.BER_Header.BER_TAG_OCTET_STRING);
processMcsData(data);
}
/// <summary>
/// Server X.224 Connection Confirm PDU
/// </summary>
private static int receiveConnectNegotiation()
{
RdpPacket packet = ISO.Receive();
packet.Position += 7L;
if (packet.Position >= packet.Length)
{
return(0);
}
switch (packet.ReadByte())
{
// TYPE_RDP_NEG_RSP
case 0x02:
Options.serverNegotiateFlags = (NegotiationFlags)packet.ReadByte();
packet.ReadLittleEndian16();
return(packet.ReadLittleEndian32());
// TYPE_RDP_NEG_FAILURE
case 0x03:
packet.ReadByte();
packet.ReadLittleEndian16();
switch ((NegotiationFailureCodes)packet.ReadLittleEndian32())
{
case NegotiationFailureCodes.SSL_REQUIRED_BY_SERVER:
throw new RDFatalException("The server requires that the client support Enhanced RDP Security with TLS 1.0");
case NegotiationFailureCodes.SSL_NOT_ALLOWED_BY_SERVER:
return(0x10000000);
case NegotiationFailureCodes.SSL_CERT_NOT_ON_SERVER:
throw new RDFatalException("The server does not possess a valid authentication certificate and cannot initialize the External Security Protocol Provider");
case NegotiationFailureCodes.INCONSISTENT_FLAGS:
throw new RDFatalException("The list of requested security protocols is not consistent with the current security protocol in effect.");
case NegotiationFailureCodes.HYBRID_REQUIRED_BY_SERVER:
throw new RDFatalException("The server requires that the client support Enhanced RDP Security with CredSSP");
case NegotiationFailureCodes.SSL_WITH_USER_AUTH_REQUIRED_BY_SERVER:
throw new RDFatalException("The server requires that the client support Enhanced RDP Security and certificate-based client authentication");
}
throw new RDFatalException("Unknown Negotiation failure!");
}
throw new RDFatalException("Negotiation failed, requested security level not supported by server.");
}
private static void processMultiRectangle(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
MultiRectangleOrder.X = setCoordinate(data, MultiRectangleOrder.X, delta);
}
if ((present & 2) != 0)
{
MultiRectangleOrder.Y = setCoordinate(data, MultiRectangleOrder.Y, delta);
}
if ((present & 4) != 0)
{
MultiRectangleOrder.CX = setCoordinate(data, MultiRectangleOrder.CX, delta);
}
if ((present & 8) != 0)
{
MultiRectangleOrder.CY = setCoordinate(data, MultiRectangleOrder.CY, delta);
}
if ((present & 0x10) != 0)
{
MultiRectangleOrder.ColourR = data.ReadByte();
}
if ((present & 0x20) != 0)
{
MultiRectangleOrder.ColourG = data.ReadByte();
}
if ((present & 0x40) != 0)
{
MultiRectangleOrder.ColourB = data.ReadByte();
}
if ((present & 0x80) != 0)
{
MultiRectangleOrder.DeltaEntries = data.ReadByte();
}
if ((present & 0x100) != 0)
{
MultiRectangleOrder.DeltaList = readEncodedDeltaRects(data, MultiRectangleOrder.DeltaEntries);
}
MultiRectangleOrder.drawMultiRectangleOrder();
}
private static void processMultiScreenBlt(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
MultiScreenBltOrder.X = setCoordinate(data, MultiScreenBltOrder.X, delta);
}
if ((present & 2) != 0)
{
MultiScreenBltOrder.Y = setCoordinate(data, MultiScreenBltOrder.Y, delta);
}
if ((present & 4) != 0)
{
MultiScreenBltOrder.CX = setCoordinate(data, MultiScreenBltOrder.CX, delta);
}
if ((present & 8) != 0)
{
MultiScreenBltOrder.CY = setCoordinate(data, MultiScreenBltOrder.CY, delta);
}
if ((present & 0x10) != 0)
{
MultiScreenBltOrder.Opcode = ROP2_S(data.ReadByte());
}
if ((present & 0x20) != 0)
{
MultiScreenBltOrder.SrcX = setCoordinate(data, MultiScreenBltOrder.SrcX, delta);
}
if ((present & 0x40) != 0)
{
MultiScreenBltOrder.SrcY = setCoordinate(data, MultiScreenBltOrder.SrcY, delta);
}
if ((present & 0x80) != 0)
{
MultiScreenBltOrder.DeltaEntries = data.ReadByte();
}
if ((present & 0x100) != 0)
{
MultiScreenBltOrder.DeltaList = readEncodedDeltaRects(data, MultiScreenBltOrder.DeltaEntries);
}
MultiScreenBltOrder.drawMultiScreenBltOrder();
}
private static void processColorCache(RdpPacket data)
{
byte[] buffer = null;
byte[] r = null;
byte[] g = null;
byte[] b = null;
int index = 0;
int num2 = data.ReadByte();
int count = data.ReadLittleEndian16();
buffer = new byte[count * 4];
r = new byte[count];
g = new byte[count];
b = new byte[count];
data.Read(buffer, 0, buffer.Length);
for (int i = 0; i < count; i++)
{
b[i] = buffer[index];
g[i] = buffer[index + 1];
r[i] = buffer[index + 2];
index += 4;
}
Cache.put_colourmap(num2, new Palette(8, count, r, g, b));
}
private static void processDestBlt(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
DestBltOrder.X = setCoordinate(data, DestBltOrder.X, delta);
}
if ((present & 2) != 0)
{
DestBltOrder.Y = setCoordinate(data, DestBltOrder.Y, delta);
}
if ((present & 4) != 0)
{
DestBltOrder.CX = setCoordinate(data, DestBltOrder.CX, delta);
}
if ((present & 8) != 0)
{
DestBltOrder.CY = setCoordinate(data, DestBltOrder.CY, delta);
}
if ((present & 0x10) != 0)
{
DestBltOrder.Opcode = ROP2_S(data.ReadByte());
}
DestBltOrder.drawDestBltOrder();
}
private static int inPresent(RdpPacket data, int flags, int size)
{
int num = 0;
int num2 = 0;
int num3 = 0;
if ((flags & 0x40) != 0)
{
size--;
}
if ((flags & 0x80) != 0)
{
if (size < 2)
{
size = 0;
}
else
{
size -= 2;
}
}
for (num3 = 0; num3 < size; num3++)
{
num2 = data.ReadByte();
num |= num2 << (num3 * 8);
}
return(num);
}
protected static int ReadTag(RdpPacket packet, string Identifier)
{
int num = packet.ReadByte();
ReadLength(packet, Identifier);
return(num);
}
private static void processPolyLine(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
PolylineOrder.X = setCoordinate(data, PolylineOrder.X, delta);
}
if ((present & 2) != 0)
{
PolylineOrder.Y = setCoordinate(data, PolylineOrder.Y, delta);
}
if ((present & 4) != 0)
{
PolylineOrder.Opcode = data.ReadByte();
}
if ((present & 8) != 0)
{
data.ReadLittleEndian16();
}
if ((present & 0x10) != 0)
{
PolylineOrder.PenColor = setColor(data);
}
if ((present & 0x20) != 0)
{
PolylineOrder.Lines = data.ReadByte();
}
if ((present & 0x40) != 0)
{
int num = data.ReadByte();
PolylineOrder.DataSize = num;
byte[] buffer = new byte[num];
data.Read(buffer, 0, buffer.Length);
PolylineOrder.Data = buffer;
}
PolylineOrder.drawPolyLineOrder();
}
protected static int ReadTag(RdpPacket packet, int ExpectedTag, string Identifier)
{
int num = packet.ReadByte();
if (num != ExpectedTag)
{
throw new Exception(string.Concat(new object[] { "Expected DER tag ", ExpectedTag, " but got ", num }));
}
return(ReadLength(packet, Identifier));
}
private static void processRectangle(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
RectangleOrder.X = setCoordinate(data, RectangleOrder.X, delta);
}
if ((present & 2) != 0)
{
RectangleOrder.Y = setCoordinate(data, RectangleOrder.Y, delta);
}
if ((present & 4) != 0)
{
RectangleOrder.CX = setCoordinate(data, RectangleOrder.CX, delta);
}
if ((present & 8) != 0)
{
RectangleOrder.CY = setCoordinate(data, RectangleOrder.CY, delta);
}
if ((present & 0x10) != 0)
{
RectangleOrder.ColourR = data.ReadByte();
}
if ((present & 0x20) != 0)
{
RectangleOrder.ColourG = data.ReadByte();
}
if ((present & 0x40) != 0)
{
RectangleOrder.ColourB = data.ReadByte();
}
RectangleOrder.drawRectangleOrder();
}
internal static void Print(RdpPacket data)
{
data.Position = 0L;
int count = 0;
for (int i = 0; i < data.Length; i++)
{
if (count == 16)
{
count = 0;
Debug.Write(string.Format("0x{0:X02}", (short)data.ReadByte()).ToLower() + "\r\n");
}
else
{
Debug.Write(string.Format("0x{0:X02}", (short)data.ReadByte()).ToLower() + " ");
}
count++;
}
}
internal static RdpPacket Receive()
{
byte[] buffer = new byte[0x3000];
int count = Network.Receive(buffer);
RdpPacket packet = new RdpPacket();
packet.Write(buffer, 0, count);
packet.Position = 0L;
int num2 = 0;
if (packet.ReadByte() == 3)
{
packet.ReadByte();
num2 = packet.ReadBigEndian16();
long position = packet.Position;
while (num2 > count)
{
int num4 = Network.Receive(buffer);
packet.Position = count;
packet.Write(buffer, 0, num4);
count += num4;
}
packet.Position = position;
return(packet);
}
num2 = packet.ReadByte();
if ((num2 & 0x80) != 0)
{
num2 &= -129;
num2 = num2 << (8 + packet.ReadByte());
}
return(packet);
}
internal static void process(RdpPacket data)
{
int num = 0;
num = data.ReadByte();
data.ReadByte();
data.ReadLittleEndian16();
switch (num)
{
case 1:
process_demand(data);
return;
case 2:
process_authreq(data);
return;
case 3:
process_issue(data);
m_bLicensed = true;
return;
case 4:
m_bLicensed = true;
return;
case 0xff:
data.ReadLittleEndian32();
data.ReadLittleEndian32();
data.ReadLittleEndian16();
data.ReadLittleEndian16();
m_bLicensed = true;
return;
}
}
private static int setCoordinate(RdpPacket data, int coordinate, bool delta)
{
sbyte num = 0;
if (delta)
{
num = (sbyte)data.ReadByte();
coordinate += num;
return(coordinate);
}
coordinate = data.ReadLittleEndian16();
return(coordinate);
}
private static void parseBounds(RdpPacket data)
{
int num = 0;
num = data.ReadByte();
if ((num & 1) != 0)
{
SurfaceClip.Left = setCoordinate(data, SurfaceClip.Left, false);
}
else if ((num & 0x10) != 0)
{
SurfaceClip.Left = setCoordinate(data, SurfaceClip.Left, true);
}
if ((num & 2) != 0)
{
SurfaceClip.Top = setCoordinate(data, SurfaceClip.Top, false);
}
else if ((num & 0x20) != 0)
{
SurfaceClip.Top = setCoordinate(data, SurfaceClip.Top, true);
}
if ((num & 4) != 0)
{
SurfaceClip.Right = setCoordinate(data, SurfaceClip.Right, false);
}
else if ((num & 0x40) != 0)
{
SurfaceClip.Right = setCoordinate(data, SurfaceClip.Right, true);
}
if ((num & 8) != 0)
{
SurfaceClip.Bottom = setCoordinate(data, SurfaceClip.Bottom, false);
}
else if ((num & 0x80) != 0)
{
SurfaceClip.Bottom = setCoordinate(data, SurfaceClip.Bottom, true);
}
if (data.Position > data.Length)
{
throw new RDFatalException("Bad order bound packet flags!");
}
}
private static void processDeskSave(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
DeskSaveOrder.Offset = data.ReadLittleEndian32();
}
if ((present & 2) != 0)
{
DeskSaveOrder.Left = setCoordinate(data, DeskSaveOrder.Left, delta);
}
if ((present & 4) != 0)
{
DeskSaveOrder.Top = setCoordinate(data, DeskSaveOrder.Top, delta);
}
if ((present & 8) != 0)
{
DeskSaveOrder.Right = setCoordinate(data, DeskSaveOrder.Right, delta);
}
if ((present & 0x10) != 0)
{
DeskSaveOrder.Bottom = setCoordinate(data, DeskSaveOrder.Bottom, delta);
}
if ((present & 0x20) != 0)
{
DeskSaveOrder.Action = data.ReadByte();
}
int cx = (DeskSaveOrder.Right - DeskSaveOrder.Left) + 1;
int cy = (DeskSaveOrder.Bottom - DeskSaveOrder.Top) + 1;
if (DeskSaveOrder.Action == 0)
{
int[] numArray = Options.Canvas.GetPixels(DeskSaveOrder.Left, DeskSaveOrder.Top, cx, cy);
Cache.putDesktop(DeskSaveOrder.Offset, cx, cy, numArray);
}
else
{
int[] src = Cache.getDesktopInt(DeskSaveOrder.Offset, cx, cy);
Options.Canvas.SetPixels(DeskSaveOrder.Left, DeskSaveOrder.Top, cx, cy, src, 0, 0, cx);
}
}
private static void processPatBlt(RdpPacket data, int present, bool delta)
{
if ((present & 1) != 0)
{
PatBltOrder.X = setCoordinate(data, PatBltOrder.X, delta);
}
if ((present & 2) != 0)
{
PatBltOrder.Y = setCoordinate(data, PatBltOrder.Y, delta);
}
if ((present & 4) != 0)
{
PatBltOrder.CX = setCoordinate(data, PatBltOrder.CX, delta);
}
if ((present & 8) != 0)
{
PatBltOrder.CY = setCoordinate(data, PatBltOrder.CY, delta);
}
if ((present & 0x10) != 0)
{
PatBltOrder.Opcode = ROP2_P(data.ReadByte());
}
if ((present & 0x20) != 0)
{
PatBltOrder.BackgroundColor = setColor(data);
}
if ((present & 0x40) != 0)
{
PatBltOrder.ForegroundColor = setColor(data);
}
parseBrush(data, PatBltOrder.Brush, present >> 7);
PatBltOrder.drawPatBltOrder();
}
