void OnFriendMessage(SteamFriends.FriendMsgCallback cb)
{
Log.WriteLine("Msg from {0} {1} {2} \"{3}\"", cb.Sender, cb.EntryType, (int)cb.EntryType, cb.Message);
var room_id = cb.Sender;
var room = ChatRoom.Active.FindOrCreate(room_id);
room.Messages.Add(new ChatMessage {
Message = cb.Message, Sender = cb.Sender, Type = cb.EntryType
});
// TODO: Thread safety
var message_index = room.Messages.Count - 1;
var b = new Core.Util.Buffer();
b.SetAlignment(4);
b.WriteULong(cb.Sender);
b.WriteULong(cb.Sender);
b.Write((byte)cb.EntryType);
b.Write((byte)(cb.FromLimitedAccount ? 1 : 0));
// b.Write((byte)0);
b.Write((uint)message_index);
Instance.PostCallback(Common.CallbackId(Common.CallbackType.ClientFriends, 5), b);
}
void OnAccountLogonDenied(SteamUser.LoggedOnCallback cb)
{
logon_state = LogonState.LoggedOff;
Log.WriteLine("OnAccountLogonDenied: {0}", cb.Result.ExtendedString());
switch (cb.Result)
{
case EResult.AccountLoginDeniedNeedTwoFactor:
{
Log.WriteLine("Needs twofactor code...");
logon_needs = LogonNeeds.TwoFactor;
break;
}
case EResult.AccountLogonDenied:
{
Log.WriteLine("Needs steamguard code...");
logon_needs = LogonNeeds.SteamGuard;
break;
}
}
var b = new Core.Util.Buffer();
b.SetAlignment(4);
b.Write((uint)cb.Result);
b.WriteBool(false);
Instance.PostCallback(102, b);
}
public void PostCallback(int callback_id, Core.Util.Buffer b)
{
// TODO: we probably need a lock here to be threadsafe
foreach (var p in ConnectedPipes)
{
CallbackHandler.PostCallback(p, Id, callback_id, b);
}
}
public void StructTest(ref Core.Util.Buffer b)
{
b.Reset();
b.SetAlignment(4);
b.WriteByte(0xAA); // 0
b.WriteUInt(0xBBCCDDEE); // 4
b.WriteUShort(0xFFAA); // 8
b.WriteByte(0xBB); // 10
b.WriteULong(0xCCDDEEFFAABBCCDD); // 12
}
public int BufferTest(ref Core.Util.Buffer b)
{
// Reset the buffer
b.Reset();
// Write raw chars here as that is what the test expects
// Writing typeof(string) will write the length of the string first
// (which is useful for deserialization but isnt what this is testing for)
b.Write("13 characters".ToCharArray());
return(b.Length());
}
public void OnClanState(SteamFriends.ClanStateCallback cb)
{
foreach (var e in cb.Events)
{
Core.Util.Buffer b = new Core.Util.Buffer();
b.SetAlignment(4);
b.WriteULong(e.ID);
b.WriteULong(cb.ClanID);
// TODO: pad to 256 characters
b.WriteString(e.Headline);
b.WriteUInt(Platform.ToUnixTime(e.EventTime));
b.WriteULong(e.GameID);
Instance.PostCallback(Common.CallbackId(Common.CallbackType.ClientFriends, 2), b);
}
// TODO: do something with announcements
var clan = ClanGroup.Active.FindOrCreate(cb.ClanID);
var name_changed = clan.Name != cb.ClanName;
var avatar_changed = clan.AvatarHash != cb.AvatarHash;
var acc_info_changed = clan.AccountFlags != cb.AccountFlags;
// Might be completely unnecessary
if (name_changed || avatar_changed || acc_info_changed)
{
Core.Util.Buffer b = new Core.Util.Buffer();
b.SetAlignment(4);
b.WriteULong(cb.ClanID);
b.WriteBool(name_changed);
b.WriteBool(avatar_changed);
b.WriteBool(acc_info_changed);
Instance.PostCallback(Common.CallbackId(Common.CallbackType.ClientFriends, 19), b);
}
// Set all the new info that we have
clan.Name = cb.ClanName;
clan.AccountFlags = cb.AccountFlags;
clan.AvatarHash = cb.AvatarHash;
clan.ChatRoomPrivate = cb.ChatRoomPrivate;
clan.MemberChattingCount = cb.MemberChattingCount;
clan.MemberInGameCount = cb.MemberInGameCount;
clan.MemberOnlineCount = cb.MemberOnlineCount;
clan.MemberTotal = cb.MemberTotalCount;
Log.WriteLine("OnClanState for {0} <{1}>", clan.Id, clan.Name);
}
public static void PostCallback(int pipe_id, int user_id, int callback_id, Core.Util.Buffer b)
{
var new_callback = new InternalCallbackMsg
{
user_id = user_id,
callback_id = (uint)callback_id,
data = b.GetBuffer(),
};
if (PendingCallbacks.TryGetValue(pipe_id, out var cb_queue))
{
cb_queue.Enqueue(new_callback);
return;
}
PendingCallbacks[pipe_id] = new Queue <InternalCallbackMsg>();
PendingCallbacks[pipe_id].Enqueue(new_callback);
}
public void StructTest(IntPtr _, IntPtr b_pointer, int b_length)
{
var b = new Core.Util.Buffer();
b.ReadFromPointer(b_pointer, b_length);
var result = Client.ClientPipe.CallSerializedFunction(PipeId, new Core.IPC.SerializedFunction()
{
ClientId = ClientId,
InterfaceId = InterfaceId,
Name = "StructTest",
Args = new object[] { b },
});
b = (Core.Util.Buffer)result.Args[0];
b.WriteToPointer(b_pointer, b_length);
}
public int GetChatMessage(ulong steam_id, int msg_index, ref Core.Util.Buffer b, ref uint msg_type)
{
var id = new SteamKit2.SteamID(steam_id);
var cm = f.GetChatMessage(id, msg_index);
if (cm != null)
{
var total_wrote = Math.Min(b.Length(), cm.Message.Length);
b.Reset();
b.Write(cm.Message.ToCharArray());
msg_type = (uint)cm.Type;
return(total_wrote);
}
return(0);
}
public void OnPersonaState(SteamFriends.PersonaStateCallback cb)
{
if (cb.FriendID.IsClanAccount)
{
Log.WriteLine("Found clan {0} <{1}>", cb.FriendID, steam_friends.GetClanName(cb.FriendID));
var c = ClanGroup.Active.FindOrCreate(cb.FriendID);
c.Id = cb.FriendID;
c.AvatarHash = steam_friends.GetClanAvatar(cb.FriendID);
c.Name = steam_friends.GetClanName(cb.FriendID);
}
Core.Util.Buffer b = new Core.Util.Buffer();
b.SetAlignment(4);
b.WriteULong(cb.FriendID);
b.WriteUInt((uint)cb.StatusFlags);
Instance.PostCallback(Common.CallbackId(Common.CallbackType.SteamFriends, 4), b);
}
public int GetChatMessage(IntPtr _, ulong steam_id, int msg_index, IntPtr b_pointer, int b_length, ref uint msg_type)
{
var b = new Core.Util.Buffer();
b.ReadFromPointer(b_pointer, b_length);
var result = Client.ClientPipe.CallSerializedFunction(PipeId, new Core.IPC.SerializedFunction()
{
ClientId = ClientId,
InterfaceId = InterfaceId,
Name = "GetChatMessage",
Args = new object[] { steam_id, msg_index, b, msg_type },
});
b = (Core.Util.Buffer)result.Args[2];
msg_type = (uint)result.Args[3];
b.WriteToPointer(b_pointer, b_length);
return((int)result.Result);
}
// TODO: this is part of the old client authentication api and as such shouldnt really be called anymore...
public byte[] InitiateGameConnection(int max_buffer, SteamID game_server_id, GameID game_id, uint server_ip, ushort server_port, bool secure)
{
Log.WriteLine("InitiateGameConnection should no longer be called...");
if (!game_server_id.IsValid)
{
Log.WriteLine("Invalid game server steam id passed to InitiateGameConnection");
return(null);
}
// TODO: check whether server port / ip are valid
var b = new Core.Util.Buffer();
// TODO: write a real game connect token in here
if (game_connect_tokens.Count > 0)
{
var token = GetGameConnectToken();
b.Write(token.Length);
b.Write(token);
}
else
{
// Write out the placeholder token
b.Write(4u);
b.Write(0u);
}
var ownership_ticket = GetAppOwnershipTicket(game_id.AppID);
b.Write(ownership_ticket.Length);
b.Write(ownership_ticket);
// TODO: look at InternalUpdateClientGame and see whether there is anything else important
// That needs to go here
return(b.GetBuffer());
}
public int GetAuthSessionTicket(int app_id, int pipe)
{
Log.WriteLine("GetAuthSessionTicket for app_id {0}", app_id);
var ownership_ticket = GetAppOwnershipTicket((uint)app_id);
var client_ticket_buffer = new Core.Util.Buffer();
// Write the token into the ticket
var token = GetGameConnectToken();
client_ticket_buffer.Write(token.Length);
client_ticket_buffer.Write(token);
// Size of header
client_ticket_buffer.Write(0x18);
// This is all copied from what the steamclient method does
client_ticket_buffer.Write(1);
client_ticket_buffer.Write(2);
var ip_bytes = public_ip.GetAddressBytes();
Array.Reverse(ip_bytes);
client_ticket_buffer.Write(ip_bytes);
client_ticket_buffer.Write(Instance.SteamClient.LocalIP.GetAddressBytes());
client_ticket_buffer.Write(Core.Platform.MilisecondTime());
client_ticket_buffer.Write(++ticket_request_count);
var client_ticket_crc = BitConverter.ToUInt32(CryptoHelper.CRCHash(client_ticket_buffer.GetBuffer()), 0);
auth_ticket_store.Add(new AuthTicket()
{
app_id = app_id,
pipe_id = pipe,
crc32 = client_ticket_crc,
handle = auth_ticket_store.Count + 1,
ticket = client_ticket_buffer.GetBuffer(),
cancelled = false,
});
// Resend the auth list with our new ticket
SendClientAuthList();
// Create the ticket that will actually be sent to the server
var server_ticket_buffer = new Core.Util.Buffer();
var size = 8 + client_ticket_buffer.GetBuffer().Length + 4 + ownership_ticket.Length;
server_ticket_buffer.Write((ushort)size);
server_ticket_buffer.Write(steam_user.SteamID.ConvertToUInt64());
server_ticket_buffer.Write(client_ticket_buffer.GetBuffer());
// Write the ownership ticket data in here
// We are just going to assume that our tickets are 100% correct...
server_ticket_buffer.Write(ownership_ticket.Length);
server_ticket_buffer.Write(ownership_ticket);
var server_ticket_crc = BitConverter.ToUInt32(CryptoHelper.CRCHash(server_ticket_buffer.GetBuffer()), 0);
auth_ticket_store.Add(new AuthTicket()
{
is_server_ticket = true,
app_id = app_id,
pipe_id = pipe,
crc32 = server_ticket_crc,
handle = auth_ticket_store.Count + 1,
ticket = server_ticket_buffer.GetBuffer(),
cancelled = false,
});
return(auth_ticket_store.Count);
}
