// This is called once per test and performs max_count as defined in the
// constructor
public int Send(Address rem_addr) {
// Get a random set of data
byte[]data = new byte[length];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(data);
// Add the appropriate header to the data block
testing.ToMemBlock().CopyTo(data, 0);
MemBlock to_send = MemBlock.Reference(data);
// Setup the sender
ISender sender = new AHExactSender(_nm.Node, rem_addr);
// perform the send test
DateTime now = DateTime.UtcNow;
for(int i = 1; i <= _max_count; i++) {
// at every 102400 packet, we syncrhonize and force a GC otherwise
// memory tends to explode
if(i % (102400) != 0) {
sender.Send(MemBlock.Reference(to_send));
}
else {
sender.Send(eos);
_all_done.WaitOne();
Thread.Sleep(500);
GC.Collect();
}
}
// All done, now let's send and wait!
sender.Send(eos);
if(!_all_done.WaitOne(10000, false)) {
Console.WriteLine("Failed");
}
return (int) (DateTime.UtcNow - now).TotalMilliseconds;
}
/// <summary>Sends the IP Packet to the specified target address.</summary>
/// <param name="target"> the Brunet Address of the target</param>
/// <param name="packet"> the data to send to the recepient</param>
protected virtual void SendIP(Address target, MemBlock packet)
{
ISender s = null;
if(_secure_senders) {
try {
s = _bso.GetSecureSender(target);
}
catch(Exception e) {
Console.WriteLine(e);
return;
}
}
else {
s = new AHExactSender(Brunet, target);
}
s.Send(new CopyList(PType.Protocol.IP, packet));
}
protected void FriendPing(string address)
{
Address addr = AddressParser.Parse(address);
Channel q = new Channel();
q.CloseAfterEnqueue();
q.CloseEvent += delegate(object obj, EventArgs eargs) {
try {
RpcResult res = (RpcResult) q.Dequeue();
string result = (string) res.Result;
string[] parts = result.Split(DELIM);
string dht_key = parts[0];
string response = parts[1];
if(response == "online") {
SocialUser friend = _friends[dht_key];
friend.Time = DateTime.Now.ToString();
}
ProtocolLog.Write(SocialLog.SVPNLog, "PING FRIEND REPLY: " +
result);
} catch(Exception e) {
ProtocolLog.Write(SocialLog.SVPNLog, e.Message);
ProtocolLog.Write(SocialLog.SVPNLog, "PING FRIEND FAILURE: " +
address);
}
};
ISender sender = new AHExactSender(_node, addr);
_rpc.Invoke(sender, q, "SocialVPN.FriendPing", _local_user.DhtKey);
}
public static void Main(string []args) {
if (args.Length < 1) {
Console.WriteLine("please specify the number edge protocol.");
Environment.Exit(0);
}
if (args.Length < 2) {
Console.WriteLine("please specify the number of p2p nodes.");
Environment.Exit(0);
}
if (args.Length < 3) {
Console.WriteLine("please specify the number of missing edges.");
Environment.Exit(0);
}
string proto = "function";
try {
proto = args[0].Trim();
} catch(Exception) {}
bool tunnel = false;
int base_port = 54000;
int network_size = Int32.Parse(args[1]);
int missing_count = Int32.Parse(args[2]);
try {
tunnel = args[3].Trim().Equals("tunnel");
} catch (Exception) {}
Console.WriteLine("use tunnel edges: {0}", tunnel);
Random rand = new Random();
ArrayList missing_edges = new ArrayList();
for (int i = 0; i < missing_count; i++) {
int idx = -1;
int left, right;
do {
idx = rand.Next(0, network_size);
left = (idx + 1)%network_size;
if (idx == 0) {
right = network_size - 1;
} else {
right = idx - 1;
}
} while (missing_edges.Contains(idx));// ||
//missing_edges.Contains(left) ||
//missing_edges.Contains(right));
Console.WriteLine("Will drop a left edge on idx {0}: ", idx);
missing_edges.Add(idx);
}
//
// Sort missing edges.
//
missing_edges.Sort();
SortedList dist = new SortedList();
//
// Compute the average distance between missing edges.
//
if (missing_count > 1) {
for (int i = 0; i < missing_count; i++) {
int idx = (int) missing_edges[i];
int idx_next;
int d;
if (i == missing_count - 1) {
idx_next = (int) missing_edges[0];
d = (network_size - 1) - idx + idx_next;
} else {
idx_next = (int) missing_edges[i+1];
d = idx_next - idx - 1;
}
if (!dist.Contains(d)) {
dist[d] = 0;
} else {
int c = (int) dist[d];
dist[d] = c + 1;
}
}
}
double sum = 0.0;
int num = 0;
Console.WriteLine("distribution of missing edges separation");
foreach(DictionaryEntry de in dist) {
int k = (int) de.Key;
int c = (int) de.Value;
Console.WriteLine("{0} {1}", k, c);
sum = sum + k*c;
num = num + c;
}
Console.WriteLine("average separation: {0}", (double) sum/num);
string brunet_namespace = "testing";
Console.WriteLine("Initializing...");
ArrayList RemoteTA = new ArrayList();
for(int i = 0; i < network_size; i++) {
if (proto.Equals("udp")) {
RemoteTA.Add(TransportAddressFactory.CreateInstance("brunet.udp://localhost:" + (base_port + i)));
} else if (proto.Equals("function")) {
RemoteTA.Add(TransportAddressFactory.CreateInstance("brunet.function://localhost:" + (base_port + i)));
}
}
for(int i = 0; i < network_size; i++) {
AHAddress address = new AHAddress(new RNGCryptoServiceProvider());
Node node = new StructuredNode(address, brunet_namespace);
_sorted_node_list.Add((Address) address, node);
_node_list.Add(node);
RouteTestHandler test_handler = new RouteTestHandler();
node.GetTypeSource(new PType(routing_test)).Subscribe(test_handler, address.ToMemBlock());
RpcManager rpc_man = RpcManager.GetInstance(node);
rpc_man.AddHandler("rpc_routing_test", new RpcRoutingTestHandler(node));
}
for (int i = 0; i < network_size; i++) {
Node node = (Node) _sorted_node_list.GetByIndex(i);
Console.WriteLine("Configuring node: {0} ", node.Address);
TAAuthorizer ta_auth = null;
if (missing_edges.Contains(i)) {
int remote_port;
if (i == network_size - 1) {
remote_port = base_port;
} else {
remote_port = base_port + i + 1;
}
PortTAAuthorizer port_auth = new PortTAAuthorizer(remote_port);
Console.WriteLine("Adding a port TA authorizer at: {0} for remote port: {1}", base_port + i, remote_port);
ArrayList arr_tas = new ArrayList();
arr_tas.Add(port_auth);
arr_tas.Add(new ConstantAuthorizer(TAAuthorizer.Decision.Allow));
ta_auth = new SeriesTAAuthorizer(arr_tas);
}
if (proto.Equals("udp")) {
node.AddEdgeListener(new UdpEdgeListener(base_port + i, null, ta_auth));
} else if(proto.Equals("function")) {
node.AddEdgeListener(new FunctionEdgeListener(base_port + i, -1.00, ta_auth));
}
if (tunnel) {
Console.WriteLine("Adding a tunnel edge listener");
node.AddEdgeListener(new Tunnel.TunnelEdgeListener(node));
}
_node_to_port[node] = base_port + i;
node.RemoteTAs = RemoteTA;
}
//start nodes one by one.
for (int i = 0; i < network_size; i++) {
Node node = (Node) _node_list[i];
Console.WriteLine("Starting node: {0}, {1}", i, node.Address);
node.Connect();
Console.WriteLine("Going to sleep for 2 seconds.");
System.Threading.Thread.Sleep(2000);
}
//wait for 300000 more seconds
Console.WriteLine("Going to sleep for 300000 seconds.");
System.Threading.Thread.Sleep(300000);
bool complete = CheckStatus();
int count = 0;
//
// Send a large number of packets as exact packets to random destinations
// and make sure exact routing is perfect.
//
for (int i = 0; i < network_size; i++) {
for (int j = 0; j < network_size; j++) {
int src_idx = i;
int dest_idx = j;
Node src_node = (Node) _sorted_node_list.GetByIndex(src_idx);
Node dest_node = (Node) _sorted_node_list.GetByIndex(dest_idx);
//Console.WriteLine("{0} -> {1}", src_idx, dest_idx);
Address dest_address = (Address) dest_node.Address;
ISender s = new AHExactSender(src_node, dest_address);
MemBlock p = dest_address.ToMemBlock();
s.Send(new CopyList(new PType(routing_test), p));
_sent++;
//System.Threading.Thread.Sleep(10);
s.Send(new CopyList(new PType(routing_test), p));
_sent++;
//System.Threading.Thread.Sleep(10);
}
}
//wait for 10 more seconds
Console.WriteLine("Going to sleep for 10 seconds.");
System.Threading.Thread.Sleep(10000);
Console.WriteLine("Final statistics");
lock(_class_lock) {
Console.WriteLine("Sent: {0}, Received: {1}, Wrongly routed: {2}",
_sent, _received, _wrongly_routed);
}
int missing_rpcs = 0;
int correct_rpcs = 0;
int incorrect_rpcs = 0;
Hashtable queue_to_address = new Hashtable();
for (int i = 0; i < network_size; i++) {
for (int j = 0; j < network_size; j++) {
int src_idx = i;
int dest_idx = j;
Node src_node = (Node) _sorted_node_list.GetByIndex(src_idx);
Node dest_node = (Node) _sorted_node_list.GetByIndex(dest_idx);
//Console.WriteLine("{0} -> {1}", src_idx, dest_idx);
Address dest_address = (Address) dest_node.Address;
ISender s = new AHExactSender(src_node, dest_address);
RpcManager rpc_man = RpcManager.GetInstance(src_node);
Channel q = new Channel();
lock (_class_lock) {
queue_to_address[q] = dest_address;
}
q.CloseAfterEnqueue();
q.CloseEvent += delegate(object o, EventArgs cargs) {
lock(_class_lock) {
Channel qu = (Channel) o;
if (qu.Count == 0) {
missing_rpcs++;
}
queue_to_address.Remove(qu);
}
};
q.EnqueueEvent += delegate(object o, EventArgs cargs) {
lock(_class_lock) {
Channel qu = (Channel) o;
RpcResult rpc_reply = (RpcResult) qu.Peek();
byte []result = (byte[]) rpc_reply.Result;
Address target = new AHAddress(result);
if (target.Equals(queue_to_address[qu])) {
correct_rpcs++;
} else {
incorrect_rpcs++;
}
}
};
rpc_man.Invoke(s, q, "rpc_routing_test.GetIdentification", new object[]{});
}
}
//wait for 10 more seconds
while (true) {
int c = -1;
lock(_class_lock) {
c = incorrect_rpcs + missing_rpcs + correct_rpcs;
}
if (c < network_size*network_size) {
Console.WriteLine("Going to sleep for 10 seconds.");
System.Threading.Thread.Sleep(10000);
} else {
break;
}
}
Console.WriteLine("Final statistics");
Console.WriteLine("correct rpcs: {0}, incorrect rpcs: {1}, missing rpcs: {2}",
correct_rpcs, incorrect_rpcs, missing_rpcs);
System.Environment.Exit(1);
}
/**
* Callback function that is invoked when TargetSelector fetches candidate scores in a range.
* Initiates connection setup.
* Node: All connection messages can be tagged with a token string. This token string is currenly being
* used to keep the following information about a shortcut:
* 1. The node who initiated the shortcut setup.
* 2. The random target near which shortcut was chosen.
* @param start address pointing to the start of range to query.
* @param score_table list of candidate addresses sorted by score.
* @param current currently selected optimal (nullable)
*/
protected void CreateShortcutCallback(Address start, SortedList score_table, Address current) {
if (score_table.Count > 0) {
/**
* we remember our address and the start of range inside the token.
* token is the concatenation of
* (a) local node address
* (b) random target for the range queried by target selector
*/
string token = _node.Address + start.ToString();
//connect to the min_target
Address min_target = (Address) score_table.GetByIndex(0);
ISender send = null;
if (start.Equals(min_target)) {
//looks like the target selector simply returned our random address
if (LogEnabled) {
ProtocolLog.Write(ProtocolLog.SCO,
String.Format("SCO local: {0}, Connecting (shortcut) to min_target: {1} (greedy), random_target: {2}.",
_node.Address, min_target, start));
}
//use a greedy sender
send = new AHGreedySender(_node, min_target);
} else {
if (LogEnabled) {
ProtocolLog.Write(ProtocolLog.SCO,
String.Format("SCO local: {0}, Connecting (shortcut) to min_target: {1} (exact), random_target: {2}.",
_node.Address, min_target, start));
}
//use exact sender
send = new AHExactSender(_node, min_target);
}
ConnectTo(send, min_target, STRUC_SHORT, token);
}
}
/// <summary>This method handles IPPackets that come from Brunet, i.e.,
/// abroad. </summary>
/// <param name="packet"> The packet from Brunet.</param>
/// <param name="ret">An ISender to send data to the Brunet node that sent
/// the packet.</param>
public virtual void HandleIPIn(MemBlock packet, ISender ret)
{
if(_secure_senders && !(ret is SecurityAssociation)) {
return;
}
Address addr = null;
if(ret is SecurityAssociation) {
ret = ((SecurityAssociation) ret).Sender;
}
if(ret is AHSender) {
addr = ((AHSender) ret).Destination;
} else {
ProtocolLog.Write(IpopLog.PacketLog, String.Format(
"Incoming packet was not from an AHSender: {0}.", ret));
return;
}
if(_translator != null) {
try {
packet = _translator.Translate(packet, addr);
}
catch (Exception e) {
if(ProtocolLog.Exceptions.Enabled) {
ProtocolLog.Write(ProtocolLog.Exceptions, e.ToString());
}
return;
}
}
IPPacket ipp = new IPPacket(packet);
try {
if(!_address_resolver.Check(ipp.SourceIP, addr)) {
return;
}
} catch (AddressResolutionException ex) {
if(ex.Issue == AddressResolutionException.Issues.DoesNotExist) {
ProtocolLog.WriteIf(IpopLog.ResolverLog, "Notifying remote node of " +
" missing address: " + addr + ":" + ipp.SSourceIP);
ISender sender = new AHExactSender(Brunet, addr);
Brunet.Rpc.Invoke(sender, null, "Ipop.NoSuchMapping", ipp.SSourceIP);
return;
} else {
throw;
}
}
if(IpopLog.PacketLog.Enabled) {
ProtocolLog.Write(IpopLog.PacketLog, String.Format(
"Incoming packet:: IP src: {0}, IP dst: {1}, p2p " +
"from: {2}, size: {3}", ipp.SSourceIP, ipp.SDestinationIP,
ret, packet.Length));
}
WriteIP(packet);
}
/**
* Makes the ping request to a friend.
* @param address the address of the friend.
* @param dhtKey the friend's dhtkey.
*/
protected void FriendSearch(string address, string dhtKey,
string query)
{
Address addr = AddressParser.Parse(address);
Channel q = new Channel();
q.CloseAfterEnqueue();
q.CloseEvent += delegate(object obj, EventArgs eargs) {
try {
RpcResult res = (RpcResult) q.Dequeue();
string result = (string) res.Result;
UpdateDnsMapping(dhtKey, result);
ProtocolLog.WriteIf(SocialLog.SVPNLog,
String.Format("SEARCH FRIEND REPLY: {0} {1} {2} {3}",
DateTime.Now.TimeOfDay, dhtKey, address, result));
} catch(Exception e) {
_friends[dhtKey].Time = SocialUser.TIMEDEFAULT;
ProtocolLog.WriteIf(SocialLog.SVPNLog, e.Message);
ProtocolLog.WriteIf(SocialLog.SVPNLog,
String.Format("SEARCH FRIEND FAILURE: {0} {1} {2}",
DateTime.Now.TimeOfDay, dhtKey, address));
}
};
ProtocolLog.WriteIf(SocialLog.SVPNLog,
String.Format("SEARCH FRIEND REQUEST: {0} {1} {2}",
DateTime.Now.TimeOfDay, dhtKey, address));
ISender sender = new AHExactSender(_node, addr);
_rpc.Invoke(sender, q, "SocialVPN.GetDnsMapping", _local_user.DhtKey,
query);
}
protected void CreateBypassCallback(Address start, SortedList score_table, Address current) {
if (score_table.Count > 0) {
Address min_target = (Address) score_table.GetByIndex(0);
if (LogEnabled) {
ProtocolLog.Write(ProtocolLog.SCO,
String.Format("SCO local: {0}, Connecting (bypass) to min_target: {1}",
_node.Address, min_target));
}
ISender send = new AHExactSender(_node, min_target);
ConnectTo(send, STRUC_BYPASS);
}
}
/// <summary>First we try to find a third party we can connect with for
/// overlap, if that is successful, we attempt to connect to him, if that
/// is successful, we create a new tunnel edge.</summary>
protected void AttemptToCreateOverlap(TunnelEdgeCallbackAction teca)
{
WaitCallback create_connection = delegate(object o) {
Address target = o as Address;
if(o == null) {
FailedEdgeCreate(teca);
return;
}
ConnectionList cons = _connections;
int index = cons.IndexOf(target);
if(index < 0) {
FailedEdgeCreate(teca);
return;
}
List<Connection> overlap = new List<Connection>(1);
overlap.Add(cons[index]);
CreateEdge(teca, overlap);
};
Channel chan = new Channel(1);
chan.CloseEvent += delegate(object o, EventArgs ea) {
Address target = null;
try {
IDictionary msg = (chan.Dequeue() as RpcResult).Result as IDictionary;
target = _ito.EvaluatePotentialOverlap(msg);
} catch {
}
if(target == null) {
FailedEdgeCreate(teca);
} else {
_oco.ConnectTo(target, create_connection);
}
};
ISender s = new AHExactSender(_node, teca.TunnelTA.Target);
_node.Rpc.Invoke(s, chan, "tunnel.RequestSync");
}
virtual protected void ConnectTo(Address target, string ConnectionType,
string token)
{
ISender sender = new AHExactSender(_node, target);
ConnectTo(sender, target, ConnectionType, _node.Address.ToString());
}