public BitChatInfo(BinaryReader bR)
{
if (Encoding.ASCII.GetString(bR.ReadBytes(2)) != "BI")
{
throw new BitChatException("Invalid BitChatInfo data format.");
}
byte version = bR.ReadByte();
switch (version)
{
case 1:
case 2:
case 3:
case 4:
if (version > 2)
{
_type = (BitChatNetworkType)bR.ReadByte();
}
else
{
_type = BitChatNetworkType.GroupChat;
}
_networkNameOrPeerEmailAddress = Encoding.UTF8.GetString(bR.ReadBytes(bR.ReadByte()));
_sharedSecret = Encoding.UTF8.GetString(bR.ReadBytes(bR.ReadByte()));
if (version > 3)
{
_networkID = new BinaryID(bR.ReadBytes(bR.ReadByte()));
}
_peerCerts = new Certificate[bR.ReadByte()];
for (int i = 0; i < _peerCerts.Length; i++)
{
_peerCerts[i] = new Certificate(bR);
}
_sharedFiles = new SharedFileInfo[bR.ReadByte()];
for (int i = 0; i < _sharedFiles.Length; i++)
{
_sharedFiles[i] = new SharedFileInfo(bR);
}
if (version > 1)
{
_trackerURIs = new Uri[bR.ReadByte()];
for (int i = 0; i < _trackerURIs.Length; i++)
{
_trackerURIs[i] = new Uri(Encoding.UTF8.GetString(bR.ReadBytes(bR.ReadByte())));
}
}
break;
default:
throw new BitChatException("BitChatInfo data version not supported.");
}
}
private void ChannelRequest(Connection connection, BinaryID channelName, ChannelType type, Stream channel)
{
try
{
switch (type)
{
case ChannelType.BitChatNetwork:
BitChatNetwork network;
lock (_networks)
{
network = _networks[channelName];
}
SecureChannelStream secureChannel = new SecureChannelServerStream(channel, connection.RemotePeerEP, _profile.LocalCertificateStore, _trustedRootCertificates, this, _supportedCryptoOptions, _reNegotiateOnBytesSent, _reNegotiateAfterSeconds, network.SharedSecret);
network.JoinNetwork(secureChannel.RemotePeerCertificate.IssuedTo.EmailAddress.Address, secureChannel, _profile.CheckCertificateRevocationList);
break;
}
}
catch
{
channel.Dispose();
}
}
public static byte[] CreateFileUnparticipate(BinaryID fileID)
{
using (MemoryStream mS = new MemoryStream(fileID.ID.Length + 1))
{
mS.WriteByte((byte)BitChatMessageType.FileShareUnparticipate); //1 byte
mS.Write(fileID.ID, 0, fileID.ID.Length);
return(mS.ToArray());
}
}
public BitChatInfo(BitChatNetworkType type, string networkNameOrPeerEmailAddress, string sharedSecret, BinaryID networkID, Certificate[] peerCerts, SharedFileInfo[] sharedFiles, Uri[] trackerURIs)
{
_type = type;
_networkNameOrPeerEmailAddress = networkNameOrPeerEmailAddress;
_sharedSecret = sharedSecret;
_networkID = networkID;
_peerCerts = peerCerts;
_sharedFiles = sharedFiles;
_trackerURIs = trackerURIs;
}
public BitChat CreateBitChat(string networkName, string sharedSecret, BinaryID networkID, Certificate[] knownPeerCerts, BitChatProfile.SharedFileInfo[] sharedFileInfoList, Uri[] trackerURIs)
{
BitChatNetwork network = new BitChatNetwork(networkName, sharedSecret, networkID, knownPeerCerts, this, this);
lock (_networks)
{
_networks.Add(network.NetworkID, network);
}
if (trackerURIs == null)
{
trackerURIs = _profile.TrackerURIs;
}
return(new BitChat(this, _profile, network, sharedFileInfoList, trackerURIs));
}
private void _virtualPeer_PacketReceived(BitChatNetwork.VirtualPeer sender, Stream packetDataStream, IPEndPoint remotePeerEP)
{
switch (BitChatMessage.ReadType(packetDataStream))
{
case BitChatMessageType.TypingNotification:
#region Typing Notification
{
if (_bitchat.PeerTyping != null)
{
_bitchat.RaiseEventPeerTyping(this);
}
break;
}
#endregion
case BitChatMessageType.Text:
#region Text
{
if (_bitchat.MessageReceived != null)
{
_bitchat.RaiseEventMessageReceived(this, BitChatMessage.ReadTextMessage(packetDataStream));
}
break;
}
#endregion
case BitChatMessageType.FileAdvertisement:
#region FileAdvertisement
{
SharedFile sharedFile = SharedFile.PrepareDownloadFile(BitChatMessage.ReadFileAdvertisement(packetDataStream), _bitchat, this, _bitchat._profile, _bitchat._syncCxt);
lock (_bitchat._sharedFiles)
{
if (_bitchat._sharedFiles.ContainsKey(sharedFile.MetaData.FileID))
{
//file already exists
if (sharedFile.IsComplete)
{
//remove the seeder
sharedFile.RemovePeerOrSeeder(this);
}
else
{
sharedFile.AddChat(_bitchat);
sharedFile.AddSeeder(this); //add the seeder
byte[] packetData = BitChatMessage.CreateFileParticipate(sharedFile.MetaData.FileID);
WritePacket(packetData, 0, packetData.Length);
}
}
else
{
//file doesnt exists
_bitchat._sharedFiles.Add(sharedFile.MetaData.FileID, sharedFile);
if (_bitchat.FileAdded != null)
{
_bitchat.RaiseEventFileAdded(sharedFile);
}
}
}
break;
}
#endregion
case BitChatMessageType.FileBlockRequest:
#region FileBlockRequest
{
FileBlockRequest blockRequest = BitChatMessage.ReadFileBlockRequest(packetDataStream);
SharedFile sharedFile;
lock (_bitchat._sharedFiles)
{
sharedFile = _bitchat._sharedFiles[blockRequest.FileID];
}
if (sharedFile.State == FileSharing.SharedFileState.Paused)
{
return;
}
if (!sharedFile.PeerExists(this))
{
return;
}
FileBlockDataPart blockData = sharedFile.ReadBlock(blockRequest.BlockNumber, blockRequest.BlockOffset, blockRequest.Length);
byte[] packetData = BitChatMessage.CreateFileBlockResponse(blockData);
_virtualPeer.WritePacket(packetData, 0, packetData.Length);
break;
}
#endregion
case BitChatMessageType.FileBlockResponse:
#region FileBlockResponse
{
FileBlockDataPart blockData = BitChatMessage.ReadFileBlockData(packetDataStream);
SharedFile sharedFile;
lock (_bitchat._sharedFiles)
{
sharedFile = _bitchat._sharedFiles[blockData.FileID];
}
if (sharedFile.State == FileSharing.SharedFileState.Paused)
{
return;
}
if (!sharedFile.PeerExists(this))
{
return;
}
SharedFile.FileBlockDownloadManager downloadingBlock = sharedFile.GetDownloadingBlock(blockData.BlockNumber);
if (downloadingBlock != null)
{
if (downloadingBlock.IsThisDownloadPeerSet(this))
{
if (!downloadingBlock.SetBlockData(blockData))
{
byte[] packetData = BitChatMessage.CreateFileBlockRequest(downloadingBlock.GetNextRequest());
_virtualPeer.WritePacket(packetData, 0, packetData.Length);
}
}
}
break;
}
#endregion
case BitChatMessageType.FileBlockWanted:
#region FileBlockWanted
{
FileBlockWanted blockWanted = BitChatMessage.ReadFileBlockWanted(packetDataStream);
SharedFile sharedFile;
lock (_bitchat._sharedFiles)
{
sharedFile = _bitchat._sharedFiles[blockWanted.FileID];
}
if (sharedFile.State == FileSharing.SharedFileState.Paused)
{
return;
}
if (!sharedFile.PeerExists(this))
{
return;
}
if (sharedFile.IsBlockAvailable(blockWanted.BlockNumber))
{
byte[] packetData = BitChatMessage.CreateFileBlockAvailable(blockWanted);
_virtualPeer.WritePacket(packetData, 0, packetData.Length);
}
break;
}
#endregion
case BitChatMessageType.FileBlockAvailable:
#region FileBlockAvailable
{
FileBlockWanted blockWanted = BitChatMessage.ReadFileBlockWanted(packetDataStream);
SharedFile sharedFile;
lock (_bitchat._sharedFiles)
{
sharedFile = _bitchat._sharedFiles[blockWanted.FileID];
}
if (sharedFile.IsComplete)
{
return;
}
if (sharedFile.State == FileSharing.SharedFileState.Paused)
{
return;
}
if (!sharedFile.PeerExists(this))
{
return;
}
SharedFile.FileBlockDownloadManager downloadingBlock = sharedFile.GetDownloadingBlock(blockWanted.BlockNumber);
if (downloadingBlock != null)
{
if (downloadingBlock.SetDownloadPeer(this))
{
byte[] packetData = BitChatMessage.CreateFileBlockRequest(downloadingBlock.GetNextRequest());
_virtualPeer.WritePacket(packetData, 0, packetData.Length);
}
}
break;
}
#endregion
case BitChatMessageType.FileShareParticipate:
#region FileShareParticipate
{
BinaryID fileID = BitChatMessage.ReadFileID(packetDataStream);
lock (_bitchat._sharedFiles)
{
_bitchat._sharedFiles[fileID].AddPeer(this);
}
break;
}
#endregion
case BitChatMessageType.FileShareUnparticipate:
#region FileShareUnparticipate
{
BinaryID fileID = BitChatMessage.ReadFileID(packetDataStream);
lock (_bitchat._sharedFiles)
{
_bitchat._sharedFiles[fileID].RemovePeerOrSeeder(this);
}
break;
}
#endregion
case BitChatMessageType.PeerExchange:
#region PeerExchange
List <PeerInfo> peerList = BitChatMessage.ReadPeerExchange(packetDataStream);
lock (_connectedPeerList)
{
//reason: for the lock to be valid for use
_connectedPeerList.Clear();
_connectedPeerList.AddRange(peerList);
}
_bitchat._network.MakeConnection(peerList);
//start network status check
_bitchat.TriggerUpdateNetworkStatus();
break;
#endregion
case BitChatMessageType.NOOP:
Debug.Write("Peer.PacketReceived", "NOOP received from: " + sender.PeerCertificate.IssuedTo.EmailAddress.Address + " [" + remotePeerEP.Address.ToString() + "]");
break;
}
}
public void ResumeLocalAnnouncement(BinaryID networkID)
{
_localDiscovery.ResumeAnnouncement(networkID);
}
public void PauseLocalAnnouncement(BinaryID networkID)
{
_localDiscovery.PauseAnnouncement(networkID);
}
public void StopLocalTracking(BinaryID networkID)
{
_localDiscovery.StopTracking(networkID);
}
private void _localDiscovery_PeerDiscovered(LocalPeerDiscovery sender, IPEndPoint peerEP, BinaryID networkID)
{
lock (_networks)
{
if (_networks.ContainsKey(networkID))
{
_networks[networkID].MakeConnection(peerEP);
}
}
}
public void StopLocalAnnouncement(BinaryID networkID)
{
_localDiscovery.StopTracking(networkID);
}
