mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
171 lines
4.8 KiB
C#
171 lines
4.8 KiB
C#
// System.Runtime.Remoting.Channels.Simple.SimpleMessageFormat.cs
|
|
//
|
|
// Author:
|
|
// DietmarMaurer ([email protected])
|
|
//
|
|
// (C) 2002 Ximian, Inc. http://www.ximian.com
|
|
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System.Runtime.Serialization.Formatters;
|
|
using System.Runtime.Serialization;
|
|
using System.Reflection;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Runtime.Remoting.Messaging;
|
|
|
|
namespace System.Runtime.Remoting.Channels.Simple {
|
|
|
|
public sealed class SimpleMessageFormat
|
|
{
|
|
public enum MessageType : byte {
|
|
Request = 0,
|
|
Response = 1,
|
|
Exception = 2,
|
|
Unknown = 3
|
|
}
|
|
|
|
public SimpleMessageFormat ()
|
|
{
|
|
}
|
|
|
|
public static void SendExceptionMessage (Stream network_stream, string message)
|
|
{
|
|
// we use the uri field to encode the message text
|
|
SendMessageStream (network_stream, null, MessageType.Exception, message);
|
|
}
|
|
|
|
public static void SendMessageStream (Stream network_stream, MemoryStream data,
|
|
MessageType msg_type, string uri)
|
|
{
|
|
int data_len = 0;
|
|
|
|
if (data != null)
|
|
data_len = (int)data.Length;
|
|
|
|
int uri_len = 0;
|
|
|
|
if (uri != null)
|
|
uri_len = uri.Length;
|
|
|
|
int header_len = 12 + uri_len * 2;
|
|
int msg_len = data_len + header_len;
|
|
|
|
byte [] buffer = new byte [msg_len];
|
|
|
|
// magic header signature
|
|
buffer [0] = 255;
|
|
buffer [1] = 0;
|
|
buffer [2] = 255;
|
|
buffer [3] = (byte) msg_type;
|
|
|
|
// data length
|
|
buffer [4] = (byte) data_len;
|
|
buffer [5] = (byte) (data_len >> 8);
|
|
buffer [6] = (byte) (data_len >> 16);
|
|
buffer [7] = (byte) (data_len >> 24);
|
|
|
|
// uri length
|
|
buffer [8] = (byte) uri_len;
|
|
buffer [9] = (byte) (uri_len >> 8);
|
|
buffer [10] = (byte) (uri_len >> 16);
|
|
buffer [11] = (byte) (uri_len >> 24);
|
|
|
|
// uri
|
|
for (int i = 0; i < uri_len; i++) {
|
|
buffer [12 + i*2] = (byte) uri [i];
|
|
buffer [13 + i*2] = (byte) (uri [i] >> 8);
|
|
}
|
|
|
|
if (data_len > 0) {
|
|
byte [] data_buffer = data.GetBuffer ();
|
|
for (int i = 0; i < data_len; i++)
|
|
buffer [i + header_len] = data_buffer [i];
|
|
}
|
|
|
|
network_stream.Write (buffer, 0, msg_len);
|
|
}
|
|
|
|
public static MemoryStream ReceiveMessageStream (Stream network_stream,
|
|
out MessageType msg_type,
|
|
out string uri)
|
|
{
|
|
int data_len = 0;
|
|
int uri_len = 0;
|
|
msg_type = MessageType.Unknown;
|
|
uri = null;
|
|
|
|
// search for message header (255, 0, 255, msg_type, msg_len)
|
|
while (true) {
|
|
while (true) {
|
|
int x = network_stream.ReadByte ();
|
|
if (x != 255)
|
|
continue;
|
|
x = network_stream.ReadByte ();
|
|
if (x != 0)
|
|
continue;
|
|
x = network_stream.ReadByte ();
|
|
if (x != 255)
|
|
continue;
|
|
break;
|
|
}
|
|
|
|
msg_type = (MessageType)network_stream.ReadByte ();
|
|
|
|
byte [] buffer = new byte [8];
|
|
|
|
int bytes_read = network_stream.Read (buffer, 0, 8);
|
|
if (bytes_read != 8)
|
|
continue;
|
|
|
|
data_len = (buffer [0] | (buffer [1] << 8) |
|
|
(buffer [2] << 16) | (buffer [3] << 24));
|
|
|
|
uri_len = (buffer [4] | (buffer [5] << 8) |
|
|
(buffer [6] << 16) | (buffer [7] << 24));
|
|
|
|
if (uri_len > 0) {
|
|
byte [] uri_buffer = new byte [uri_len * 2];
|
|
bytes_read = network_stream.Read (uri_buffer, 0, uri_len * 2);
|
|
if (bytes_read != (uri_len * 2))
|
|
continue;
|
|
char [] uri_array = new char [uri_len];
|
|
for (int i = 0; i < uri_len; i++) {
|
|
uri_array [i] = (char) (uri_buffer [i * 2] | (uri_buffer [(i * 2) + 1] << 8));
|
|
}
|
|
uri = new string (uri_array);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (msg_type == MessageType.Exception)
|
|
throw new RemotingException ("\n" + uri + "\n" + "Rethrown at:\n");
|
|
|
|
byte [] stream_buffer = new byte [data_len];
|
|
if ((network_stream.Read (stream_buffer, 0, data_len)) != data_len)
|
|
throw new Exception ("packet size error");
|
|
|
|
return new MemoryStream (stream_buffer, false);
|
|
}
|
|
}
|
|
}
|