public static ChatInvite Decode(G2Header root)
{
ChatInvite invite = new ChatInvite();
G2Protocol.ResetPacket(root);
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
continue;
switch (child.Name)
{
case Packet_RoomID:
invite.RoomID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_Title:
invite.Title = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Host:
invite.Host = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_SignedInvite:
invite.SignedInvite = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return invite;
}
void Session_Data(RudpSession session, byte[] data)
{
G2Header root = new G2Header(data);
if (G2Protocol.ReadPacket(root))
{
switch (root.Name)
{
case ChatPacket.Data:
ReceiveMessage(ChatText.Decode(root), session);
break;
case ChatPacket.Status:
ReceiveStatus(ChatStatus.Decode(root), session);
break;
case ChatPacket.Invite:
ReceiveInvite(ChatInvite.Decode(root), session);
break;
case ChatPacket.Who:
ReceiveWho(ChatWho.Decode(root), session);
break;
}
}
}
void SendInviteProof(ChatRoom room, RudpSession session)
{
if (!room.Invites.ContainsKey(Core.UserID))
{
return;
}
// if already sent proof to client, return
Tuple <ChatInvite, List <ushort> > tried;
if (!room.Invites.TryGetValue(session.UserID, out tried))
{
tried = new Tuple <ChatInvite, List <ushort> >(null, new List <ushort>());
room.Invites[session.UserID] = tried;
}
if (tried.Param2.Contains(session.ClientID))
{
return;
}
tried.Param2.Add(session.ClientID);
ChatInvite invite = new ChatInvite();
invite.RoomID = room.RoomID;
invite.Title = room.Title;
invite.SignedInvite = room.Invites[Core.UserID].Param1.SignedInvite;
session.SendData(ServiceID, 0, invite);
}
public void SendInviteRequest(ChatRoom room, ulong id)
{
if (Core.InvokeRequired)
{
Core.RunInCoreAsync(delegate() { SendInviteRequest(room, id); });
return;
}
room.AddMember(id);
ChatInvite invite = null;
// if user explicitly chooses to invite users, invalidate previous recorded attempts
invite = new ChatInvite();
invite.RoomID = room.RoomID;
invite.Title = room.Title;
// if private room sign remote users id with our private key
if (room.Kind == RoomKind.Secret)
{
invite.Host = Core.KeyMap[Core.UserID];
if (!Core.KeyMap.ContainsKey(id))
{
return;
}
invite.SignedInvite = Core.User.Settings.KeyPair.SignData(Core.KeyMap[id], new SHA1CryptoServiceProvider());
room.Verified[id] = true;
}
room.Invites[id] = new Tuple <ChatInvite, List <ushort> >(invite, new List <ushort>());
// try to conncet to all of id's locations
foreach (ClientInfo loc in Core.Locations.GetClients(id))
{
Network.RudpControl.Connect(loc.Data);
}
// send invite to already connected locations
foreach (RudpSession session in Network.RudpControl.GetActiveSessions(id))
{
session.SendData(ServiceID, 0, invite);
room.Invites[id].Param2.Add(session.ClientID);
ProcessMessage(room, "Invite sent to " + GetNameAndLocation(session));
SendStatus(room); // so we get added as active to new room invitee creates
SendWhoResponse(room, session);
}
}
public static ChatInvite Decode(G2Header root)
{
ChatInvite invite = new ChatInvite();
G2Protocol.ResetPacket(root);
G2Header child = new G2Header(root.Data);
while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_RoomID:
invite.RoomID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_Title:
invite.Title = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Host:
invite.Host = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_SignedInvite:
invite.SignedInvite = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return(invite);
}
void ReceiveInvite(ChatInvite invite, RudpSession session)
{
// if in global im, only allow if on buddies list
if (Core.User.Settings.GlobalIM)
{
if (!Core.Buddies.BuddyList.SafeContainsKey(session.UserID))
{
return;
}
}
if (Core.Buddies.IgnoreList.SafeContainsKey(session.UserID))
{
return;
}
bool showInvite = false;
ChatRoom room;
if (!RoomMap.TryGetValue(invite.RoomID, out room))
{
RoomKind kind = invite.SignedInvite != null ? RoomKind.Secret : RoomKind.Private;
room = new ChatRoom(kind, invite.RoomID, invite.Title);
room.RoomID = invite.RoomID;
room.Kind = kind;
room.AddMember(session.UserID);
if (invite.Host != null)
{
room.Host = Utilities.KeytoID(invite.Host);
Core.IndexKey(room.Host, ref invite.Host);
}
RoomMap.SafeAdd(room.RoomID, room);
showInvite = true;
}
// private room
if (room.Kind == RoomKind.Secret)
{
if (!Core.KeyMap.ContainsKey(room.Host))
{
return;
}
byte[] hostKey = Core.KeyMap[room.Host];
// if this is host sending us our verification
if (session.UserID == room.Host)
{
// check that host signed our public key with his private
if (!Utilities.CheckSignedData(hostKey, Core.KeyMap[Core.UserID], invite.SignedInvite))
{
return;
}
if (!room.Invites.ContainsKey(Core.UserID)) // would fail if a node's dupe on network sends invite back to itself
{
room.Invites.Add(Core.UserID, new Tuple <ChatInvite, List <ushort> >(invite, new List <ushort>()));
}
}
// else this is node in room sending us proof of being invited
else
{
if (!Core.KeyMap.ContainsKey(session.UserID))
{
return; // key should def be in map, it was added when session was made to sender
}
// check that host signed remote's key with host's private
if (!Utilities.CheckSignedData(hostKey, Core.KeyMap[session.UserID], invite.SignedInvite))
{
return;
}
}
// if not verified yet, add them and send back our own verification
if (!room.Verified.ContainsKey(session.UserID))
{
room.Verified[session.UserID] = true;
if (room.Active)
{
SendInviteProof(room, session); // someone sends us their proof, we send it back in return
SendStatus(session); // send status here because now it will include private rooms
}
}
}
if (Trust != null && !Trust.TrustMap.SafeContainsKey(session.UserID))
{
Trust.Research(session.UserID, 0, false);
}
if (showInvite)
{
Core.RunInGuiThread(NewInvite, session.UserID, room);
}
}
