/// <summary>
/// Send data to client.
/// </summary>
/// <param name="data">Data array to send.</param>
/// <exception cref="Exception">Thrown if destination is null or destinationPort is 0.</exception>
/// <exception cref="ArgumentException">Thrown on fatal error (contact support).</exception>
/// <exception cref="OverflowException">Thrown if data array length is greater than Int32.MaxValue.</exception>
/// <exception cref="Sys.IO.IOException">Thrown on IO error.</exception>
/// <exception cref="Exception">Thrown if TCP Status is not ESTABLISHED.</exception>
public void Send(byte[] data)
{
if ((StateMachine.destination == null) || (StateMachine.destinationPort == 0))
{
throw new InvalidOperationException("Must establish a default remote host by calling Connect() before using this Send() overload");
}
if (StateMachine.Status != Status.ESTABLISHED)
{
throw new Exception("Client must be connected before sending data.");
}
if (data.Length > 536)
{
var chunks = ArrayHelper.ArraySplit(data, 536);
for (int i = 0; i < chunks.Length; i++)
{
var packet = new TCPPacket(StateMachine.source, StateMachine.destination, (ushort)StateMachine.localPort, (ushort)StateMachine.destinationPort, StateMachine.SequenceNumber, StateMachine.AckNumber, 20, i == chunks.Length - 2 ? (byte)(Flags.PSH | Flags.ACK) : (byte)(Flags.ACK), 0xFAF0, 0, chunks[i]);
OutgoingBuffer.AddPacket(packet);
NetworkStack.Update();
StateMachine.SequenceNumber += (uint)chunks[i].Length;
}
}
else
{
var packet = new TCPPacket(StateMachine.source, StateMachine.destination, (ushort)StateMachine.localPort, (ushort)StateMachine.destinationPort, StateMachine.SequenceNumber, StateMachine.AckNumber, 20, (byte)(Flags.PSH | Flags.ACK), 0xFAF0, 0, data);
OutgoingBuffer.AddPacket(packet);
NetworkStack.Update();
StateMachine.SequenceNumber += (uint)data.Length;
}
StateMachine.WaitingAck = true;
}
/// <summary>
/// Send data to client.
/// </summary>
/// <param name="data">Data array to send.</param>
/// <exception cref="Exception">Thrown if destination is null or destinationPort is 0.</exception>
/// <exception cref="ArgumentException">Thrown on fatal error (contact support).</exception>
/// <exception cref="OverflowException">Thrown if data array length is greater than Int32.MaxValue.</exception>
/// <exception cref="Sys.IO.IOException">Thrown on IO error.</exception>
/// <exception cref="Exception">Thrown if TCP Status is not ESTABLISHED.</exception>
public void Send(byte[] data)
{
if ((StateMachine.RemoteEndPoint.Address == null) || (StateMachine.RemoteEndPoint.Port == 0))
{
throw new InvalidOperationException("Must establish a default remote host by calling Connect() before using this Send() overload");
}
if (StateMachine.Status != Status.ESTABLISHED)
{
throw new Exception("Client must be connected before sending data.");
}
if (data.Length > 536)
{
var chunks = ArrayHelper.ArraySplit(data, 536);
for (int i = 0; i < chunks.Length; i++)
{
var packet = new TCPPacket(StateMachine.LocalEndPoint.Address, StateMachine.RemoteEndPoint.Address, StateMachine.LocalEndPoint.Port, StateMachine.RemoteEndPoint.Port, StateMachine.TCB.SndNxt, StateMachine.TCB.RcvNxt, 20, i == chunks.Length - 2 ? (byte)(Flags.PSH | Flags.ACK) : (byte)(Flags.ACK), StateMachine.TCB.SndWnd, 0, chunks[i]);
OutgoingBuffer.AddPacket(packet);
NetworkStack.Update();
StateMachine.TCB.SndNxt += (uint)chunks[i].Length;
}
}
else
{
var packet = new TCPPacket(StateMachine.LocalEndPoint.Address, StateMachine.RemoteEndPoint.Address, StateMachine.LocalEndPoint.Port, StateMachine.RemoteEndPoint.Port, StateMachine.TCB.SndNxt, StateMachine.TCB.RcvNxt, 20, (byte)(Flags.PSH | Flags.ACK), StateMachine.TCB.SndWnd, 0, data);
OutgoingBuffer.AddPacket(packet);
NetworkStack.Update();
StateMachine.TCB.SndNxt += (uint)data.Length;
}
}
/// <summary>
/// Connect to client.
/// </summary>
/// <param name="dest">Destination address.</param>
/// <param name="destPort">Destination port.</param>
/// <exception cref="Exception">Thrown if TCP Status is not CLOSED.</exception>
public void Connect(Address dest, int destPort, int timeout = 5000)
{
if (StateMachine.Status != Status.CLOSED)
{
throw new Exception("Client must be closed before setting a new connection.");
}
StateMachine.destination = dest;
StateMachine.destinationPort = destPort;
StateMachine.source = IPConfig.FindNetwork(dest);
//Generate Random Sequence Number
var rnd = new Random();
StateMachine.SequenceNumber = (uint)((rnd.Next(0, Int32.MaxValue)) << 32) | (uint)(rnd.Next(0, Int32.MaxValue));
// Flags=0x02 -> Syn
var packet = new TCPPacket(StateMachine.source, StateMachine.destination, (ushort)StateMachine.localPort, (ushort)destPort, StateMachine.SequenceNumber, 0, 20, (byte)Flags.SYN, 0xFAF0, 0);
OutgoingBuffer.AddPacket(packet);
NetworkStack.Update();
StateMachine.Status = Status.SYN_SENT;
if (StateMachine.WaitStatus(Status.ESTABLISHED, timeout) == false)
{
throw new Exception("Failed to open TCP connection!");
}
}
/// <summary>
/// Close connection.
/// </summary>
/// <exception cref="ArgumentOutOfRangeException">Thrown on fatal error (contact support).</exception>
/// <exception cref="Exception">Thrown if TCP Status is CLOSED.</exception>
public void Close()
{
if (StateMachine.Status == Status.CLOSED)
{
throw new Exception("Client already closed.");
}
if (StateMachine.Status == Status.ESTABLISHED)
{
var packet = new TCPPacket(StateMachine.source, StateMachine.destination, (ushort)StateMachine.localPort, (ushort)StateMachine.destinationPort, StateMachine.SequenceNumber, StateMachine.AckNumber, 20, (byte)(Flags.FIN | Flags.ACK), 0xFAF0, 0);
OutgoingBuffer.AddPacket(packet);
NetworkStack.Update();
StateMachine.SequenceNumber++;
StateMachine.Status = Status.FIN_WAIT1;
if (StateMachine.WaitStatus(Status.CLOSED, 5000) == false)
{
throw new Exception("Failed to close TCP connection!");
}
}
if (clients.ContainsKey((uint)StateMachine.localPort))
{
clients.Remove((uint)StateMachine.localPort);
}
}
private static void Main()
{
var app = new App(new AppProps());
var networkStack = new NetworkStack(app, "ExampleNetwork", new StackProps());
var pipelineStack = new PipelineStack(app, "ExamplePipeline", new PipelineStackProps
{
GitHubSecretName = "github.com/roberthodgen",
ApiImageTag = apiImageTag,
ApiStackName = apiStackName,
GitHubOwner = gitHubOwner,
GitHubRepo = gitHubRepo,
});
new IntegrationTestStack(app, "ExampleIntegrationTests", new IntegrationTestStackProps
{
GitHubOwner = gitHubOwner,
GitHubRepo = gitHubRepo,
});
new ApiStack(app, apiStackName, new ApiStackProps
{
Vpc = networkStack.Vpc,
Repository = pipelineStack.EcrRepository,
ApiImageTag = apiImageTag,
});
app.Synth();
}
/// <summary>
/// Received reply.
/// </summary>
/// <summary>
/// Create new instance of the <see cref="ICMPPacket"/> class.
/// </summary>
/// <param name="packetData">Packet data.</param>
/// <exception cref="ArgumentException">Thrown if packetData is invalid.</exception>
internal static void ICMPHandler(byte[] packetData)
{
Global.mDebugger.Send("ICMP Handler called");
var icmp_packet = new ICMPPacket(packetData);
switch (icmp_packet.ICMPType)
{
case 0:
var receiver = ICMPClient.GetClient(icmp_packet.SourceIP.Hash);
if (receiver != null)
{
receiver.ReceiveData(icmp_packet);
}
Global.mDebugger.Send("Received ICMP Echo reply from " + icmp_packet.SourceIP.ToString());
break;
case 8:
var request = new ICMPEchoRequest(packetData);
var reply = new ICMPEchoReply(request);
Global.mDebugger.Send("Sending ICMP Echo reply to " + reply.DestinationIP.ToString());
OutgoingBuffer.AddPacket(reply);
NetworkStack.Update();
break;
}
}
public void Send(byte[] data)
{
if ((this.destination == null) ||
(this.destinationPort == 0))
{
throw new Exception("Must establish a default remote host by calling Connect() before using this Send() overload");
}
Send(data, this.destination, this.destinationPort);
NetworkStack.Update();
int _deltaT = 0;
int second = 0;
while (!readytosend)
{
if (_deltaT != Cosmos.HAL.RTC.Second)
{
second++;
_deltaT = Cosmos.HAL.RTC.Second;
}
if (second >= 4)
{
Console.WriteLine("No response in 4 secondes...");
break;
}
}
//Console.WriteLine("Done!");
}
/*
* Method called to applied the differents options received in the DHCP packet ACK
**/
/// <summary>
/// Apply the new IP configuration received.
/// </summary>
/// <param name="Options">DHCPOption class using the packetData from the received dhcp packet.</param>
/// <param name="message">Enable/Disable the displaying of messages about DHCP applying and conf. Disabled by default.
/// </param>
public static void Apply(DHCPOption Options, bool message = false)
{
NetworkStack.RemoveAllConfigIP();
//cf. Roadmap. (have to change this, because some network interfaces are not configured in dhcp mode) [have to be done in 0.5.x]
foreach (NetworkDevice networkDevice in NetworkDevice.Devices)
{
if (message)
{
Console.WriteLine();
Console.WriteLine("[DHCP ACK][" + networkDevice.Name + "] Packet received, applying IP configuration...");
Console.WriteLine(" IP Address : " + Options.Address().ToString());
Console.WriteLine(" Subnet mask : " + Options.Subnet().ToString());
Console.WriteLine(" Gateway : " + Options.Gateway().ToString());
Console.WriteLine(" DNS server : " + Options.DNS01().ToString());
}
Settings settings = new Settings(@"0:\" + networkDevice.Name + ".conf");
settings.EditValue("ipaddress", Options.Address().ToString());
settings.EditValue("subnet", Options.Subnet().ToString());
settings.EditValue("gateway", Options.Gateway().ToString());
settings.EditValue("dns01", Options.DNS01().ToString());
settings.EditValue("dhcp_server", Options.Server().ToString());
settings.PushValues();
NetworkInit.Enable();
if (message)
{
Console.WriteLine("[DHCP CONFIG][" + networkDevice.Name + "] IP configuration applied.");
Console.WriteLine();
DHCPAsked = false;
}
}
}
public static void Main(string[] args)
{
var app = new App();
var props = new StackProps()
{
Env = new Environment()
{
Account = "353697730469",
Region = "us-east-1"
}
};
var network = new NetworkStack(app, "companies", props);
new FrontendStack(app, "companies", "zro17.com");
new DatabaseStack(app, "companies", network.GetVpc(), props);
new SchedulerStack(app, "regulatory-sec-update", 128, new CronOptions()
{
Minute = "*/5",
Hour = "*",
Day = "*",
Month = "*",
Year = "*"
}, network.GetVpc(), props);
new ConsumerStack(app, "regulatory-sec-reader", 128, network.GetVpc(), props);
new ConsumerStack(app, "regulatory-sec-parser", 128, network.GetVpc(), props);
new ConsumerStack(app, "calculations-indexes", 128, network.GetVpc(), props);
app.Synth();
}
protected override void BeforeRun()
{
try
{
using (var xClient = new DHCPClient())
{
/** Send a DHCP Discover packet **/
//This will automatically set the IP config after DHCP response
NetworkStack.Update();
int r = xClient.SendDiscoverPacket();
if (r == -1)
{
Console.WriteLine("Failure while configuring DHCP: timeout");
ManualConfig();
}
else
{
Console.WriteLine("DHCP Configure: result: " + r);
}
xClient.Close(); //don't forget to close!
}
ipconfig();
}
catch (Exception x)
{
Console.WriteLine("err: " + x.Message);
}
}
/// <summary>
/// Send acknowledgement packet
/// </summary>
private void SendEmptyPacket(Flags flag)
{
var packet = new TCPPacket(source, destination, (ushort)localPort, (ushort)destinationPort, SequenceNumber, AckNumber, 20, (byte)flag, 0xFAF0, 0);
OutgoingBuffer.AddPacket(packet);
NetworkStack.Update();
}
/// <summary>
/// CommandIPConfig without args
/// </summary>
public override ReturnInfo Execute()
{
if (NetworkStack.ConfigEmpty())
{
Console.WriteLine("No network configuration detected! Use ipconfig /help");
}
foreach (HAL.Drivers.Network.NetworkDevice device in NetworkConfig.Keys)
{
switch (device.CardType)
{
case HAL.Drivers.Network.CardType.Ethernet:
Console.WriteLine("Ethernet Card : " + device.NameID + " - " + device.Name);
break;
case HAL.Drivers.Network.CardType.Wireless:
Console.WriteLine("Wireless Card : " + device.NameID + " - " + device.Name);
break;
}
Utils.Settings settings = new Utils.Settings(@"0:\System\" + device.Name + ".conf");
Console.WriteLine("MAC Address : " + device.MACAddress.ToString());
Console.WriteLine("IP Address : " + NetworkConfig.Get(device).IPAddress.ToString());
Console.WriteLine("Subnet mask : " + NetworkConfig.Get(device).SubnetMask.ToString());
Console.WriteLine("Default Gateway : " + NetworkConfig.Get(device).DefaultGateway.ToString());
Console.WriteLine("Preferred DNS server : " + settings.GetValue("dns01"));
}
return(new ReturnInfo(this, ReturnCode.OK));
}
/// <summary>
/// Send ICMP Echo
/// </summary>
public void SendEcho()
{
Address source = IPConfig.FindNetwork(destination);
ICMPEchoRequest request = new ICMPEchoRequest(source, destination, 0x0001, 0x50); //this is working
OutgoingBuffer.AddPacket(request); //Aura doesn't work when this is called.
NetworkStack.Update();
}
/// <summary>
/// Send a request to apply the new IP configuration
/// </summary>
public static void SendRequestPacket(Address RequestedAddress, Address DHCPServerAddress)
{
foreach (NetworkDevice networkDevice in NetworkDevice.Devices)
{
DHCPRequest dhcp_request = new DHCPRequest(networkDevice.MACAddress, RequestedAddress, DHCPServerAddress);
OutgoingBuffer.AddPacket(dhcp_request);
NetworkStack.Update();
}
}
public Network(Helper aHelper)
{
iHelper = aHelper;
iBoxList = new List <Box>();
iNetworkChangeWatcher = new NetworkChangeWatcher();
// create the list of network interfaces
iInterfaces = new List <NetworkInterface>();
foreach (NetworkInfoModel i in NetworkInfo.GetAllNetworkInterfaces())
{
if (i.OperationalStatus == EOperationalStatus.eUp ||
i.OperationalStatus == EOperationalStatus.eUnknown)
{
// don't add 3G network card on iPads/iPhones
if (i.Name != "pdp_ip0")
{
iInterfaces.Add(new NetworkInterface(i));
}
}
}
// create separate network stacks for each available interface
iNetworkStacks = new List <NetworkStack>();
foreach (NetworkInterface iface in iInterfaces)
{
if (iface.Status == NetworkInterface.EStatus.eAvailable)
{
NetworkStack stack = new NetworkStack(aHelper, iface.Info.IPAddress);
stack.Boxes.EventRoomAdded += RoomAddedHandler;
stack.Boxes.EventRoomRemoved += RoomRemovedHandler;
try
{
// start the stack
UserLog.WriteLine(String.Format("{0}: Linn.Wizard.Network starting stack({1})", DateTime.Now, iface.Info.IPAddress.ToString()));
stack.Start();
UserLog.WriteLine(String.Format("{0}: Linn.Wizard.Network starting stack({1}) ok", DateTime.Now, iface.Info.IPAddress.ToString()));
// success - add it to the list
iNetworkStacks.Add(stack);
}
catch (Exception e)
{
// failed to start - unhook handlers and ignore
UserLog.WriteLine(String.Format("{0}: Linn.Wizard.Network starting stack({1}) failed", DateTime.Now, iface.Info.IPAddress.ToString()));
UserLog.WriteLine("Error Message: " + e.Message);
UserLog.WriteLine("Error Message: " + e.ToString());
stack.Boxes.EventRoomAdded -= RoomAddedHandler;
stack.Boxes.EventRoomRemoved -= RoomRemovedHandler;
}
}
}
}
/// <summary>
/// Send TCP packet.
/// </summary>
private void SendPacket(TCPPacket packet)
{
OutgoingBuffer.AddPacket(packet);
NetworkStack.Update();
if (packet.SYN || packet.FIN)
{
TCB.SndNxt++;
}
}
/// <summary>
/// Send a request to apply the new IP configuration
/// </summary>
/// <returns>time value (-1 = timeout)</returns>
private int SendRequestPacket(Address RequestedAddress)
{
foreach (NetworkDevice networkDevice in NetworkDevice.Devices)
{
var dhcp_request = new DHCPRequest(networkDevice.MACAddress, RequestedAddress);
OutgoingBuffer.AddPacket(dhcp_request);
NetworkStack.Update();
}
return(Receive());
}
/// <summary>
/// Send data to client.
/// </summary>
/// <param name="data">Data array to send.</param>
/// <exception cref="Exception">Thrown if destination is null or destinationPort is 0.</exception>
/// <exception cref="ArgumentException">Thrown on fatal error (contact support).</exception>
/// <exception cref="OverflowException">Thrown if data array length is greater than Int32.MaxValue.</exception>
/// <exception cref="Sys.IO.IOException">Thrown on IO error.</exception>
public void Send(byte[] data)
{
if ((destination == null) || (destinationPort == 0))
{
throw new InvalidOperationException("Must establish a default remote host by calling Connect() before using this Send() overload");
}
Send(data, destination, destinationPort);
NetworkStack.Update();
}
public void Ask(string url)
{
Settings settings = new Settings(@"0:\System\" + NetworkInterfaces.Interface("eth0") + ".conf");
Address gateway = Address.Parse(settings.Get("dns01"));
Address source = Config.FindNetwork(gateway);
askpacket = new DNSPacketAsk(source, gateway, 0x1234, 0x0100, 1, url);
OutgoingBuffer.AddPacket(askpacket);
NetworkStack.Update();
}
public static bool Enable(NetworkDevice device, Address ip, Address subnet, Address gw)
{
if (device != null)
{
var config = new IPConfig(ip, subnet, gw);
NetworkStack.ConfigIP(device, config);
Global.mDebugger.Send("Config OK.");
return(true);
}
return(false);
}
/// <summary>
/// Send a packet to find the DHCP server and tell that we want a new IP address
/// </summary>
public static void SendDiscoverPacket()
{
foreach (NetworkDevice networkDevice in NetworkDevice.Devices)
{
DHCPDiscover dhcp_discover = new DHCPDiscover(networkDevice.MACAddress);
OutgoingBuffer.AddPacket(dhcp_discover);
NetworkStack.Update();
DHCPAsked = true;
}
}
/// <summary>
/// Send DNS Ask for Domain Name string
/// </summary>
/// <param name="url">Domain Name string.</param>
public void SendAsk(string url)
{
Address source = IPConfig.FindNetwork(destination);
queryurl = url;
var askpacket = new DNSPacketAsk(source, destination, url);
OutgoingBuffer.AddPacket(askpacket);
NetworkStack.Update();
}
/// <summary>
/// Send a packet to find the DHCP server and tell that we want a new IP address
/// </summary>
public static void SendDiscoverPacket()
{
NetworkStack.RemoveAllConfigIP();
foreach (NetworkDevice networkDevice in NetworkDevice.Devices)
{
NetworkInit.Enable(networkDevice, new Network.IPV4.Address(0, 0, 0, 0), new Network.IPV4.Address(0, 0, 0, 0), new Network.IPV4.Address(0, 0, 0, 0));
DHCPDiscover dhcp_discover = new DHCPDiscover(networkDevice.MACAddress);
OutgoingBuffer.AddPacket(dhcp_discover);
NetworkStack.Update();
DHCPAsked = true;
}
}
/// <summary>
/// Send a packet to the DHCP server to make the address available again
/// </summary>
public void SendReleasePacket()
{
foreach (NetworkDevice networkDevice in NetworkDevice.Devices)
{
Address source = IPConfig.FindNetwork(DHCPServerAddress(networkDevice));
var dhcp_release = new DHCPRelease(source, DHCPServerAddress(networkDevice), networkDevice.MACAddress);
OutgoingBuffer.AddPacket(dhcp_release);
NetworkStack.Update();
NetworkStack.RemoveAllConfigIP();
IPConfig.Enable(networkDevice, new Address(0, 0, 0, 0), new Address(0, 0, 0, 0), new Address(0, 0, 0, 0));
}
Close();
}
/*
* Method called to applied the differents options received in the DHCP packet ACK
**/
/// <summary>
/// Apply the new IP configuration received.
/// </summary>
/// <param name="Options">DHCPOption class using the packetData from the received dhcp packet.</param>
/// <param name="message">Enable/Disable the displaying of messages about DHCP applying and conf. Disabled by default.
/// </param>
public static void Apply(DHCPAck packet, bool message = false)
{
NetworkStack.RemoveAllConfigIP();
//cf. Roadmap. (have to change this, because some network interfaces are not configured in dhcp mode) [have to be done in 0.5.x]
foreach (NetworkDevice networkDevice in NetworkDevice.Devices)
{
if (packet.Client.ToString() == null ||
packet.Client.ToString() == null ||
packet.Client.ToString() == null ||
packet.Client.ToString() == null)
{
CustomConsole.WriteLineError("Parsing DHCP ACK Packet failed, can't apply network configuration.");
}
else
{
if (message)
{
Console.WriteLine();
CustomConsole.WriteLineInfo("[DHCP ACK][" + networkDevice.Name + "] Packet received, applying IP configuration...");
CustomConsole.WriteLineInfo(" IP Address : " + packet.Client.ToString());
CustomConsole.WriteLineInfo(" Subnet mask : " + packet.Subnet.ToString());
CustomConsole.WriteLineInfo(" Gateway : " + packet.Server.ToString());
CustomConsole.WriteLineInfo(" DNS server : " + packet.DNS.ToString());
}
Utils.Settings settings = new Utils.Settings(@"0:\System\" + networkDevice.Name + ".conf");
settings.EditValue("ipaddress", packet.Client.ToString());
settings.EditValue("subnet", packet.Subnet.ToString());
settings.EditValue("gateway", packet.Server.ToString());
settings.EditValue("dns01", packet.DNS.ToString());
settings.EditValue("dhcp_server", packet.Server.ToString());
settings.PushValues();
NetworkInit.Enable(networkDevice, packet.Client, packet.Subnet, packet.Server, packet.DNS);
if (message)
{
CustomConsole.WriteLineOK("[DHCP CONFIG][" + networkDevice.Name + "] IP configuration applied.");
Console.WriteLine();
DHCPAsked = false;
}
}
}
Kernel.BeforeCommand();
}
/// <summary>
/// c = command, c_SystemInfomation
/// </summary>
public static void c_IPConfig(string cmd)
{
string[] args = cmd.Split(' ');
if (args.Length == 1)
{
L.List_Translation.Ipconfig();
return;
}
if (args[1] == "/release")
{
System.Network.DHCP.Core.SendReleasePacket();
}
else if (args[1] == "/set")
{
if (args.Length <= 3)
{
Console.WriteLine("Usage : " + args[0] + " /set {interface} {IPv4} {Subnet} -g {Gateway} -d {PrimaryDNS}");
//ipconfig /set PCNETII 192.168.1.32 255.255.255.0 -g 192.168.1.254 -d 8.8.8.8
}
else
{
if (NetworkInterfaces.Interface(args[2]) != "null")
{
Utils.Settings settings = new Utils.Settings(@"0:\System\" + NetworkInterfaces.Interface(args[2]) + ".conf");
NetworkStack.RemoveAllConfigIP();
ApplyIP(args, settings);
settings.Push();
NetworkInit.Enable();
}
else
{
Console.WriteLine("This interface doesn't exists.");
}
}
}
else if (args[1] == "/renew")
{
System.Network.DHCP.Core.SendDiscoverPacket();
}
else
{
L.List_Translation.Ipconfig();
}
}
/// <summary>
/// Send a packet to find the DHCP server and tell that we want a new IP address
/// </summary>
/// <returns>time value (-1 = timeout)</returns>
public int SendDiscoverPacket()
{
NetworkStack.RemoveAllConfigIP();
foreach (NetworkDevice networkDevice in NetworkDevice.Devices)
{
IPConfig.Enable(networkDevice, new Address(0, 0, 0, 0), new Address(0, 0, 0, 0), new Address(0, 0, 0, 0));
var dhcp_discover = new DHCPDiscover(networkDevice.MACAddress);
OutgoingBuffer.AddPacket(dhcp_discover);
NetworkStack.Update();
asked = true;
}
return(Receive());
}
public bool Send(bool isdata)
{
Apps.System.Debugger.debugger.Send("Sending TCP packet...");
if (isdata)
{
TCPPacket packet = new TCPPacket(source, dest, localPort, destPort, data, sequencenumber, acknowledgmentnb, 0x50, Flags, WSValue, 0x0000, false, false);
OutgoingBuffer.AddPacket(packet);
}
else
{
TCPPacket packet = new TCPPacket(source, dest, localPort, destPort, data, sequencenumber, acknowledgmentnb, 0x50, Flags, WSValue, 0x0000, true, true);
OutgoingBuffer.AddPacket(packet);
}
NetworkStack.Update();
Apps.System.Debugger.debugger.Send("Sent!");
return(true);
}
/// <summary>
/// CommandEcho
/// </summary>
/// <param name="arguments">Arguments</param>
public override ReturnInfo Execute(List <string> arguments)
{
if (NetworkStack.ConfigEmpty())
{
return(new ReturnInfo(this, ReturnCode.ERROR, "No network configuration detected! Use ipconfig /set."));
}
if (arguments.Count == 0)
{
return(new ReturnInfo(this, ReturnCode.ERROR_ARG));
}
if (arguments[0] == "-l")
{
if (arguments.Count <= 1)
{
return(new ReturnInfo(this, ReturnCode.ERROR_ARG));
}
int port = Int32.Parse(arguments[1]);
Console.WriteLine("Listening at " + port + "...");
new System.Network.IPV4.UDP.UdpClient(port);
return(new ReturnInfo(this, ReturnCode.OK));
}
else if (arguments[0] == "-s")
{
if (arguments.Count <= 3)
{
return(new ReturnInfo(this, ReturnCode.ERROR_ARG));
}
Address ip = Address.Parse(arguments[1]);
int port = Int32.Parse(arguments[2]);
string message = arguments[3];
var xClient = new System.Network.IPV4.UDP.UdpClient(port);
xClient.Connect(ip, port);
xClient.Send(Encoding.ASCII.GetBytes(message));
xClient.Close();
return(new ReturnInfo(this, ReturnCode.OK));
}
else
{
return(new ReturnInfo(this, ReturnCode.ERROR_ARG));
}
}
/// <summary>
/// Check command availability to avoid unwanted behavior.
/// </summary>
/// <param name="command">Command</param>
private static ReturnInfo CheckCommand(ICommand command)
{
if (command.Type == CommandType.Filesystem)
{
if (Kernel.ContainsVolumes() == false)
{
return(new ReturnInfo(command, ReturnCode.ERROR, "No volume detected!"));
}
}
if (command.Type == CommandType.Network)
{
if (NetworkStack.ConfigEmpty())
{
return(new ReturnInfo(command, ReturnCode.ERROR, "No network configuration detected! Use ipconfig /set."));
}
}
return(new ReturnInfo(command, ReturnCode.OK));
}
