internal static SharedFile PrepareDownloadFile(SharedFileMetaData metaData, BitChat chat, BitChat.Peer seeder, BitChatProfile profile, SynchronizationContext syncCxt)
{
//check if file already exists
lock (_sharedFiles)
{
SharedFile sharedFile;
if (_sharedFiles.ContainsKey(metaData.FileID))
{
sharedFile = _sharedFiles[metaData.FileID];
}
else
{
sharedFile = new SharedFile(null, metaData, new FileBlockState[metaData.BlockHash.Length], 0, syncCxt);
sharedFile._profile = profile;
_sharedFiles.Add(metaData.FileID, sharedFile);
}
sharedFile.AddChat(chat);
sharedFile.AddSeeder(seeder);
return(sharedFile);
}
}
private void chat_FileRemoved(BitChat chat, SharedFile sharedFile)
{
if (_sharedFile == sharedFile)
{
FileRemoved?.Invoke(this, EventArgs.Empty);
}
}
private void CreateInvitationPrivateChat(BinaryID hashedPeerEmailAddress, BinaryID networkID, IPEndPoint peerEP, string message)
{
BitChatNetwork network = new BitChatNetwork(_connectionManager, _trustedRootCertificates, _supportedCryptoOptions, hashedPeerEmailAddress, networkID, null, BitChatNetworkStatus.Offline, peerEP.ToString(), message);
BitChat chat = CreateBitChat(network, BinaryID.GenerateRandomID160().ToString(), BinaryID.GenerateRandomID256().ID, 0, null, new BitChatProfile.SharedFileInfo[] { }, _profile.TrackerURIs, true, false, false);
RaiseEventBitChatInvitationReceived(chat);
}
public ChatMessageView(BitChat chat, ChatListItem chatItem)
{
InitializeComponent();
_chat = chat;
_chatItem = chatItem;
_chat.MessageReceived += _chat_MessageReceived;
_chat.PeerAdded += _chat_PeerAdded;
_chat.PeerTyping += _chat_PeerTyping;
_chat.PeerHasRevokedCertificate += _chat_PeerHasRevokedCertificate;
_chat.PeerSecureChannelException += _chat_PeerSecureChannelException;
if (_chat.NetworkType == BitChatClient.Network.BitChatNetworkType.PrivateChat)
{
if (_chat.NetworkName == null)
{
this.Title = _chat.PeerEmailAddress.Address;
}
else
{
this.Title = _chat.NetworkName + " <" + _chat.PeerEmailAddress.Address + ">";
}
}
else
{
this.Title = _chat.NetworkName;
}
}
private void _chat_PeerSecureChannelException(BitChat sender, SecureChannelException ex)
{
string peerInfo;
if (ex.PeerCertificate == null)
{
peerInfo = "[" + ex.PeerEP.ToString() + "]";
}
else
{
peerInfo = ex.PeerCertificate.IssuedTo.Name + " <" + ex.PeerCertificate.IssuedTo.EmailAddress.Address + "> [" + ex.PeerEP.ToString() + "]";
}
string desc;
if (ex.Code == SecureChannelCode.RemoteError)
{
desc = "RemoteError: " + (ex.InnerException as SecureChannelException).Code.ToString();
}
else
{
desc = ex.Code.ToString();
}
AddMessage(new ChatMessageInfoItem("Secure channel with peer '" + peerInfo + "' encountered '" + desc + "' exception.", DateTime.Now));
}
private void chatPanel_MessageNotification(BitChat chat, BitChat.Peer messageSender, string message)
{
if (!chat.Mute)
{
_sndMessageNotification.Play();
}
}
public frmChatProperties(BitChat chat)
{
InitializeComponent();
_chat = chat;
if (_chat.NetworkType == BitChatClient.Network.BitChatNetworkType.PrivateChat)
{
label1.Text = "Peer's Email Address";
txtNetwork.Text = chat.PeerEmailAddress.Address;
}
else
{
txtNetwork.Text = chat.NetworkName;
}
foreach (TrackerClient tracker in _chat.GetTrackers())
{
ListViewItem item = lstTrackerInfo.Items.Add(tracker.TrackerUri.AbsoluteUri);
item.Tag = tracker;
item.SubItems.Add("");
item.SubItems.Add("");
item.SubItems.Add("");
}
_timer = new Timer();
_timer.Interval = 1000;
_timer.Tick += _timer_Tick;
_timer.Start();
}
public void Remove(BitChat chat)
{
//remove self from chat
chat.RemoveSharedFile(this);
//announce no participation
SendFileShareUnparticipate(chat);
//remove chat from list
lock (_chats)
{
_chats.Remove(chat);
if (_chats.Count == 0)
{
_sharedFiles.Remove(_metaData.FileID);
this.Dispose();
}
}
if (FileRemoved != null)
{
RaiseEventFileRemoved();
}
}
public BitChatPanel(BitChat chat, ChatListItem chatItem)
{
InitializeComponent();
_chat = chat;
_chat.FileAdded += _chat_FileAdded;
_chat.PeerAdded += _chat_PeerAdded;
_chat.MessageReceived += _chat_MessageReceived;
//create view
_view = new ChatMessageView(_chat, chatItem);
_view.Dock = DockStyle.Fill;
_view.AllowDrop = true;
_view.SettingsModified += _view_SettingsModified;
_view.DragEnter += lstFiles_DragEnter;
_view.DragDrop += lstFiles_DragDrop;
//load all peers
foreach (BitChat.Peer peer in _chat.GetPeerList())
{
lstUsers.AddItem(new UserListItem(peer));
peer.StateChanged += _view.peer_StateChanged;
peer.StateChanged += peer_StateChanged;
}
//load all files
foreach (SharedFile sharedFile in _chat.GetSharedFileList())
{
_chat_FileAdded(chat, sharedFile);
}
//add view to panel
bitChatPanelSplitContainer.Panel1.Controls.Add(_view);
}
private void _chat_FileAdded(BitChat sender, SharedFile sharedFile)
{
SharedFileItem item = new SharedFileItem(sharedFile, _chat);
item.FileRemoved += OnFileRemoved;
lstFiles.AddItem(item);
}
private void BitChat_FileRemoved(BitChat chat, SharedFile sharedFile)
{
if (_sharedFile == sharedFile)
{
linkAction.Visible = false;
_sharedFile = null;
}
}
private void BitChat_SetupTcpRelay(object sender, EventArgs e)
{
BitChat chat = sender as BitChat;
if (_tcpRelayClient != null)
{
_tcpRelayClient.AddNetwork(chat.NetworkID, chat.GetTrackerURIs());
}
}
private void BitChat_RemoveTcpRelay(object sender, EventArgs e)
{
BitChat chat = sender as BitChat;
if (_tcpRelayClient != null)
{
_tcpRelayClient.RemoveNetwork(chat.NetworkID);
}
}
private void chat_PeerAdded(BitChat sender, BitChat.Peer peer)
{
_chat.WriteInfoMessage(peer.PeerCertificate.IssuedTo.Name + " joined chat");
if (sender.NetworkType == BitChatCore.Network.BitChatNetworkType.PrivateChat)
{
this.Title = peer.PeerCertificate.IssuedTo.Name + " <" + peer.PeerCertificate.IssuedTo.EmailAddress.Address + ">";
}
}
internal void AddChat(BitChat chat)
{
lock (_chats)
{
if (!_chats.Contains(chat))
{
_chats.Add(chat);
}
}
}
private void Network_NetworkChanged(BitChatNetwork network, BinaryID newNetworkID)
{
lock (_chats)
{
BitChat chat = _chats[network.NetworkID];
_chats.Add(newNetworkID, chat);
_chats.Remove(network.NetworkID);
}
}
private void _chat_PeerAdded(BitChat sender, BitChat.Peer peer)
{
AddMessage(new ChatMessageInfoItem(peer.PeerCertificate.IssuedTo.Name + " joined chat", DateTime.Now));
if (sender.NetworkType == BitChatClient.Network.BitChatNetworkType.PrivateChat)
{
_chatItem.SetTitle(peer.PeerCertificate.IssuedTo.Name);
this.Title = peer.PeerCertificate.IssuedTo.Name + " <" + peer.PeerCertificate.IssuedTo.EmailAddress.Address + ">";
}
}
public BitChat[] GetBitChatList()
{
lock (_chats)
{
BitChat[] chats = new BitChat[_chats.Values.Count];
_chats.Values.CopyTo(chats, 0);
return(chats);
}
}
private void BitChatNode_BitChatInvitationReceived(BitChatNode node, BitChat chat)
{
AddChatView(chat);
if (lstChats.Controls.Count == 1)
{
lstChats.SelectItem(lstChats.GetFirstItem());
ShowSelectedChatView();
}
}
private void chat_PeerAdded(BitChat chat, BitChat.Peer peer)
{
if (_chat.NetworkType == BitChatCore.Network.BitChatNetworkType.PrivateChat)
{
SetTitle(peer.PeerCertificate.IssuedTo.Name);
_peer = peer;
peer.ProfileImageChanged += peer_ProfileImageChanged;
peer.StateChanged += peer_StateChanged;
}
}
private void mnuAddGroupChat_Click(object sender, EventArgs e)
{
using (frmAddChat frmCreateChat = new frmAddChat())
{
if (frmCreateChat.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
BitChat chat = _service.CreateBitChat(frmCreateChat.txtNetworkNameOrPeerEmailAddress.Text, frmCreateChat.txtPassword.Text);
AddChatView(chat);
}
}
}
private void mnuAddPrivateChat_Click(object sender, EventArgs e)
{
using (frmAddChat frmCreateChat = new frmAddChat(BitChatClient.Network.BitChatNetworkType.PrivateChat))
{
if (frmCreateChat.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
BitChat chat = _service.CreateBitChat(new System.Net.Mail.MailAddress(frmCreateChat.txtNetworkNameOrPeerEmailAddress.Text.ToLower()), frmCreateChat.txtPassword.Text);
AddChatView(chat);
}
}
}
public frmViewGroup(BitChat chat)
{
InitializeComponent();
_chat = chat;
//name
string name = _chat.NetworkName;
//name icon
if (name.Length > 0)
{
labIcon.Text = name.Substring(0, 1).ToUpper();
int x = name.LastIndexOf(" ", StringComparison.CurrentCultureIgnoreCase);
if (x > 0)
{
labIcon.Text += name.Substring(x + 1, 1).ToUpper();
}
else if (name.Length > 1)
{
labIcon.Text += name.Substring(1, 1).ToLower();
}
}
else
{
labIcon.Text = "";
}
if (_chat.NetworkStatus == BitChatCore.Network.BitChatNetworkStatus.Online)
{
labIcon.BackColor = Color.FromArgb(102, 153, 255);
}
else
{
labIcon.BackColor = Color.Gray;
}
labName.Text = name;
//image icon
if (_chat.GroupImage != null)
{
using (MemoryStream mS = new MemoryStream(_chat.GroupImage))
{
_groupImage = Image.FromStream(mS);
picIcon.Image = _groupImage;
}
picIcon.Visible = true;
labIcon.Visible = false;
}
}
public SharedFileItem(SharedFile file, BitChat chat)
{
InitializeComponent();
_file = file;
_chat = chat;
_fileSizeFormatted = WebUtilities.GetFormattedSize(_file.MetaData.FileSize);
labFileName.Text = _file.MetaData.FileName;
labSpeed.Text = "";
if (_file.TotalPeers > 1)
{
labInfo1.Text = _fileSizeFormatted + " (" + _file.TotalPeers + " peers)";
}
else
{
labInfo1.Text = _fileSizeFormatted + " (" + _file.TotalPeers + " peer)";
}
_file.FileDownloadStarted += OnFileDownloadStarted;
_file.FileDownloaded += OnFileDownloaded;
_file.BlockDownloaded += OnBlockDownloaded;
_file.PeerCountUpdate += OnPeerCountUpdate;
_file.FileTransferSpeedUpdate += OnFileTransferSpeedUpdate;
_file.FileRemoved += OnFileRemoved;
if (_file.State == SharedFileState.Advertisement)
{
_type = SharedFileItemType.Advertisement;
this.BackColor = _BackColorAvailable;
pbFileProgress.Visible = false;
}
else if (_file.IsComplete)
{
_type = SharedFileItemType.Sharing;
labSpeed.ForeColor = Color.Blue;
pbFileProgress.Visible = false;
}
else
{
_type = SharedFileItemType.Downloading;
pbFileProgress.Visible = true;
pbFileProgress.Value = _file.PercentComplete;
}
}
private void BitChat_Leave(object sender, EventArgs e)
{
BitChat chat = sender as BitChat;
lock (_chats)
{
_chats.Remove(chat.NetworkID);
}
if (_tcpRelayClient != null)
{
_tcpRelayClient.RemoveNetwork(chat.NetworkID);
}
}
private ChatListItem AddChatView(BitChat chat)
{
ChatListItem itm = new ChatListItem(chat);
itm.ChatPanel.SettingsModified += chatPanel_SettingsModified;
itm.ChatPanel.MessageNotification += chatPanel_MessageNotification;
itm.ChatPanel.SwitchToPrivateChat += chatPanel_SwitchToPrivateChat;
itm.ChatPanel.ShareFile += chatPanel_ShareFile;
mainContainer.Panel2.Controls.Add(itm.ChatPanel);
lstChats.AddItem(itm);
return(itm);
}
private void chatPanel_MessageNotification(BitChat sender, BitChat.Peer messageSender, string message)
{
if (!this.Visible || !ApplicationIsActivated())
{
if (messageSender == null)
{
notifyIcon1.ShowBalloonTip(30000, sender.NetworkName + " - Bit Chat", message, ToolTipIcon.Info);
}
else
{
notifyIcon1.ShowBalloonTip(30000, sender.NetworkName + " - Bit Chat", messageSender.PeerCertificate.IssuedTo.Name + ": " + message, ToolTipIcon.Info);
}
sndMessageNotification.Play();
}
}
private void chatPanel_MessageNotification(BitChat chat, BitChat.Peer messageSender, string message)
{
if (!chat.Mute && (!this.Visible || !ApplicationIsActivated()))
{
if ((messageSender == null) || (chat.NetworkType == BitChatCore.Network.BitChatNetworkType.PrivateChat))
{
notifyIcon1.ShowBalloonTip(30000, chat.NetworkDisplayName + " - Bit Chat", message, ToolTipIcon.Info);
}
else
{
notifyIcon1.ShowBalloonTip(30000, chat.NetworkDisplayName + " - Bit Chat", messageSender.PeerCertificate.IssuedTo.Name + ": " + message, ToolTipIcon.Info);
}
_sndMessageNotification.Play();
}
}
public frmChatProperties(BitChat chat, BitChatProfile profile)
{
InitializeComponent();
_chat = chat;
_profile = profile;
this.Text = _chat.NetworkDisplayName + " - Properties";
chkLANChat.Checked = !_chat.EnableTracking;
chkLANChat.CheckedChanged += chkLANChat_CheckedChanged;
txtNetwork.Text = chat.NetworkName;
if (chat.NetworkName == null)
{
txtSecret.ReadOnly = true;
}
txtSecret.Text = _chat.SharedSecret;
if (_chat.NetworkType == BitChatCore.Network.BitChatNetworkType.PrivateChat)
{
label1.Text = "Peer's Email Address";
}
ListViewItem dhtItem = lstTrackerInfo.Items.Add("DHT");
dhtItem.SubItems.Add("");
dhtItem.SubItems.Add("");
dhtItem.SubItems.Add("");
foreach (TrackerClient tracker in _chat.GetTrackers())
{
ListViewItem item = lstTrackerInfo.Items.Add(tracker.TrackerUri.AbsoluteUri);
item.Tag = tracker;
item.SubItems.Add("");
item.SubItems.Add("");
item.SubItems.Add("");
}
_timer = new Timer();
_timer.Interval = 1000;
_timer.Tick += timer_Tick;
_timer.Start();
}
private void chat_PeerTyping(BitChat chat, BitChat.Peer peer)
{
//show typing notification
if ((_chat.NetworkType == BitChatCore.Network.BitChatNetworkType.PrivateChat) && !peer.IsSelf)
{
labLastMessage.Text = "typing...";
}
else
{
labLastMessage.Text = peer.PeerCertificate.IssuedTo.Name + " is typing...";
}
labLastMessage.ForeColor = Color.FromArgb(255, 213, 89);
timerTypingNotification.Stop();
timerTypingNotification.Start();
}
internal static SharedFile LoadFile(BitChatProfile.SharedFileInfo info, BitChat chat, SynchronizationContext syncCxt)
{
return LoadFile(info.FilePath, info.FileMetaData, info.BlockAvailable, info.IsPaused, chat, syncCxt);
}
internal static SharedFile LoadFile(string filePath, SharedFileMetaData metaData, FileBlockState[] blockAvailable, bool isPaused, BitChat chat, SynchronizationContext syncCxt)
{
//check if file already shared
lock (_sharedFiles)
{
SharedFile sharedFile;
if (_sharedFiles.ContainsKey(metaData.FileID))
{
sharedFile = _sharedFiles[metaData.FileID];
}
else
{
int availableBlocksCount = 0;
for (int i = 0; i < blockAvailable.Length; i++)
{
if (blockAvailable[i] == FileBlockState.Available)
availableBlocksCount++;
}
FileStream fS;
if (blockAvailable.Length == availableBlocksCount)
fS = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
else
fS = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite);
sharedFile = new SharedFile(fS, metaData, blockAvailable, availableBlocksCount, syncCxt);
sharedFile._state = SharedFileState.Paused;
_sharedFiles.Add(metaData.FileID, sharedFile);
if (!isPaused)
sharedFile.Start();
}
sharedFile.AddChat(chat);
return sharedFile;
}
}
internal static SharedFile PrepareDownloadFile(SharedFileMetaData metaData, BitChat chat, BitChat.Peer seeder, BitChatProfile profile, SynchronizationContext syncCxt)
{
//check if file already exists
lock (_sharedFiles)
{
SharedFile sharedFile;
if (_sharedFiles.ContainsKey(metaData.FileID))
{
sharedFile = _sharedFiles[metaData.FileID];
}
else
{
sharedFile = new SharedFile(null, metaData, new FileBlockState[metaData.BlockHash.Length], 0, syncCxt);
sharedFile._profile = profile;
_sharedFiles.Add(metaData.FileID, sharedFile);
}
sharedFile.AddChat(chat);
sharedFile.AddSeeder(seeder);
return sharedFile;
}
}
public void RemoveDownloadPeer(BitChat.Peer peer)
{
lock (peerLock)
{
if ((_peer != null) && (peer.Equals(_peer)))
_peer = null;
}
}
internal static SharedFile ShareFile(string filePath, string hashAlgo, BitChat chat, SynchronizationContext syncCxt)
{
FileStream fS = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
HashAlgorithm hash = HashAlgorithm.Create(hashAlgo);
int hashSize = hash.HashSize / 8;
//calculate block size
int blockSize;
{
//header size = ChatMessage header + FileAdvertisement header
int packetHeaderSize = (20 + 1 + 2) + (1 + 1 + 255 + 1 + 255 + 8 + 8 + 4 + 1 + 10 + 1);
int packetDataSize = 65536 - packetHeaderSize;
int totalBlocksPossible = packetDataSize / hashSize;
blockSize = Convert.ToInt32(fS.Length / totalBlocksPossible);
if (blockSize <= short.MaxValue)
blockSize = short.MaxValue + 1;
else
{
//align to 16 bytes
int remainder = blockSize % 16;
if (remainder > 0)
blockSize = blockSize - remainder + 16;
}
}
//compute block hashes and file info hash
int totalBlocks = Convert.ToInt32(Math.Ceiling(Convert.ToDouble((double)fS.Length / blockSize)));
byte[][] blockHash = new byte[totalBlocks][];
FileBlockState[] blockAvailable = new FileBlockState[totalBlocks];
//init
for (int i = 0; i < totalBlocks; i++)
{
long offset = i * blockSize;
long length = blockSize;
if ((offset + length) > fS.Length)
length = fS.Length - offset;
blockHash[i] = hash.ComputeHash(new OffsetStream(fS, offset, length));
blockAvailable[i] = FileBlockState.Available;
}
//get file meta data
SharedFileMetaData metaData = new SharedFileMetaData(Path.GetFileName(fS.Name), WebUtilities.GetContentType(fS.Name), File.GetLastWriteTimeUtc(fS.Name), fS.Length, blockSize, hashAlgo, blockHash);
//check if file already shared
lock (_sharedFiles)
{
SharedFile sharedFile;
if (_sharedFiles.ContainsKey(metaData.FileID))
{
sharedFile = _sharedFiles[metaData.FileID];
if (sharedFile._isComplete)
{
fS.Dispose();
}
else
{
sharedFile.Remove(chat);
sharedFile = new SharedFile(fS, metaData, blockAvailable, blockAvailable.Length, syncCxt);
sharedFile.StartSharing();
_sharedFiles.Add(metaData.FileID, sharedFile);
}
}
else
{
sharedFile = new SharedFile(fS, metaData, blockAvailable, blockAvailable.Length, syncCxt);
sharedFile.StartSharing();
_sharedFiles.Add(metaData.FileID, sharedFile);
}
sharedFile.AddChat(chat);
return sharedFile;
}
}
internal void AddChat(BitChat chat)
{
lock (_chats)
{
if (!_chats.Contains(chat))
_chats.Add(chat);
}
}
public bool SetDownloadPeer(BitChat.Peer peer)
{
lock (peerLock)
{
if ((_peer == null) || (peer == null))
{
_peer = peer;
_lastResponse = DateTime.UtcNow;
return true;
}
}
return false;
}
internal void AddSeeder(BitChat.Peer seeder)
{
lock (_seeders)
{
if (!_seeders.Contains(seeder))
{
_seeders.Add(seeder);
if (PeerCountUpdate != null)
RaiseEventPeerCountUpdate();
}
}
}
public void Remove(BitChat chat)
{
//remove self from chat
chat.RemoveSharedFile(this);
//announce no participation
SendFileShareUnparticipate(chat);
//remove chat from list
lock (_chats)
{
_chats.Remove(chat);
if (_chats.Count == 0)
{
_sharedFiles.Remove(_metaData.FileID);
this.Dispose();
}
}
if (FileRemoved != null)
RaiseEventFileRemoved();
}
internal void RemovePeerOrSeeder(BitChat.Peer peer)
{
//remove from peers
lock (_peers)
{
if (_peers.Remove(peer))
{
if (PeerCountUpdate != null)
RaiseEventPeerCountUpdate();
}
}
//remove from seeds
lock (_seeders)
{
if (_seeders.Remove(peer))
{
if (PeerCountUpdate != null)
RaiseEventPeerCountUpdate();
}
}
//remove from downloading blocks
if (_downloadingBlocks != null)
{
lock (_downloadingBlocks)
{
foreach (FileBlockDownloadManager download in _downloadingBlocks)
{
download.RemoveDownloadPeer(peer);
}
}
}
}
internal void AddPeer(BitChat.Peer peer)
{
lock (_peers)
{
if (!_peers.Contains(peer))
{
_peers.Add(peer);
if (PeerCountUpdate != null)
RaiseEventPeerCountUpdate();
}
}
}
internal bool PeerExists(BitChat.Peer peer)
{
lock (_seeders)
{
if (_seeders.Contains(peer))
return true;
}
lock (_peers)
{
return _peers.Contains(peer);
}
}
public bool IsThisDownloadPeerSet(BitChat.Peer fromPeer)
{
lock (peerLock)
{
return (_peer != null) && (fromPeer.Equals(_peer));
}
}
private void SendFileShareUnparticipate(BitChat chat)
{
byte[] packetData = BitChatMessage.CreateFileUnparticipate(_metaData.FileID);
chat.WritePacketBroadcast(packetData, 0, packetData.Length);
}
