/// <summary>
/// Setup the event handlers for a fresh connected peer
/// </summary>
/// <param name="client">an ungrabbed peer</param>
private void SetupPeerEventHandler(Peer client)
{
client.Nick = nick;
client.DataReceived += delegate(Peer data_received_client)
{/*
* Queue.QueueEntry entry = download_queue.FindFirstUnusedQueueEntryBySourceUser(data_received_client.PeerNick);
* if (entry != null)
* {
* Queue.QueueEntry.Source source = entry.FindFirstSourceByUser(data_received_client.PeerNick);
* if (source != null)
* {
* entry.IsInUse = true;
* }
* else
* {
* Console.WriteLine("no correct source found in queue entry for user: "******"nothing found in queue for user: "******"files.xml.bz2")
{
file_list_request_client.UploadFilename = file_list_request_client.UploadRequestFilename;
}
file_list_request_client.UploadFileListData = shares.GetFileListXmlBZ2();
return(Peer.FileRequestAnswer.LetsGo);
};
client.FileRequestReceived += delegate(Peer file_request_client)
{
Sharing.SharingEntry entry = shares.GetShareByFileRequest(file_request_client.UploadRequestFilename);
if (entry != null)
{
file_request_client.UploadFilename = entry.Filename;
return(Peer.FileRequestAnswer.LetsGo);
}
else
{
return(Peer.FileRequestAnswer.FileNotAvailable);
}
};
client.HandShakeCompleted += delegate(Peer handshake_client)
{
if (PeerHandShakeCompleted != null)
{
PeerHandShakeCompleted(handshake_client);
}
Queue.QueueEntry entry = download_queue.FindFirstUnusedQueueEntryBySourceUser(handshake_client.PeerNick);
if (entry != null)
{
Queue.QueueEntry.Source source = entry.FindFirstSourceByUser(handshake_client.PeerNick);
if (source != null)
{
//handshake_client.StartDownload(source.Filename, entry.OutputFilename, entry.Filesize);
if (entry.Type == Queue.QueueEntry.EntryType.File && entry.WantTTHL)
{
handshake_client.GetTTHL(entry);
}
else if (entry.Type == Queue.QueueEntry.EntryType.File)
{
handshake_client.StartDownload(source, entry);
}
else if (entry.Type == Queue.QueueEntry.EntryType.FileList)
{
handshake_client.GetFileList(entry);
}
}
else
{
Console.WriteLine("no correct source found in queue entry for user: "******"nothing found in queue for user: " + handshake_client.PeerNick);
handshake_client.Disconnect();
}
}
};
client.Completed += delegate(Peer completed_client)
{
//download_queue.Remove(download_queue.FindQueueEntryByOutputFilename(completed_client.OutputFilename));
if (auto_remove_downloads)
{
download_queue.Remove(completed_client.QueueEntry);
}
ContinueWithQueueForUser(completed_client.PeerNick);
if (PeerCompleted != null)
{
PeerCompleted(completed_client);
}
};
client.Disconnected += delegate(Peer disconnected_client)
{
lock (peers_lock)
{
if (peers.Contains(disconnected_client))
{
peers.Remove(disconnected_client);
}
}
//Queue.QueueEntry entry = download_queue.FindQueueEntryByOutputFilename(disconnected_client.OutputFilename);
//Queue.QueueEntry entry = disconnected_client.QueueEntry;
//if (entry != null) //TODO this will cause trouble -> fix with disconnect cause change in callback
// entry.IsInUse = false;
//ContinueWithQueueForUser(disconnected_client.PeerNick);//TODO prevent hammering on strange source with a seconds counter
if (PeerDisconnected != null)
{
PeerDisconnected(disconnected_client);
}
};
}
/// <summary>
/// Connect to a hub
/// this will initialize a hub with
/// some client values like our nickname etc
/// add some event handlers
/// and start connecting to it
/// </summary>
/// <param name="me">the hub you want to connect to</param>
public void ConnectHub(Hub me)
{
me.Nick = nick;
if (!string.IsNullOrEmpty(local_peer.ExternalIP))
{
me.MyIP = local_peer.ExternalIP;
}
else
{
me.MyIP = local_peer.IP;
}
me.MyTcpPort = local_peer.TcpPort;
me.MyUdpPort = local_peer.UdpPort;
me.MyEmail = email;
me.MyDescription = description;
me.MyVersion = version;
me.MyTagVersion = tag_version;
me.MyShareSize = share_size;
me.MyConnectionMode = connection_mode;
me.MyConnectionSpeed = connection_speed;
me.MyName = name;
if (!me.IsGrabbedByClient)
{
me.SearchReceived += delegate(Hub search_hub, Hub.SearchParameters search)
{
if (search.HasTTH)
{
Sharing.SharingEntry entry = shares.GetShareByTTH(search.tth);
if (entry != null)
{
if (search.mode == Hub.ConnectionMode.Passive)
{
search_hub.SearchReply(entry.Filename, entry.Filesize, search);
}
else
{
local_peer.SearchReply(entry.Filename, entry.Filesize, search_hub, search);
}
}
}
else
{
//TODO add old fashioned search here
}
};
me.SearchResultReceived += delegate(Hub search_result_hub, SearchResults.SearchResult result)
{
InterpretReceivedSearchResult(result);
};
me.PasswordRequested += delegate(Hub password_requested)
{
//TODO add a password for hubs db
// and first check that db before and send a found password
//automagically and silent
if (HubPasswordRequested != null)
{
return(HubPasswordRequested(password_requested));
}
return(null);
};
me.MainChatLineReceived += delegate(Hub main_chat_hub, Hub.ChatLine main_chat_line)
{
if (HubMainChatReceived != null)
{
HubMainChatReceived(main_chat_hub, main_chat_line);
}
};
me.PrivateChatLineReceived += delegate(Hub private_chat_hub, Hub.ChatLine private_chat_line)
{
if (HubPrivateChatReceived != null)
{
HubPrivateChatReceived(private_chat_hub, private_chat_line);
}
};
me.MoveForced += delegate(Hub src_hub, Hub dst_hub)
{
if (HubMoveForced != null)
{
HubMoveForced(src_hub, dst_hub);
}
};
me.ConnectToMeReceived += delegate(Hub hub, Peer connect_to_me_client)
{
//free slots check maybe needed
SetupPeerEventHandler(connect_to_me_client);
connect_to_me_client.Connected += delegate(Peer connect_to_me_connected_client)
{
if (PeerConnected != null)
{
PeerConnected(connect_to_me_connected_client);
}
connect_to_me_connected_client.StartHandShake();
lock (peers_lock)
{
peers.Add(connect_to_me_connected_client);
}
};
connect_to_me_client.Connect();
};
me.Disconnected += delegate(Hub hub)
{
UpdateSourcesByHub(hub, false);
lock (connected_hubs_lock)
{
if (connected_hubs.Contains(hub))
{
connected_hubs.Remove(hub);
}
}
if (HubDisconnected != null)
{
HubDisconnected(hub);
}
};
me.Connected += delegate(Hub hub)
{
lock (connected_hubs_lock)
{
if (!connected_hubs.Contains(hub))
{
connected_hubs.Add(hub);
}
}
if (HubConnected != null)
{
HubConnected(hub);
}
};
me.UnableToConnect += delegate(Hub hub)
{
UpdateSourcesByHub(hub, false);
/*lock (connected_hubs_lock) TODO check if commenting this out hurts our code---> :-)
* {
* if (connected_hubs.Contains(hub))
* connected_hubs.Remove(hub);
* }*/
if (HubUnableToConnect != null)
{
HubUnableToConnect(hub);
}
};
me.LoggedIn += delegate(Hub hub)
{
if (HubLoggedIn != null)
{
HubLoggedIn(hub);
}
};
me.UserJoined += delegate(Hub hub, string username)
{
UpdateSourcesByUsername(username, hub, true);
if (HubUserJoined != null)
{
HubUserJoined(hub, username);
}
};
me.UserQuit += delegate(Hub hub, string username)
{
UpdateSourcesByUsername(username, hub, false);
if (HubUserQuit != null)
{
HubUserQuit(hub, username);
}
};
me.IsGrabbedByClient = true;
}
me.Connect();
}
