/// <summary>
/// Search for something on all hubs
/// this will send a search request to every
/// connected hub
/// </summary>
/// <param name="sp">all search parameters in one single parameter</param>
public void Search(Hub.SearchParameters sp)
{
search_results.SearchTerm = sp.search_string;
lock (connected_hubs_lock)
{
foreach (Hub hub in connected_hubs)
{//search on all connected hubs
// add filter hubs possibilities
hub.Search(sp);
}
}
}
/// <summary>
/// Read values of a single hub
/// </summary>
/// <param name="node">xml node to read from</param>
/// <returns>reserved</returns>
private bool ReadHub(XmlNode node)
{
//Console.WriteLine("Reading Hub information");
Hub hub = new Hub();
foreach (XmlAttribute attr in node.Attributes)
{
try
{
//Console.WriteLine("attr:" + attr.Name + " - " + attr.Value);
if (attr.Name.Equals("Name")) hub.Name = attr.Value;
if (attr.Name.Equals("Address")) hub.Address = attr.Value;
if (attr.Name.Equals("Description")) hub.Description = attr.Value;
if (attr.Name.Equals("Country")) hub.Country = attr.Value;
if (attr.Name.Equals("IP")) hub.IP = attr.Value;
if (attr.Name.Equals("Users") && !string.IsNullOrEmpty(attr.Value)) hub.Users = long.Parse(attr.Value);
if (attr.Name.Equals("Shared") && !string.IsNullOrEmpty(attr.Value)) hub.Shared = long.Parse(attr.Value);
if (attr.Name.Equals("Minshare") && !string.IsNullOrEmpty(attr.Value)) hub.MinShare = long.Parse(attr.Value);
if (attr.Name.Equals("Minslots") && !string.IsNullOrEmpty(attr.Value)) hub.MinSlots = int.Parse(attr.Value);
if (attr.Name.Equals("Maxhubs") && !string.IsNullOrEmpty(attr.Value)) hub.MaxHubs = int.Parse(attr.Value);
if (attr.Name.Equals("Maxusers") && !string.IsNullOrEmpty(attr.Value)) hub.MaxUsers = long.Parse(attr.Value);
if (attr.Name.Equals("Port") && !string.IsNullOrEmpty(attr.Value)) hub.Port = int.Parse(attr.Value);
}
catch (Exception e)
{
Console.WriteLine("Exception reading Hub-Values: "+e.Message);
return (false);
}
}
bool unique = true;
foreach (Hub search in hubs)
{
if (search.Address == hub.Address)
{
//Console.WriteLine("duplicate hub entry found: "+hub.Name);
unique = false;
}
}
if(unique)
hubs.Add(hub);
return (true);
}
/// <summary>
/// Start getting a file list from a user
/// </summary>
/// <param name="hub">the hub which the user is connected to</param>
/// <param name="username">the user from which the file list should be downloaded from</param>
public void GetFileList(Hub hub, string username)
{
download_queue.AddFileList(hub, username);
hub.SendConnectToMe(username); //signal download to hub to start it
}
/// <summary>
/// Search for something on all hubs
/// this will send a search request to every
/// connected hub
/// </summary>
/// <param name="search_string">the term you want to search for</param>
/// <param name="size_restricted">TRUE if you want to restrict your search to a specific size range</param>
/// <param name="is_max_size">TRUE if you want to size restrict your search to a max size</param>
/// <param name="size">the size you want to use in your size resstriction,only used if size_restricted is set to TRUE</param>
/// <param name="file_type">the specific filetype to search for ,default will be ANY</param>
public void Search(string search_string, bool size_restricted, bool is_max_size, int size, Hub.SearchFileType file_type)
{
search_results.SearchTerm = search_string;
lock (connected_hubs_lock)
{
foreach (Hub hub in connected_hubs)
{//search on all connected hubs
// add filter hubs possibilities
hub.Search(search_string, size_restricted, is_max_size, size, file_type);
}
}
}
/// <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();
}
/// <summary>
/// Disconnect a hub
/// this will also remove all event handlers from that hub
/// (TODO this behaviour will cause problems in multi client scenarios,find a workaround)
/// </summary>
/// <param name="me">the hub you want to disconnect from</param>
public void DisconnectHub(Hub me)
{
lock (connected_hubs_lock)
{
connected_hubs.Remove(me);
}
me.Disconnect();
me.Ungrab(); //hub event handlers should be ungrabbed
}
//TODO if a user is connected to more than one hub we run into inconsistencies when the user disconnects the
//actually used hub.. we could still send him messages over another hub but for the client the source is
//just offline
//solution would be maybe a list of hubs instead of just one , one feature for later
/// <summary>
/// Update Source Online Status for a specific User on a certain Hub
/// this will update the online status of the user
/// and try to find the find the affected queue entry source ,if there is any
/// </summary>
/// <param name="username">the user whos status changed</param>
/// <param name="source_hub">the hub the user's status changed on</param>
/// <param name="is_online">TRUE if the user went ONLINE</param>
private void UpdateSourcesByUsername(string username, Hub source_hub, bool is_online)
{
download_queue.UpdateSourcesByUsername(username, source_hub, is_online);
}
/// <summary>
/// Update Source Online Status for a specific Hub
/// this will update the online status of the whole user list of the specified hub
/// and try to find the find the affected queue entry sources ,if any
/// </summary>
/// <param name="me">the hub which status has changed</param>
/// <param name="is_online">TRUE if you want to set the sources to ONLINE</param>
private void UpdateSourcesByHub(Hub me, bool is_online)
{
foreach (string username in me.UserList)
UpdateSourcesByUsername(username, me, is_online);
}
/// <summary>
/// Copy the hub's values into a new hub instance and return it
/// this will not duplicate a connection / socket - only values
/// </summary>
/// <returns>a new hub instance containing all values of the original hub</returns>
public Hub Copy()
{
Hub ret = new Hub();
ret.address = this.address;
ret.auto_reconnect = this.auto_reconnect;
ret.country = this.country;
ret.description = this.description;
ret.ip = this.ip;
ret.is_connecting = false;
ret.is_connected = false;
ret.is_extended_protocol = false;
ret.is_grabbed = this.is_grabbed;
ret.is_logged_in = false;
ret.Connected = this.Connected;
ret.Disconnected = this.Disconnected;
ret.UnableToConnect = this.UnableToConnect;
ret.LoggedIn = this.LoggedIn;
ret.SearchResultReceived = this.SearchResultReceived;
ret.UserJoined = this.UserJoined;
ret.UserQuit = this.UserQuit;
ret.MoveForced = this.MoveForced;
ret.max_hubs = 0;
ret.max_users = 0;
ret.min_share = 0;
ret.min_slots = 0;
ret.my_connection_mode = this.my_connection_mode;
ret.my_connection_speed = this.my_connection_speed;
ret.my_email = this.my_email;
ret.my_ip = this.my_ip;
ret.my_name = this.my_name;
ret.my_share_size = this.my_share_size;
ret.my_tag_version = this.my_tag_version;
ret.my_tcp_port = this.my_tcp_port;
ret.my_udp_port = this.my_udp_port;
ret.my_version = this.my_version;
ret.name = this.name;
ret.nick = this.nick;
ret.op_list = new List<string>();
ret.port = this.port;
ret.shared = 0;
ret.topic = this.topic;
ret.user_list = new List<string>();
ret.UserList = new List<string>();
ret.users = 0;
return (ret);
}
public void TestLocalHubConnect()
{
Console.WriteLine("Test to connect to a local hub (remember to start some hub before).");
bool wait = true;
Hub hub = new Hub();
hub.Address = "localhost";
hub.Connected += delegate(Hub connected)
{
Console.WriteLine("Hub Connected");
//Assert.IsTrue(!string.IsNullOrEmpty(external_ip), "no ip address fetched");
//wait = false;
};
hub.LoggedIn += delegate(Hub logged_in)
{
Console.WriteLine("Hub Logged in");
wait = false;
};
hub.Disconnected += delegate(Hub disconnected)
{
if (wait)
{
Console.WriteLine("Test failed : Hub disconnected.");
Assert.Fail("Test failed : Hub disconnected.");
}
};
hub.UnableToConnect += delegate(Hub error)
{
Console.WriteLine("Test failed : Unable to connect to");
};
hub.IsGrabbedByClient = true;
hub.Connect();
Console.WriteLine("Waiting for hub events.");
DateTime start = DateTime.Now;
while (wait)
{
if (DateTime.Now - start > new TimeSpan(0, 0, 10))
{
Console.WriteLine("");
Console.WriteLine("Operation took too long");
wait = false;
Assert.Fail("Operation took too long");
}
Console.Write(".");
Thread.Sleep(250);
}
hub.Disconnect();
Console.WriteLine("Local Hub Connect Test successful.");
}
/// <summary>
/// Reply to a search from a user via udp
/// (active connection of peer user required)
/// </summary>
/// <param name="result_name">the filename of the share found</param>
/// <param name="filesize">the filesize of the share</param>
/// <param name="hub">the hub the user is connected to</param>
/// <param name="search">a whole lot of parameters of the search initiated by a remote user (including ip and port,which we will need here)</param>
public void SearchReply(string result_name, long filesize, Hub hub, Hub.SearchParameters search)
{
try
{
string temp_hub = hub.Name;
if (search.HasTTH) temp_hub = "TTH:" + search.tth;
string reply = "$SR " + hub.Nick + " " + result_name + (char)0x05 + filesize + " 1/1" + (char)0x05 + temp_hub + " (" + hub.IP + ":" + hub.Port + ")|";
Console.WriteLine("Replying to active search: " + reply);
IPEndPoint udp_reply_endpoint = new IPEndPoint(IPAddress.Parse(search.ip), search.port);
//EndPoint temp_receive_from_endpoint = (EndPoint)receive_from_endpoint;
byte[] send_bytes = System.Text.Encoding.Default.GetBytes(reply);
udp_socket.BeginSendTo(send_bytes, 0, send_bytes.Length, SocketFlags.None,udp_reply_endpoint, new AsyncCallback(SearchReplyCallback), udp_socket);
}
catch(Exception ex)
{
Console.WriteLine("Exception during sending of SearchReply to: "+search.ip+":"+search.port+" : "+ex.Message);
}
}
