void Session_Data(RudpSession session, byte[] data)
{
IMStatus status = OpenStatus(session.UserID);
G2Header root = new G2Header(data);
if (G2Protocol.ReadPacket(root))
{
if (root.Name == IMPacket.Message)
{
MessageData message = MessageData.Decode(root);
if (message.TargetID != 0)
{
Debug.Assert(session.UserID == Core.UserID);
if (session.UserID != Core.UserID)
{
return;
}
status = OpenStatus(message.TargetID);
}
ProcessMessage(status, new InstantMessage(Core, session, message));
}
if (root.Name == IMPacket.Alive)
{
status.SetTTL(session.ClientID, SessionTimeout * 2);
}
}
}
void SendWhoResponse(ChatRoom room, RudpSession session)
{
Debug.Assert(!IsCommandRoom(room.Kind));
List <ChatWho> whoPackets = new List <ChatWho>();
ChatWho who = new ChatWho();
who.RoomID = room.RoomID;
whoPackets.Add(who);
room.Members.LockReading(delegate()
{
foreach (ulong id in room.Members)
{
if (Network.RudpControl.GetActiveSessions(id).Count > 0) // only send members who are connected
{
who.Members.Add(id);
if (who.Members.Count > 40) // 40 * 8 = 320 bytes
{
who = new ChatWho();
who.RoomID = room.RoomID;
whoPackets.Add(who);
}
}
}
});
// send who to already connected locations
foreach (ChatWho packet in whoPackets)
{
session.SendData(ServiceID, 0, packet);
}
}
public void GetPublicList(ulong user)
{
if (Core.InvokeRequired)
{
Core.RunInCoreAsync(() => GetPublicList(user));
return;
}
ShareCollection collection;
if (!Collections.SafeTryGetValue(user, out collection))
{
collection = new ShareCollection(user);
Collections.SafeAdd(user, collection);
}
AddTargets(collection.ToRequest, user, 0);
foreach (DhtClient target in collection.ToRequest)
{
RudpSession session = Network.RudpControl.GetActiveSession(target);
if (session == null)
{
Network.RudpControl.Connect(target);
collection.Status = "Connecting to " + Core.GetName(target.UserID);
}
else
{
SendPublicRequest(session, collection);
}
}
}
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;
}
}
}
private void ReceiveMessage(ChatText message, RudpSession session)
{
if (Core.Buddies.IgnoreList.SafeContainsKey(session.UserID))
{
return;
}
// remote's command low, is my command high
// do here otherwise have to send custom roomID packets to selfs/lowers/highers
if (Trust != null && session.UserID != Core.UserID)
{
// if check fails then it is loop node sending data, keep it unchanged
if (message.Kind == RoomKind.Command_High && Trust.IsLowerDirect(session.UserID, message.ProjectID))
{
message.Kind = RoomKind.Command_Low;
}
else if (message.Kind == RoomKind.Command_Low && Trust.IsHigher(session.UserID, message.ProjectID))
{
message.Kind = RoomKind.Command_High;
}
else if (message.Kind == RoomKind.Live_High)
{
message.Kind = RoomKind.Live_Low;
}
else if (message.Kind == RoomKind.Live_Low)
{
message.Kind = RoomKind.Live_High;
}
}
ulong id = IsCommandRoom(message.Kind) ? GetRoomID(message.ProjectID, message.Kind) : message.RoomID;
ChatRoom room = null;
// if not in room let remote user know
if (!RoomMap.TryGetValue(id, out room) ||
!room.Active)
{
SendStatus(session);
return;
}
// if sender not in room
if (!room.Members.SafeContains(session.UserID))
{
return;
}
if (!ChatNewsUpdate)
{
ChatNewsUpdate = true;
Core.MakeNews(ServiceIDs.Chat, Core.GetName(session.UserID) + " is chatting", session.UserID, 0, false);
}
ProcessMessage(room, new ChatMessage(Core, session, message));
}
private void ReceivePublicDetails(RudpSession session, ShareCollection file)
{
ShareCollection collection;
if (!Collections.SafeTryGetValue(session.UserID, out collection))
{
return;
}
collection.Key = file.Key;
collection.Size = file.Size;
collection.Hash = file.Hash;
foreach (DhtClient done in collection.ToRequest.Where(t => t.ClientID == session.ClientID).ToArray())
{
collection.ToRequest.Remove(done);
}
FileDetails details = new FileDetails(ServiceID, DataTypePublic, file.Hash, file.Size, null);
object[] args = new object[] { collection, (object)session.ClientID };
DhtClient client = new DhtClient(session.UserID, session.ClientID);
OpTransfer transfer = Core.Transfers.StartDownload(client.UserID, details, GetPublicPath(collection), new EndDownloadHandler(CollectionDownloadFinished), args);
transfer.AddPeer(client);
transfer.DoSearch = false;
collection.Status = "Starting List Download";
}
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 Session_Update(RudpSession session)
{
if (!ActiveUsers.Contains(session.UserID))
{
return;
}
IMStatus status = null;
if (!IMMap.SafeTryGetValue(session.UserID, out status))
{
return;
}
if (session.Status == SessionStatus.Active)
{
// needs to be set here as well be cause we don't receive a keep alive from remote host on connect
status.SetTTL(session.ClientID, SessionTimeout * 2);
session.SendData(ServiceID, 0, new IMKeepAlive());
}
Update(status);
}
public InstantMessage(OpCore core, RudpSession session, MessageData message)
{
UserID = session.UserID;
ClientID = session.ClientID;
TimeStamp = core.TimeNow;
Text = message.Text;
Format = message.Format;
}
public ChatMessage(OpCore core, RudpSession session, ChatText text)
{
UserID = session.UserID;
ClientID = session.ClientID;
TimeStamp = core.TimeNow;
Text = text.Text;
Format = text.Format;
}
void SendWhoRequest(ChatRoom room, RudpSession session)
{
ChatWho whoReq = new ChatWho();
whoReq.Request = true;
whoReq.RoomID = room.RoomID;
session.SendData(ServiceID, 0, whoReq);
}
void ReceiveStatus(ChatStatus status, RudpSession session)
{
// status is what nodes send to each other to tell what rooms they are active in
RoomMap.LockReading(delegate()
{
foreach (ChatRoom room in RoomMap.Values)
{
bool update = false;
// remove from room
if (!status.ActiveRooms.Contains(room.RoomID) && room.Members.SafeContains(session.UserID))
{
if (!IsCommandRoom(room.Kind))
{
if (room.Members.SafeContains(session.UserID))
{
ProcessMessage(room, GetNameAndLocation(session) + " left the room");
}
room.RemoveMember(session.UserID);
}
update = true;
}
// add member to room
if (IsCommandRoom(room.Kind) && room.Members.SafeContains(session.UserID))
{
update = true;
}
else if (status.ActiveRooms.Contains(room.RoomID))
{
// if room private check that sender is verified
if (room.Kind == RoomKind.Secret && !room.Verified.ContainsKey(session.UserID))
{
continue;
}
if (!room.Members.SafeContains(session.UserID))
{
ProcessMessage(room, GetNameAndLocation(session) + " joined the room");
}
room.AddMember(session.UserID);
update = true;
}
if (update)
{
Core.RunInGuiThread(room.MembersUpdate);
}
}
});
}
public void Session_Update(RudpSession session)
{
// send node rooms that we have in common
if (session.Status == SessionStatus.Active)
{
// send invites
RoomMap.LockReading(delegate()
{
// if we are host of room and connect hasn't been sent invite
foreach (ChatRoom room in RoomMap.Values)
{
if (room.NeedSendInvite(session.UserID, session.ClientID))
{
// invite not sent
if (room.Kind == RoomKind.Private || room.Host == Core.UserID)
{
session.SendData(ServiceID, 0, room.Invites[session.UserID].Param1);
room.Invites[session.UserID].Param2.Add(session.ClientID);
ProcessMessage(room, "Invite sent to " + GetNameAndLocation(session));
SendWhoResponse(room, session);
}
// else private room and we are not the host, send proof we belong here
else
{
SendInviteProof(room, session);
}
}
// ask member who else is in room
if (!IsCommandRoom(room.Kind) &&
room.Members.SafeContains(session.UserID))
{
SendWhoRequest(room, session);
}
}
});
SendStatus(session);
}
// if disconnected
if (session.Status == SessionStatus.Closed)
{
foreach (ChatRoom room in FindRoom(session.UserID))
{
if (room.Active)
{
// don't remove from members unless explicitly told in status
Core.RunInGuiThread(room.MembersUpdate);
}
}
}
}
void ReceiveWho(ChatWho who, RudpSession session)
{
// if in room
ChatRoom room;
// if not in room, send status
if (!RoomMap.TryGetValue(who.RoomID, out room))
{
SendStatus(session);
return;
}
// if room not public, and not from verified private room member or host, igonre
if (IsCommandRoom(room.Kind) || (room.Kind == RoomKind.Secret && !room.Verified.ContainsKey(session.UserID)))
{
return;
}
if (!room.Active)
{
return;
}
// if requset
if (who.Request)
{
SendWhoResponse(room, session);
}
// if reply
else
{
// add members to our own list
foreach (ulong id in who.Members)
{
if (!room.Members.SafeContains(id))
{
room.AddMember(id);
if (Trust != null && Trust.GetTrust(id) == null)
{
Trust.Research(id, 0, false);
}
Core.Locations.Research(id);
}
}
// connect to new members
ConnectRoom(room);
}
}
public bool Contains(RudpSession rudp)
{
if (AllSessions.Contains(rudp.UserID))
return true;
if (!Sessions.ContainsKey(rudp.UserID))
return false;
if (Sessions[rudp.UserID].Contains(rudp.ClientID))
return true;
return false;
}
void Session_Update(RudpSession session)
{
DhtClient client = new DhtClient(session.UserID, session.ClientID);
if (session.Status == SessionStatus.Active)
{
ShareCollection collection;
if (Collections.SafeTryGetValue(session.UserID, out collection))
{
if (collection.ToRequest.Any(t => t.ClientID == session.ClientID))
{
SendPublicRequest(session, collection);
}
}
}
}
void Core_SecondTimer()
{
// need keep alives because someone else might have IM window open while we have it closed
// send keep alives every x secs
if (Core.TimeNow.Second % SessionTimeout == 0)
{
foreach (var userID in ActiveUsers)
{
IMStatus status = null;
if (IMMap.SafeTryGetValue(userID, out status))
{
foreach (ushort client in status.TTL.Keys)
{
if (status.TTL[client].Value > 0)
{
RudpSession session = Network.RudpControl.GetActiveSession(userID, client);
if (session != null)
{
status.TTL[client].Value = SessionTimeout * 2;
session.SendData(ServiceID, 0, new IMKeepAlive());
}
}
}
}
}
}
// timeout sessions
IMMap.LockReading(delegate()
{
foreach (IMStatus status in IMMap.Values)
{
foreach (BoxInt ttl in status.TTL.Values)
{
if (ttl.Value > 0)
{
ttl.Value--;
}
}
}
});
}
void Session_Data(RudpSession session, byte[] data)
{
G2Header root = new G2Header(data);
if (G2Protocol.ReadPacket(root))
{
switch (root.Name)
{
case SharePacket.PublicRequest:
ReceivePublicRequest(session);
break;
case SharePacket.Collection:
ReceivePublicDetails(session, ShareCollection.Decode(root, session.UserID));
break;
}
}
}
private void ReceivePublicRequest(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;
}
if (Local.Hash != null)
{
session.SendData(ServiceID, DataTypeSession, Local);
}
}
private void SendStatus(RudpSession session)
{
// send even if empty so they know to remove us
ChatStatus status = new ChatStatus();
RoomMap.LockReading(delegate()
{
foreach (ChatRoom room in RoomMap.Values)
{
if (room.Active && !IsCommandRoom(room.Kind))
{
if (room.Kind == RoomKind.Secret && !room.Verified.ContainsKey(session.UserID))
{
continue;
}
status.ActiveRooms.Add(room.RoomID);
}
}
});
session.SendData(ServiceID, 0, status);
}
void Session_Data(RudpSession session, byte[] data)
{
Comm_ReceiveData(session, data);
}
void Session_Data(RudpSession session, byte[] data)
{
G2Header root = new G2Header(data);
if (G2Protocol.ReadPacket(root))
{
switch (root.Name)
{
case SharingPacket.File:
ReceiveFileRequest(session, SharedFile.Decode(root, Core.Network.Local.ClientID));
break;
case SharingPacket.PublicRequest:
ReceivePublicRequest(session);
break;
case SharingPacket.Collection:
ReceivePublicDetails(session, ShareCollection.Decode(root, session.UserID));
break;
}
}
}
public void ReceiveCommPacket(G2ReceivedPacket raw, RudpPacket packet)
{
try
{
if (packet.PacketType == RudpPacketType.Light ||
packet.PacketType == RudpPacketType.LightAck)
{
LightComm.ReceivePacket(raw, packet);
return;
}
// if a socket already set up
lock (RudpControl.SocketMap)
if (RudpControl.SocketMap.ContainsKey(packet.PeerID))
{
RudpControl.SocketMap[packet.PeerID].RudpReceive(raw, packet, IsLookup);
return;
}
// if starting new session
if (packet.PacketType != RudpPacketType.Syn)
return;
RudpSyn syn = new RudpSyn(packet.Payload);
// prevent connection from self
if (syn.SenderID == Local.UserID && syn.ClientID == Local.ClientID)
return;
// find connecting session with same or unknown client id
ulong id = syn.SenderID ^ syn.ClientID;
if (RudpControl.SessionMap.ContainsKey(id))
{
RudpSession session = RudpControl.SessionMap[id];
// if session id zero or matches forward
if ((session.Comm.State == RudpState.Connecting && session.Comm.RemotePeerID == 0) ||
(session.Comm.State != RudpState.Closed && session.Comm.RemotePeerID == syn.ConnID)) // duplicate syn
{
session.Comm.RudpReceive(raw, packet, IsLookup);
return;
}
else if (session.Comm.State == RudpState.Finishing)
{
RudpControl.RemoveSession(session);
// remove session, allow new one to be created
}
else
return;
}
// if clientid not in session, create new session
RudpSession newSession = new RudpSession(RudpControl, syn.SenderID, syn.ClientID, true);
RudpControl.SessionMap[id] = newSession;
// send ack before sending our own syn (connect)
// ack tells remote which address is good so that our syn's ack comes back quickly
newSession.Comm.RudpReceive(raw, packet, IsLookup);
newSession.Connect();
UpdateLog("RUDP", "Inbound session accepted to ClientID " + syn.ClientID.ToString());
}
catch (Exception ex)
{
UpdateLog("Exception", "DhtNetwork::ReceiveCommPacket: " + ex.Message);
}
}
void Session_Data(RudpSession session, byte[] data)
{
Comm_ReceiveData(session, data);
}
private void ReceivePublicRequest(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;
if(Local.Hash != null)
session.SendData(ServiceID, DataTypeSession, Local);
}
public InstantMessage(OpCore core, RudpSession session, MessageData message)
{
UserID = session.UserID;
ClientID = session.ClientID;
TimeStamp = core.TimeNow;
Text = message.Text;
Format = message.Format;
}
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);
}
}
public bool Connect(LocationData location)
{
if (location.UserID == Network.Local.UserID && location.Source.ClientID == Network.Local.ClientID)
return false;
ulong id = location.UserID ^ location.Source.ClientID;
if (SessionMap.ContainsKey(id))
return SessionMap[id].Status != SessionStatus.Closed;
RudpSession session = new RudpSession(this, location.UserID, location.Source.ClientID, false);
SessionMap[id] = session;
session.Comm.AddAddress(new RudpAddress(new DhtAddress(location.IP, location.Source)));
foreach (DhtAddress address in location.Proxies)
session.Comm.AddAddress(new RudpAddress(address));
foreach (DhtAddress server in location.TunnelServers)
session.Comm.AddAddress(new RudpAddress(new DhtContact(location.Source, location.IP, location.TunnelClient, server)));
session.Connect();
return true;
}
private void SendPublicRequest(RudpSession session, ShareCollection collection)
{
collection.Status = "Requesting List";
session.SendData(ServiceID, DataTypeSession, new PublicShareRequest(), true);
}
private void SendPublicRequest(RudpSession session, ShareCollection collection)
{
collection.Status = "Requesting List";
session.SendData(ServiceID, DataTypeSession, new PublicShareRequest());
}
private void SendFileRequest(RudpSession session, SharedFile file)
{
foreach (DhtClient taraget in file.ToRequest.Where(c => c.UserID == session.UserID && c.ClientID == session.ClientID).ToArray())
file.ToRequest.Remove(taraget);
file.SaveLocal = false;
session.SendData(ServiceID, DataTypeSession, file, true);
file.TransferStatus = "Request sent to " + Core.GetName(session.UserID);
}
private void ReceivePublicRequest(RudpSession session)
{
if(Local.Hash != null)
session.SendData(ServiceID, DataTypeSession, Local, true);
}
private void ReceivePublicDetails(RudpSession session, ShareCollection file)
{
ShareCollection collection;
if (!Collections.SafeTryGetValue(session.UserID, out collection))
return;
collection.Key = file.Key;
collection.Size = file.Size;
collection.Hash = file.Hash;
foreach (DhtClient done in collection.ToRequest.Where(t => t.ClientID == session.ClientID).ToArray())
collection.ToRequest.Remove(done);
FileDetails details = new FileDetails(ServiceID, DataTypePublic, file.Hash, file.Size, null);
object[] args = new object[] { collection, (object) session.ClientID };
DhtClient client = new DhtClient(session.UserID, session.ClientID);
OpTransfer transfer = Core.Transfers.StartDownload(client.UserID, details, args, new EndDownloadHandler(CollectionDownloadFinished));
transfer.AddPeer(client);
transfer.DoSearch = false;
collection.Status = "Starting List Download";
}
public void ReceiveCommPacket(G2ReceivedPacket raw, RudpPacket packet)
{
try
{
if (packet.PacketType == RudpPacketType.Light ||
packet.PacketType == RudpPacketType.LightAck)
{
LightComm.ReceivePacket(raw, packet);
return;
}
// if a socket already set up
lock (RudpControl.SocketMap)
if (RudpControl.SocketMap.ContainsKey(packet.PeerID))
{
RudpControl.SocketMap[packet.PeerID].RudpReceive(raw, packet, IsLookup);
return;
}
// if starting new session
if (packet.PacketType != RudpPacketType.Syn)
{
return;
}
RudpSyn syn = new RudpSyn(packet.Payload);
// prevent connection from self
if (syn.SenderID == Local.UserID && syn.ClientID == Local.ClientID)
{
return;
}
// find connecting session with same or unknown client id
ulong id = syn.SenderID ^ syn.ClientID;
if (RudpControl.SessionMap.ContainsKey(id))
{
RudpSession session = RudpControl.SessionMap[id];
// if session id zero or matches forward
if ((session.Comm.State == RudpState.Connecting && session.Comm.RemotePeerID == 0) ||
(session.Comm.State != RudpState.Closed && session.Comm.RemotePeerID == syn.ConnID)) // duplicate syn
{
session.Comm.RudpReceive(raw, packet, IsLookup);
return;
}
else if (session.Comm.State == RudpState.Finishing)
{
RudpControl.RemoveSession(session);
// remove session, allow new one to be created
}
else
{
return;
}
}
// if clientid not in session, create new session
RudpSession newSession = new RudpSession(RudpControl, syn.SenderID, syn.ClientID, true);
RudpControl.SessionMap[id] = newSession;
// send ack before sending our own syn (connect)
// ack tells remote which address is good so that our syn's ack comes back quickly
newSession.Comm.RudpReceive(raw, packet, IsLookup);
newSession.Connect();
UpdateLog("RUDP", "Inbound session accepted to ClientID " + syn.ClientID.ToString());
}
catch (Exception ex)
{
UpdateLog("Exception", "DhtNetwork::ReceiveCommPacket: " + ex.Message);
}
}
public void Add(RudpSession rudp)
{
Add(rudp.UserID, rudp.ClientID);
}
void Session_Update(RudpSession session)
{
DhtClient client = new DhtClient(session.UserID, session.ClientID);
if (session.Status == SessionStatus.Active)
{
Local.Files.LockReading(() =>
{
foreach (SharedFile file in Local.Files.Where(s => s.ToRequest.Any(c => c.UserID == session.UserID && c.ClientID == session.ClientID)))
SendFileRequest(session, file);
});
ShareCollection collection;
if (Collections.SafeTryGetValue(session.UserID, out collection))
if (collection.ToRequest.Any(t => t.ClientID == session.ClientID))
SendPublicRequest(session, collection);
}
}
public void Session_Update(RudpSession session)
{
if (!ActiveUsers.Contains(session.UserID))
return;
IMStatus status = null;
if (!IMMap.SafeTryGetValue(session.UserID, out status))
return;
if (session.Status == SessionStatus.Active)
{
// needs to be set here as well be cause we don't receive a keep alive from remote host on connect
status.SetTTL(session.ClientID, SessionTimeout * 2);
session.SendData(ServiceID, 0, new IMKeepAlive());
}
Update(status);
}
public bool Connect(DhtClient client)
{
if (client.UserID == Network.Local.UserID && client.ClientID == Network.Local.ClientID)
return false;
// sessionmap and socketmap both need to have the same # of entries
// if a session is fin or closed, we need to wait for fins to complete before re-assigning entry
if(SessionMap.ContainsKey(client.RoutingID))
return SessionMap[client.RoutingID].Status != SessionStatus.Closed;
RudpSession session = new RudpSession(this, client.UserID, client.ClientID, false);
SessionMap[client.RoutingID] = session;
if (Network.LightComm.Clients.ContainsKey(client.RoutingID))
foreach (RudpAddress address in Network.LightComm.Clients[client.RoutingID].Addresses)
session.Comm.AddAddress(address);
session.Connect();
return true; // indicates that we will eventually notify caller with close, so caller can clean up
}
void Session_Data(RudpSession session, byte[] data)
{
IMStatus status = OpenStatus(session.UserID);
G2Header root = new G2Header(data);
if (G2Protocol.ReadPacket(root))
{
if (root.Name == IMPacket.Message)
{
MessageData message = MessageData.Decode(root);
if(message.TargetID != 0)
{
Debug.Assert(session.UserID == Core.UserID);
if(session.UserID != Core.UserID)
return;
status = OpenStatus(message.TargetID);
}
ProcessMessage(status, new InstantMessage(Core, session, message));
}
if (root.Name == IMPacket.Alive)
status.SetTTL(session.ClientID, SessionTimeout * 2);
}
}
public void RemoveSession(RudpSession session)
{
lock (SocketMap)
if (SocketMap.ContainsKey(session.Comm.PeerID))
SocketMap.Remove(session.Comm.PeerID);
SessionMap.Remove(session.RoutingID);
}
void Session_Update(RudpSession session)
{
DhtClient client = new DhtClient(session.UserID, session.ClientID);
if (session.Status == SessionStatus.Active)
{
ShareCollection collection;
if (Collections.SafeTryGetValue(session.UserID, out collection))
if (collection.ToRequest.Any(t => t.ClientID == session.ClientID))
SendPublicRequest(session, collection);
}
}
private void ReceiveFileRequest(RudpSession session, SharedFile file)
{
DhtClient client = new DhtClient(session.UserID, session.ClientID);
// check if file hash already on sharelist, if it is ignore
bool alertUser = true;
Local.Files.LockReading(() =>
{
SharedFile existing = Local.Files.Where(s => Utilities.MemCompare(s.Hash, file.Hash)).FirstOrDefault();
// transfer exists, but this is from another source, or we started up and someone is trying
// to resend file to us, which this auto adds the new source
if (existing != null)
{
if (!existing.Ignore)
StartTransfer(client, existing);
alertUser = false;
}
});
if (!alertUser)
return;
file.Ignore = true; // turned off once accepted, allowing this item to be saved to header
file.FileID = OpTransfer.GetFileID(ServiceID, file.Hash, file.Size);
Local.Files.SafeAdd(file);
Core.RunInGuiThread(GuiFileUpdate, file);
file.TransferStatus = "Request received from " + Core.GetName(session.UserID);
Core.RunInGuiThread((System.Windows.Forms.MethodInvoker) delegate()
{
new AcceptFileForm(Core, client, file).ShowDialog();
});
}
public RudpSocket(RudpSession session, bool listening)
{
Session = session;
Core = session.Core;
Network = Session.Network;
Bandwidth = new BandwidthLog(Core.RecordBandwidthSeconds);
Listening = listening;
PeerID = (ushort)Core.RndGen.Next(1, ushort.MaxValue);
lock (Session.RudpControl.SocketMap)
Session.RudpControl.SocketMap[PeerID] = this;
}
