public void Run(Client client, MessageEvent msgEvent)
{
msgEvent.ReadVL64();
int id = msgEvent.ReadVL64();
msgEvent.ReadVL64();
Room room = Engine.Locator.RoomController.GetRoom(id);
if (room == null)
{
return;
}
if (client.CurrentRoomId != 0 &&
Engine.Locator.RoomController.Rooms.TryGetValue(client.CurrentRoomId, out Room currentRoom))
{
currentRoom.RemoveActor(client.UserActor, false);
}
client.LoadingRoomId = id;
MessageComposer fuseResponse = new MessageComposer(166);
fuseResponse.AppendString("/client/public/" + room.Model + "/0", 0);
client.SendComposer(fuseResponse);
client.SendComposer(new RoomReadyMessageComposer(id, room.Model));
}
public void FlushComposer(MessageComposer composer)
{
foreach (RoomActor actor in Actors.Values)
{
actor.Client.Flush();
}
}
public PromptingDeployer(IDeployer inner, MessageComposer composer)
{
Deployer = inner;
MessageComposer = composer;
StartPromptProgram();
Pipe = new IPCPipe(true);
}
public void QueueComposer(MessageComposer composer)
{
foreach (RoomActor actor in Actors.Values)
{
actor.Client.QueueComposer(composer);
}
}
private void OnEventReceived(EventDispatcher.Event e, object?arg)
{
Dispatcher.UIThread.Post(async() =>
{
switch (e)
{
case EventDispatcher.Event.EqualizerToggle:
await MessageComposer.SetEqualizer(!_eqSwitch.IsChecked, (EqPreset)_presetSlider.Value, false);
_eqSwitch.Toggle();
break;
case EventDispatcher.Event.EqualizerNextPreset:
_eqSwitch.IsChecked = true;
var newVal = _presetSlider.Value + 1;
if (newVal >= 5)
{
newVal = 0;
}
_presetSlider.Value = newVal;
await MessageComposer.SetEqualizer(_eqSwitch.IsChecked, (EqPreset)_presetSlider.Value, false);
break;
}
});
}
private string ConvertBytesToString(byte[] bytes)
{
//char[] chars = new char[iRx + 1];
//System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
//d.GetChars(bytes, 0, iRx, chars, 0);
//string szData = new string(chars);
//return szData;
int messageKind;
MessageBase msg;
MessageComposer.Deserialize(bytes, out messageKind, out msg);
MessageKind kind = (MessageKind)messageKind;
switch (kind)
{
case MessageKind.SendingTime:
SendingTimeMessage sendingTimeMessage = (SendingTimeMessage)msg;
return("SendingTimeMessage: " + sendingTimeMessage.Message);
case MessageKind.Simple:
SimpleMessage simpleMessage = (SimpleMessage)msg;
return("SimpleMessage: " + simpleMessage.Message);
}
return("UnKnown");
}
private async void OnExtendedStatusUpdate(object?sender, ExtendedStatusUpdateParser e)
{
if (SettingsProvider.Instance.Popup.Enabled)
{
ShowPopup();
}
await MessageComposer.SetManagerInfo();
}
public static async Task <Connection> CreateAsync()
{
var conn = new Connection("9090", new StreamSocketListener());
conn.SocketListener.Control.KeepAlive = false;
conn.SocketListener.ConnectionReceived += async(sender, args) =>
{
Debug.Log("Connection received");
// get rid of old MessageQueue, which has completed
// var oldMessageQueue = Interlocked.Exchange(ref conn.MessageQueue, new BufferBlock<MessageComposer.Payload>(BlockOptions));
try
{
while (true)
{
// get latest frames
Tuple <MessageComposer.Payload, MessageComposer.Payload> frames = null;
while (frames == null)
{
Debug.Log("Waiting for frames");
// until we have a pair of frames
frames = await conn.GetFrames();
}
// compose and send a chunked message
using (var dw = new DataWriter(args.Socket.OutputStream))
{
Debug.Log("Writing msg");
dw.WriteBytes(MessageComposer.GetMessage(frames.Item1)); // depth
await dw.StoreAsync();
dw.WriteBytes(MessageComposer.GetMessage(frames.Item2)); // color
await dw.StoreAsync();
// flush
await dw.FlushAsync();
dw.DetachStream();
Debug.Log("Done");
}
}
}
catch (Exception e)
{
Debug.Log($"Connection terminated: {e.Message}");
}
finally
{
await conn.ClearFrames();
}
};
Debug.Log($"OutboundSocket listening on port {conn.Port}");
// may throw if port is unavailable
await conn.SocketListener.BindServiceNameAsync(conn.Port);
return(conn);
}
public void Invoke(Client client, params object[] args)
{
MessageComposer composer = new MessageComposer(139);
composer.AppendString(string.Join(" ", args) + "\r\n - " + client.Player.Username);
foreach (Client target in Engine.Locator.ClientController.Clients.Values)
{
target.SendComposer(composer);
}
}
public void Send(MessageComposer composer, bool flush)
{
Engine.Logger.Info(System.Text.Encoding.GetEncoding(0).GetString(composer.GetBytes()));
if (flush)
{
_channel.WriteAndFlushAsync(Unpooled.CopiedBuffer(composer.GetBytes()));
}
else
{
_channel.WriteAsync(Unpooled.CopiedBuffer(composer.GetBytes()));
}
}
public void SendPacket(MessageComposer packet)
{
foreach (TradeUser user in Users)
{
if (user == null || user.RoomUser == null || user.RoomUser.GetClient() == null)
{
continue;
}
user.RoomUser.GetClient().SendPacket(packet);
}
}
public override DynamicMetaObject _0001(InvokeMemberBinder instance, DynamicMetaObject[] pol)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (!CancelProperty("TryInvokeMember"))
{
return(base.BindInvokeMember(instance, pol));
}
MessageComposer messageComposer = (DynamicMetaObject P_0) => instance.FallbackInvokeMember(this, pol, P_0);
return(CollectProperty("TryInvokeMember", instance, WorkerClientBridge <T> ._0001(pol), CollectProperty("TryGetMember", new ResolverPropertyStruct(instance), WorkerClientBridge <T> ._0001(), messageComposer(null), (DynamicMetaObject P_0) => instance.FallbackInvoke(P_0, pol, null)), null));
}
private Task WriteGroupElements(IMessageChannel channel, IReadOnlyList <BigInteger> groupElements)
{
MessageComposer message = new MessageComposer(2 * groupElements.Count);
foreach (BigInteger groupElement in groupElements)
{
byte[] packedGroupElement = groupElement.ToByteArray();
message.Write(packedGroupElement.Length);
message.Write(packedGroupElement);
}
return(channel.WriteMessageAsync(message.Compose()));
}
private Task WriteOptions(IMessageChannel channel, byte[][][] options, int numberOfOptions, int numberOfInvocations, int numberOfMessageBytes)
{
MessageComposer message = new MessageComposer(numberOfOptions * numberOfInvocations);
for (int j = 0; j < numberOfInvocations; ++j)
{
for (int i = 0; i < numberOfOptions; ++i)
{
message.Write(options[j][i]);
}
}
return(channel.WriteMessageAsync(message.Compose()));
}
public SmppClientDemo()
{
//HOW TO INSTALL LICENSE FILE
//====================
//After purchase you will receive Inetlab.SMPP.license file per E-Mail.
//Add this file into the root of project where you have a reference on Inetlab.SMPP.dll. Change "Build Action" of the file to "Embedded Resource".
//Set license before using Inetlab.SMPP classes in your code:
// C#
// Inetlab.SMPP.LicenseManager.SetLicense(this.GetType().Assembly.GetManifestResourceStream(this.GetType(), "Inetlab.SMPP.license" ));
//
// VB.NET
// Inetlab.SMPP.LicenseManager.SetLicense(Me.GetType().Assembly.GetManifestResourceStream(Me.GetType(), "Inetlab.SMPP.license"))
InitializeComponent();
LogManager.SetLoggerFactory(new TextBoxLogFactory(tbLog, LogLevel.Info));
_log = LogManager.GetLogger(GetType().Name);
AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
{
LogManager.GetLogger("AppDomain").Fatal((Exception)args.ExceptionObject, "Unhandled Exception");
};
_client = new SmppClient();
_client.ResponseTimeout = TimeSpan.FromSeconds(60);
_client.EnquireLinkInterval = TimeSpan.FromSeconds(20);
_client.evDisconnected += new DisconnectedEventHandler(client_evDisconnected);
_client.evDeliverSm += new DeliverSmEventHandler(client_evDeliverSm);
_client.evEnquireLink += new EnquireLinkEventHandler(client_evEnquireLink);
_client.evUnBind += new UnBindEventHandler(client_evUnBind);
_client.evDataSm += new DataSmEventHandler(client_evDataSm);
_client.evRecoverySucceeded += ClientOnRecoverySucceeded;
_client.evServerCertificateValidation += OnCertificateValidation;
_messageComposer = new MessageComposer();
_messageComposer.evFullMessageReceived += OnFullMessageReceived;
_messageComposer.evFullMessageTimeout += OnFullMessageTimeout;
}
private DynamicMetaObject DefineProperty(string info, DynamicMetaObjectBinder selection, IEnumerable <Expression> filter, [global::_0008._0012(new byte[]
{
1,
0
})] MessageComposer _0005, [global::_0008._0012(new byte[]
{
2,
0
})] MessageComposer _0006 = null)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
DynamicMetaObject visitor = _0005(null);
return(CollectProperty(info, selection, filter, visitor, _0006));
}
public void StaffAlert(MessageComposer Message, int Exclude = 0)
{
foreach (GameClient client in this.GetClients.ToList())
{
if (client == null || client.GetHabbo() == null)
{
continue;
}
if (client.GetHabbo().Rank < 2 || client.GetHabbo().Id == Exclude)
{
continue;
}
client.SendPacket(Message);
}
}
void m_TerminalClient_Connected(Socket socket)
{
SimpleMessage message = new SimpleMessage("Hello There");
int messageKing = (int)MessageKind.Simple;
byte[] buffer = MessageComposer.Serialize(messageKing, message);
m_ClientTerminal.SendMessage(buffer);
cmdConnect.Enabled = false;
cmdClose.Enabled = true;
PresentMessage(listLog, "Connection Opened!");
m_ClientTerminal.StartListen();
PresentMessage(listLog, "Start listening to server messages");
}
public void SendToTent(int Id, int TentId, MessageComposer Packet)
{
if (!Tents.ContainsKey(TentId))
{
return;
}
foreach (RoomUser User in Tents[TentId].ToList())
{
if (User == null || User.GetClient() == null || User.GetClient().GetHabbo() == null || User.GetClient().GetHabbo().GetIgnores().IgnoredUserIds().Contains(Id) || User.GetClient().GetHabbo().TentId != TentId)
{
continue;
}
User.GetClient().SendPacket(Packet);
}
}
public static void SerializeRoom(Room room, MessageComposer composer)
{
composer.AppendVL64(room.Id);
composer.AppendVL64(false); // events
composer.AppendString(room.Name);
composer.AppendString(room.Owner);
composer.AppendVL64((int)room.State);
composer.AppendVL64(room.PlayersIn);
composer.AppendVL64(room.PlayersMax);
composer.AppendString(room.Description);
composer.AppendVL64(0);
composer.AppendVL64(Engine.Locator.NavigatorController.Categories[room.CategoryId].TradeAllowed);
composer.AppendVL64(0); // score
composer.AppendVL64(0); // tags
composer.AppendString("");
composer.AppendVL64(0);
composer.AppendString(room.Icon, 0);
}
public SmppServerDemo()
{
//HOW TO INSTALL LICENSE FILE
//====================
//After purchase you will receive Inetlab.SMPP.license file per E-Mail.
//Add this file into the root of project where you have a reference on Inetlab.SMPP.dll. Change "Build Action" of the file to "Embedded Resource".
//Set license before using Inetlab.SMPP classes in your code:
// C#
// Inetlab.SMPP.LicenseManager.SetLicense(this.GetType().Assembly.GetManifestResourceStream(this.GetType(), "Inetlab.SMPP.license" ));
//
// VB.NET
// Inetlab.SMPP.LicenseManager.SetLicense(Me.GetType().Assembly.GetManifestResourceStream(Me.GetType(), "Inetlab.SMPP.license"))
InitializeComponent();
LogManager.SetLoggerFactory(new TextBoxLogFactory(tbLog, LogLevel.Info));
AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
{
LogManager.GetLogger("AppDomain").Fatal((Exception)args.ExceptionObject, "Unhandled Exception");
};
_log = LogManager.GetLogger(GetType().Name);
_server = new SmppServer(new IPEndPoint(IPAddress.Any, int.Parse(tbPort.Text)));
_server.evClientConnected += server_evClientConnected;
_server.evClientDisconnected += server_evClientDisconnected;
_server.evClientBind += server_evClientBind;
_server.evClientSubmitSm += server_evClientSubmitSm;
_server.evClientSubmitMulti += server_evClientSubmitMulti;
_server.evClientEnquireLink += ServerOnClientEnquireLink;
_server.evClientCertificateValidation += OnClientCertificateValidation;
//Create message composer. It helps to get full text of the concatenated message in the method OnFullMessageReceived
_messageComposer = new MessageComposer();
_messageComposer.evFullMessageReceived += OnFullMessageReceived;
_messageComposer.evFullMessageTimeout += OnFullMessageTimeout;
}
public void SendPacket(MessageComposer Packet, string fuse = "")
{
foreach (GameClient Client in this._clients.Values.ToList())
{
if (Client == null || Client.GetHabbo() == null)
{
continue;
}
if (!string.IsNullOrEmpty(fuse))
{
if (!Client.GetHabbo().GetPermissions().HasRight(fuse))
{
continue;
}
}
Client.SendPacket(Packet);
}
}
public void SendPacket(MessageComposer message, bool withRightsOnly = false)
{
if (message == null)
{
return;
}
try
{
List <RoomUser> users = _roomUserManager.GetUserList().ToList();
if (_roomUserManager == null || users == null)
{
return;
}
foreach (RoomUser user in users)
{
if (user == null || user.IsBot)
{
continue;
}
if (user.GetClient() == null)
{
continue;
}
if (withRightsOnly && !CheckRights(user.GetClient()))
{
continue;
}
user.GetClient().SendPacket(message);
}
}
catch (Exception e)
{
ExceptionLogger.LogException(e);
}
}
private void cmdSendMessage_Click(object sender, EventArgs e)
{
try
{
string mes = txtData.Text;
// Create the concrete message
SendingTimeMessage message = new SendingTimeMessage(mes);
int messageKind = (int)MessageKind.SendingTime;
byte[] buffer = MessageComposer.Serialize(messageKind, message);
// Send the message (as bytes) to the server.
m_ClientTerminal.SendMessage(buffer);
}
catch (SocketException se)
{
MessageBox.Show(se.Message);
}
}
public LoraWanGateway(
ITransceiver transceiver,
LoraWanGatewaySettings gatewaySettings,
GatewayEui gatewayEui,
IPositionProvider positionProvider)
{
_stopwatch.Start();
_transceiver = transceiver;
_gatewaySettings = gatewaySettings;
_positionProvider = positionProvider;
_loraNetworkClients = gatewaySettings.Hosts
.Select(x => new LoraNetworkClient(new HostName(x), 1700))
.ToArray();
_messageComposer = new MessageComposer(gatewayEui);
_transceiver.OnMessageReceived += TransceiverOnMessageReceived;
_datr = GetSF() + GetBW();
_codr = GetCodr();
}
private string ConvertBytesToString(byte[] bytes)
{
int messageKind;
MessageBase msg;
MessageComposer.Deserialize(bytes, out messageKind, out msg);
MessageKind kind = (MessageKind)messageKind;
switch (kind)
{
case MessageKind.SendingTime:
SendingTimeMessage sendingTimeMessage = (SendingTimeMessage)msg;
return("SendingTimeMessage: " + sendingTimeMessage.Message);
case MessageKind.Simple:
SimpleMessage simpleMessage = (SimpleMessage)msg;
return("SimpleMessage: " + simpleMessage.Message);
}
return("UnKnown");
}
private DynamicMetaObject CollectProperty(string def, DynamicMetaObjectBinder ivk, IEnumerable <Expression> role, DynamicMetaObject visitor2, MessageComposer last3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ParameterExpression parameterExpression = Expression.Parameter(typeof(object), null);
IList <Expression> list = new List <Expression>();
list.Add(Expression.Convert(base.Expression, typeof(T)));
list.Add(InitProperty(ivk));
list.ExcludeTest(role);
list.Add(parameterExpression);
DynamicMetaObject dynamicMetaObject = new DynamicMetaObject(parameterExpression, BindingRestrictions.Empty);
if (ivk.ReturnType != typeof(object))
{
dynamicMetaObject = new DynamicMetaObject(Expression.Convert(dynamicMetaObject.Expression, ivk.ReturnType), dynamicMetaObject.Restrictions);
}
if (last3 != null)
{
dynamicMetaObject = last3(dynamicMetaObject);
}
return(new DynamicMetaObject(Expression.Block(new ParameterExpression[1]
{
parameterExpression
}, Expression.Condition(Expression.Call(Expression.Constant(modelComposer), typeof(GDBD.Bridges.SetterClientBridge <T>).GetMethod(def), list), dynamicMetaObject.Expression, visitor2.Expression, ivk.ReturnType)), this._0001().Merge(dynamicMetaObject.Restrictions).Merge(visitor2.Restrictions)));
}
public void SendPacket(MessageComposer message)
{
channel.WriteAndFlushAsync(message);
}
private DynamicMetaObject CallProperty(string init, DynamicMetaObjectBinder ord, Expression[] dic, MessageComposer key2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
DynamicMetaObject dynamicMetaObject = key2(null);
IList <Expression> list = new List <Expression>();
list.Add(Expression.Convert(base.Expression, typeof(T)));
list.Add(InitProperty(ord));
list.ExcludeTest(dic);
return(new DynamicMetaObject(Expression.Condition(Expression.Call(Expression.Constant(modelComposer), typeof(GDBD.Bridges.SetterClientBridge <T>).GetMethod(init), list), Expression.Empty(), dynamicMetaObject.Expression, typeof(void)), this._0001().Merge(dynamicMetaObject.Restrictions)));
}
private DynamicMetaObject SortProperty(string spec, DynamicMetaObjectBinder ivk, IEnumerable <Expression> control, MessageComposer ord2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
DynamicMetaObject dynamicMetaObject = ord2(null);
ParameterExpression parameterExpression = Expression.Parameter(typeof(object), null);
IList <Expression> list = new List <Expression>();
list.Add(Expression.Convert(base.Expression, typeof(T)));
list.Add(InitProperty(ivk));
list.ExcludeTest(control);
list[list.Count - 1] = Expression.Assign(parameterExpression, list[list.Count - 1]);
return(new DynamicMetaObject(Expression.Block(new ParameterExpression[1]
{
parameterExpression
}, Expression.Condition(Expression.Call(Expression.Constant(modelComposer), typeof(GDBD.Bridges.SetterClientBridge <T>).GetMethod(spec), list), parameterExpression, dynamicMetaObject.Expression, typeof(object))), this._0001().Merge(dynamicMetaObject.Restrictions)));
}
