/// <summary>
/// Read a named unsigned integer parameter from a
/// <c>ProtocolParams</c> instance.
/// </summary>
/// <returns><paramref name="defaultValue"/> if <paramref name="parameters"/>
/// is <c>null</c> or <paramref name="parameterName"/> cannot be found.
/// Otherwise it returns the named parameter as an unsigned
/// integer.</returns>
public static uint LookupUInt32(ProtocolParams parameters,
string parameterName,
uint defaultValue)
{
if (parameters == null)
{
return(defaultValue);
}
else if (parameterName == null)
{
throw new ArgumentNullException();
}
string sValue = parameters[parameterName];
if (sValue == null)
{
return(defaultValue);
}
try {
return(UInt32.Parse(sValue));
}
catch {
Core.Log("Failed on parameter \"{0}\" value \"{1}\"\n",
parameterName, sValue);
return(defaultValue);
}
}
/// <summary>
/// Read a named boolean parameter from a <c>ProtocolParams</c>
/// instance.
/// </summary>
/// <returns><paramref name="defaultValue"/> if <paramref name="parameters"/>
/// is <c>null</c> or <paramref name="parameterName"/> cannot be found.
/// Otherwise it returns the named parameter as a boolean.</returns>
public static bool LookupBoolean(ProtocolParams parameters,
string parameterName,
bool defaultValue)
{
if (parameters == null)
{
return(defaultValue);
}
else if (parameterName == null)
{
throw new ArgumentNullException();
}
string sValue = parameters[parameterName];
if (sValue == null)
{
return(defaultValue);
}
try {
return(Boolean.Parse(sValue));
}
catch (FormatException) {
Core.Log("Failed on parameter \"{0}\" value \"{1}\"\n",
parameterName, sValue);
return(defaultValue);
}
}
// IProtocol interfaces
// ------------------------
public bool Initialize(ProtocolParams parameters)
{
Debug.Assert(parameters == null ||
parameters["name"] == moduleName);
hostConfig = new HostConfiguration();
version = ProtocolParams.LookupInt32(parameters, "version", 4);
bool fragment = ProtocolParams.LookupBoolean(parameters,
"fragment",
false);
// save the routing protocol name, if exists
if (version != 4 || fragment == true)
{
DebugPrint("Support only exists for V4 w/o fragments.\n");
return(false);
}
Core core = Core.Instance();
core.RegisterProtocol(this);
if (!core.packetTypes.RegisterTypeHandler(PacketTypes.IP, this))
{
core.DeregisterProtocol(this);
return(false);
}
return(true);
}
// IProtocol interfaces
// ------------------------
public bool Initialize(ProtocolParams parameters)
{
Debug.Assert(parameters == null || parameters["name"] == "TCP");
Core.Instance().RegisterProtocol(this);
TcpSessionPool.SetTcpModule(this);
return(true);
}
// IProtocol interfaces
// ------------------------
public bool Initialize(ProtocolParams parameters)
{
Debug.Assert(parameters == null || parameters["name"] == "ICMP");
Core.Instance().RegisterProtocol(this);
// no need to register at the packet level!
return(true);
}
/// <summary>
/// Read a named string parameter from a <c>ProtocolParams</c>
/// instance.
/// </summary>
/// <returns><paramref name="defaultValue"/> if <paramref name="parameters"/>
/// is <c>null</c> or <paramref name="parameterName"/> cannot be found.
/// Otherwise it returns the named parameter as a string.</returns>
public static string LookupString(ProtocolParams parameters,
string parameterName,
string defaultValue)
{
if (parameters == null)
{
return(defaultValue);
}
else if (parameterName == null)
{
throw new ArgumentNullException();
}
string sValue = parameters[parameterName];
if (sValue == null)
{
return(defaultValue);
}
return(sValue);
}
// This method dynamically loads a protocol and
// initializes it.
protected bool LoadProtocolModule(ProtocolParams args)
{
// the user can mark a protocol ignore field so
// we just ignore it...
string ignore = args["ignore"];
if (ignore != null && ignore == "true")
{
return(true);
}
#if DEBUG
System.Console.Out.WriteLine("[Protocol {0}]", args["name"]);
foreach (string s in args.Keys)
{
System.Console.Out.WriteLine("{0}={1}", s, args[s]);
}
System.Console.Out.WriteLine("-----------------------------");
#endif
// dynamic load the protocol
// by default it is in the Runtime assembly
string protocolType = args["type"];
try {
IProtocol protocol = (IProtocol)Activator.CreateInstance(Type.GetType(protocolType));
if (protocol == null)
{
throw new Exception("Can't find Protocol's Class.");
}
// initialize the protocol
protocol.Initialize(args);
}
catch (Exception e) {
Console.Out.WriteLine(String.Format("Can't load protocol class: {0}", protocolType));
Console.Out.WriteLine(e.Message);
return(false);
}
return(true);
}
// IProtocol interfaces
// ------------------------
public bool Initialize(ProtocolParams parameters)
{
Debug.Assert(parameters == null || parameters["name"] == "ARP");
int size = ProtocolParams.LookupInt32(parameters, "cacheSize",
128);
int age = ProtocolParams.LookupInt32(parameters, "max-age",
ArpTable.MaxAge);
arpTable = new ArpTable(size, age, this);
pendingRequests = new ArrayList();
Core core = Core.Instance();
core.RegisterProtocol(this);
if (!core.packetTypes.RegisterTypeHandler(PacketTypes.ARP, this))
{
core.DeregisterProtocol(this);
return(false);
}
return(true);
}
// loads an adapter's driver and add the relevant data structures
// for managing it.
protected bool LoadAdapter(ProtocolParams args, string driversPath)
{
// the user can ignore an adapter
// so ignore it...
string ignore = args["ignore"];
if (ignore != null && ignore == "true")
{
return(true);
}
string name =
ProtocolParams.LookupString(args, "name", "unknown");
string typeName =
ProtocolParams.LookupString(args, "type", "unknown");
string id =
ProtocolParams.LookupString(args, "id", "unknown");
int mtu = ProtocolParams.LookupInt32(args, "mtu",
EthernetFormat.MaxFrameSize);
int txRing = ProtocolParams.LookupInt32(args, "txRing", 64);
int rxRing = ProtocolParams.LookupInt32(args, "rxRing", 64);
int fwQueue = ProtocolParams.LookupInt32(args, "fwQueue", 64);
IAdapterFactory factory = null;
IAdapter adapter = null;
try {
string factoryTypeName = typeName + "Factory";
Assembly assembly = Assembly.LoadFrom(driversPath);
Type[] types = assembly.GetTypes();
foreach (Type t in types)
{
if (t.IsClass && t.Name.Equals(typeName))
{
factory = (IAdapterFactory)Activator.CreateInstance(t, null);
break;
}
if (factory == null)
{
throw new Exception("Can't find Adapter's Factory.");
}
adapter = factory.CreateAdapter(name, id, txRing, rxRing);
Core.Instance().RegisterAdapter(adapter, fwQueue);
}
}
catch (Exception e) {
adapter = null;
Console.Out.WriteLine(e.Message);
Environment.Exit(1);
}
IPModule ipModule = Core.Instance().GetProtocolByName("IP") as IPModule;
HostConfiguration hostConfig = ipModule.HostConfiguration;
for (int i = 0;; i++)
{
string ipTag = String.Format("ip{0}", i);
string maskTag = String.Format("mask{0}", i);
string gatewayTag = String.Format("gateway{0}", i);
// XXX No point-to-point support here.
IPv4 address = ProtocolParams.LookupIPv4(args, ipTag,
IPv4.AllOnes);
IPv4 netmask = ProtocolParams.LookupIPv4(args, maskTag,
IPv4.AllOnes);
IPv4 gateway = ProtocolParams.LookupIPv4(args, gatewayTag,
IPv4.Zero);
if (address == IPv4.AllOnes || netmask == IPv4.AllOnes)
{
break;
}
hostConfig.Bindings.Add(adapter,
new InterfaceIPConfiguration(address, netmask, gateway, 128)
);
}
#if DEBUG
System.Console.Out.WriteLine("[Interface {0}]", args["name"]);
System.Console.Out.WriteLine("-----------------------------");
#endif
return(true);
}
//handle host config
protected void HandleConfiguration()
{
Core core = Core.Instance();
// the path of the driver assembly
ConfigElement config = ParseConfiguration(false);
// we start with the configuration tag...
// we assume that the XML is valid!
// if we have children, and we have...
if (config.ChildElements.Count > 0)
{
foreach (ConfigElement element in config.ChildElements)
{
switch (element.TagName)
{
case "creator":
break;
case "date":
break;
case "hostname":
break;
case "forwarding":
break;
case "OutQHandlerTimeout":
core.SetOutQueueHandlerInterval(Convert.ToInt32(element.Text, 10));
break;
case "protocol-path":
protocolsPath = element.Text;
break;
case "drivers-path":
driversPath = element.Text;
break;
case "backlog-size":
int freeListSize = Convert.ToInt32(element.Text, 10);
core.ProvisionDemux(
freeListSize,
EthernetFormat.MaxFrameSize
);
break;
case "protocols":
// handle the protocols
// use a generic scheme and apply
// it to the adapters in the future ;-)
// the args include the name and type!
ProtocolParams args = new ProtocolParams();;
foreach (ConfigElement prot in element.ChildElements)
{
args.Clear();
foreach (string attr in prot.Attributes.Keys)
{
args.Add(attr, prot.Attribute(attr));
}
foreach (ConfigElement protInfo in prot.ChildElements)
{
args.Add(protInfo.TagName, protInfo.Text);
}
// done with one...
if (!LoadProtocolModule(args))
{
Core.Panic("Error while loading Protocol");
}
}
break;
case "adapters":
// handle the adapters
ProtocolParams adArgs = new ProtocolParams();;
foreach (ConfigElement ad in element.ChildElements)
{
adArgs.Clear();
foreach (string attr in ad.Attributes.Keys)
{
adArgs.Add(attr, ad.Attribute(attr));
}
foreach (ConfigElement adInfo in ad.ChildElements)
{
adArgs.Add(adInfo.TagName, adInfo.Text);
}
// done with one...
if (!LoadAdapter(adArgs, driversPath))
{
Core.Panic("Error while loading an Adapter");
}
}
break;
}
}
}
}
public bool Initialize(ProtocolParams parameters)
{
Core.Instance().RegisterProtocol(this);
return(true);
}