public override string ToString()
{
try {
return(Data.GetString(System.Text.Encoding.ASCII));
}
catch {
return("AnnounceState: could not get string as ASCII");
}
}
/// <summary>
/// This method replaces IP addresses based on some identifier
/// </summary>
/// <param name="payload">Payload to be translated</param>
/// <param name="old_ss_ip">Old source IP address</param>
/// <param name="old_sd_ip">Old destination IP</param>
/// <param name="new_ss_ip">New source IP address</param>
/// <param name="new_sd_ip">New destination IP address</param>
/// <param name="packet_id">A packet identifier</param>
/// <returns>A MemBlock of the translated payload</returns>
public static MemBlock TextTranslate(MemBlock payload, string old_ss_ip,
string old_sd_ip, string new_ss_ip,
string new_sd_ip, string packet_id) {
string sdata = payload.GetString(System.Text.Encoding.UTF8);
if(sdata.Contains(packet_id)) {
sdata = sdata.Replace(old_ss_ip, new_ss_ip);
sdata = sdata.Replace(old_sd_ip, new_sd_ip);
payload = MemBlock.Reference(System.Text.Encoding.UTF8.GetBytes(sdata));
}
return payload;
}
/// <summary>
/// This method replaces IP addresses based on some identifier
/// </summary>
/// <param name="payload">Payload to be translated</param>
/// <param name="old_ss_ip">Old source IP address</param>
/// <param name="old_sd_ip">Old destination IP</param>
/// <param name="new_ss_ip">New source IP address</param>
/// <param name="new_sd_ip">New destination IP address</param>
/// <param name="packet_id">A packet identifier</param>
/// <returns>A MemBlock of the translated payload</returns>
public static MemBlock TextTranslate(MemBlock payload, string old_ss_ip,
string old_sd_ip, string new_ss_ip,
string new_sd_ip, string packet_id)
{
string sdata = payload.GetString(System.Text.Encoding.UTF8);
if (sdata.Contains(packet_id))
{
sdata = sdata.Replace(old_ss_ip, new_ss_ip);
sdata = sdata.Replace(old_sd_ip, new_sd_ip);
payload = MemBlock.Reference(System.Text.Encoding.UTF8.GetBytes(sdata));
}
return(payload);
}
/// <summary>All messages for the SecurityOverlord come through this loop.
/// It demuxes between Security, SecureData, and SecureControl packets, while
/// the remaining packets are left to the default handler.</summary>
override public void HandleData(MemBlock data, ISender return_path, object state)
{
MemBlock payload = null;
PType t = null;
try {
t = PType.Parse(data, out payload);
if (t.Equals(Security))
{
HandleData(payload, return_path, null);
}
else if (t.Equals(SecureData))
{
HandleData(payload, return_path);
}
else if (t.Equals(SecureControl))
{
HandleControl(payload, return_path);
}
else if (t.Equals(PType.Protocol.ReqRep))
{
_rrman.HandleData(payload, return_path, null);
}
else
{
Edge edge = return_path as Edge;
if (edge != null && !(edge is Brunet.Security.Transport.SecureEdge))
{
throw new Exception("Insecure edge attempting to communicate with the node!");
}
Subscriber sub = _sub;
if (sub == null)
{
throw new Exception("No default handler... this won't do!");
}
_sub.Handle(data, return_path);
}
} catch (Exception e) {
string ps = string.Empty;
try {
ps = payload.GetString(System.Text.Encoding.ASCII);
} catch { }
ProtocolLog.WriteIf(ProtocolLog.SecurityExceptions, String.Format(
"Security Packet Handling Exception, Type: {0}, From: {1}\n\tData: {2}\n\tException:{3}\n\tStack Trace:{4}",
t, return_path, ps, e, new System.Diagnostics.StackTrace(true)));
}
}
/**
* When a packet is to be delivered to this node,
* this method is called. This method is public so that
* we can chain protocols through the node. For instance,
* after a packet is handled, it may be a wrapped packet
* which actually contains another packet inside. Thus,
* the unwrapped packet could be "Announced" by the handler
*
* One needs to be careful to prevent an infinite loop of
* a Handler announcing the packet it is supposed to handle.
*/
protected virtual void Announce(MemBlock b, ISender from)
{
//When Subscribe or unsubscribe are called,
//they make copies of the ArrayList, thus we
//only need to hold the sync while we are
//getting the list of handlers.
/*
* Note that getting from Hashtable is threadsafe, multiple
* threads writing is a problem
*/
MemBlock payload = null;
int handlers = 0;
MultiSource ns = null;
PType t = null;
try {
t = PType.Parse(b, out payload);
ns = (MultiSource)DemuxHandler.GetTypeSource(t);
handlers = ns.Announce(payload, from);
/**
* @todo if no one handled the packet, we might want to send some
* ICMP-like message.
*/
if (handlers == 0)
{
string p_s = payload.GetString(System.Text.Encoding.ASCII);
ProtocolLog.WriteIf(ProtocolLog.Exceptions, String.Format(
"No Handler for packet type: {0} from: {2}\n{1} :: {3}", t, p_s, from, b.ToBase16String()));
}
}
catch (Exception x) {
ProtocolLog.WriteIf(ProtocolLog.Exceptions, String.Format(
"Packet Handling Exception"));
string nodeSource = "null";
if (ns != null)
{
nodeSource = ns.ToString();
}
ProtocolLog.WriteIf(ProtocolLog.Exceptions, String.Format(
"Handler: {0}\tEdge: {1}", nodeSource, from));
ProtocolLog.WriteIf(ProtocolLog.Exceptions, String.Format(
"Exception: {0}", x));
}
}
public void HandleData(MemBlock b, ISender from, object state)
{
MemBlock payload = null;
PType t = null;
try {
t = PType.Parse(b, out payload);
if (t.Equals(PType.Protocol.ReqRep))
{
_rrm.HandleData(payload, from, state);
}
else if (t.Equals(PType.Protocol.Rpc))
{
Rpc.HandleData(payload, from, state);
}
}
catch (Exception x) {
Console.Error.WriteLine("Packet Handling Exception: {3}\n\tType: {0}\n\t\n\tFrom: {1}\n\tData: {2}",
t, from, payload.GetString(System.Text.Encoding.ASCII), x);
}
}
virtual public void HandleData(MemBlock data, ISender return_path, object state)
{
Address addr = GetAddress(return_path);
if (addr == null)
{
ProtocolLog.WriteIf(ProtocolLog.ConnectionHandlerLog,
String.Format("Unable to obtain an address for: {0}", return_path));
return;
}
_ondemand.Set(addr);
try {
_sub.Handle(data, return_path);
} catch {
string d_s = data.GetString(System.Text.Encoding.ASCII);
ProtocolLog.WriteIf(ProtocolLog.Exceptions, String.Format(
"Error handling packet from {0}, containing {1}",
return_path, d_s));
}
}
/// <summary>This is the only method declared by IDataHandler. All packets that
/// are of PType("HelloWorld") will arrive here.</summary>
/// <param name="payload">The data portion of the packet.</summary>
/// <param name="return_path">The return path to the sending node.</summary>
/// <param name="state">Optional state that is specified during the
/// subscribe state.</summary>
public void HandleData(MemBlock payload, ISender return_path, object state) {
Console.WriteLine(return_path + ": " + payload.GetString(System.Text.Encoding.UTF8));
}
/// <summary>This is the only method declared by IDataHandler. All packets that
/// are of PType("HelloWorld") will arrive here.</summary>
/// <param name="payload">The data portion of the packet.</summary>
/// <param name="return_path">The return path to the sending node.</summary>
/// <param name="state">Optional state that is specified during the
/// subscribe state.</summary>
public void HandleData(MemBlock payload, ISender return_path, object state)
{
Console.WriteLine(return_path + ": " + payload.GetString(System.Text.Encoding.UTF8));
}
