394 lines
13 KiB
C#
394 lines
13 KiB
C#
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft Research Singularity
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// File: IPConfig.cs
|
|
//
|
|
// Note: Simple Singularity test program.
|
|
//
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Net.IP;
|
|
|
|
using Microsoft.Singularity;
|
|
using Microsoft.Singularity.Channels;
|
|
using Microsoft.Singularity.Directory;
|
|
using Microsoft.SingSharp;
|
|
using NetStack.Contracts;
|
|
using NetStack.Channels.Public;
|
|
|
|
using Microsoft.Contracts;
|
|
using Microsoft.SingSharp.Reflection;
|
|
using Microsoft.Singularity.Applications;
|
|
using Microsoft.Singularity.Io;
|
|
using Microsoft.Singularity.Configuration;
|
|
[assembly: Transform(typeof(ApplicationResourceTransform))]
|
|
|
|
namespace Microsoft.Singularity.Applications.Network
|
|
{
|
|
[ConsoleCategory(HelpMessage="Configure nic with IP addresses", DefaultAction=true)]
|
|
internal class DefaultConfig {
|
|
[InputEndpoint("data")]
|
|
public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;
|
|
|
|
[OutputEndpoint("data")]
|
|
public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<IPContract.Imp:Start> ipRef;
|
|
|
|
[StringParameter( "device", Mandatory=true, Position=0, HelpMessage="Nic to configure")]
|
|
internal string device;
|
|
|
|
[StringParameter( "address", Mandatory=true, Position=1, HelpMessage="address to give it")]
|
|
internal string address;
|
|
|
|
[StringParameter( "mask", Mandatory=true, Position=2, HelpMessage="mask to use")]
|
|
internal string mask;
|
|
|
|
[StringParameter( "gateway", Mandatory=true, Position=3, HelpMessage="gateway")]
|
|
internal string gateway;
|
|
|
|
reflective internal DefaultConfig();
|
|
|
|
internal int AppMain() {
|
|
return IPConfig.DefaultMain(this);
|
|
}
|
|
}
|
|
|
|
[ConsoleCategory(Action="show", HelpMessage="SHOW nic' IP configuration" )]
|
|
internal class ShowConfig {
|
|
[Endpoint]
|
|
public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<IPContract.Imp:Start> ipRef;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<DNSContract.Imp:Start> dnsRef;
|
|
|
|
reflective internal ShowConfig();
|
|
|
|
internal int AppMain() {
|
|
return IPConfig.Show(this);
|
|
}
|
|
}
|
|
|
|
[ConsoleCategory(Action="dhcp", HelpMessage="Configure nic via DHCP" )]
|
|
internal class DhcpConfig {
|
|
[Endpoint]
|
|
public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<IPContract.Imp:Start> ipRef;
|
|
|
|
[StringParameter( "device", Mandatory=true, Position=0, HelpMessage="Nic to configure")]
|
|
internal string device;
|
|
|
|
[StringParameter( "verb", Mandatory=true, Position=1, HelpMessage="verb (start or stop).")]
|
|
internal string action;
|
|
|
|
reflective internal DhcpConfig();
|
|
|
|
internal int AppMain() {
|
|
return IPConfig.Dhcp(this);
|
|
}
|
|
}
|
|
|
|
[ConsoleCategory(Action="verify", HelpMessage="check device interface" )]
|
|
internal class VerifyConfig {
|
|
[Endpoint]
|
|
public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<IPContract.Imp:Start> ipRef;
|
|
|
|
[StringParameter( "device", Mandatory=true, Position=0, HelpMessage="Nic to configure")]
|
|
internal string device;
|
|
|
|
reflective internal VerifyConfig();
|
|
|
|
internal int AppMain() {
|
|
return IPConfig.Verify(this);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Class for interface configuration related commands.
|
|
/// </summary>
|
|
public class IPConfig
|
|
{
|
|
|
|
// Marked unsafe for now since checker
|
|
// has problems with custom vector access.
|
|
public static void ShowConfig(IPContract.Imp:ReadyState! ipConn, DNSContract.Imp:ReadyState! dnsConn)
|
|
{
|
|
int done = 0;
|
|
char[]! in ExHeap hostName, domainName;
|
|
|
|
ipConn.SendGetHostName();
|
|
ipConn.RecvHostName(out hostName);
|
|
ipConn.SendGetDomainName();
|
|
ipConn.RecvDomainName(out domainName);
|
|
|
|
Console.WriteLine("Hostname: {0}.{1}", Bitter.ToString2(hostName), Bitter.ToString2(domainName));
|
|
delete hostName;
|
|
delete domainName;
|
|
|
|
Console.WriteLine("DNS Servers:");
|
|
|
|
try
|
|
{ Utils.DNSShow(dnsConn); }
|
|
finally
|
|
{}
|
|
|
|
char[][]! in ExHeap ifNames;
|
|
ipConn.SendGetInterfaces();
|
|
ipConn.RecvInterfaceList(out ifNames);
|
|
|
|
for (int i = 0; i < ifNames.Length; ++i)
|
|
{
|
|
CustomVector.Expose(ifNames, i);
|
|
char[] in ExHeap ifName = ifNames[i];
|
|
if (ifName == null)
|
|
throw new Exception("ifName is null");
|
|
string! deviceName = Bitter.ToString2(ifName);
|
|
CustomVector.UnExpose(ifNames, i);
|
|
ipConn.SendGetInterfaceState(Bitter.FromString2(deviceName));
|
|
switch receive
|
|
{
|
|
case ipConn.InterfaceNotFound() :
|
|
Console.WriteLine("Unexpected error");
|
|
break;
|
|
|
|
case ipConn.InterfaceState(InterfaceInfo ifInfo) :
|
|
ShowInterface(ifInfo, deviceName);
|
|
break;
|
|
|
|
case ipConn.ChannelClosed() :
|
|
throw new Exception("ipConn channel closed");
|
|
}
|
|
|
|
done++;
|
|
}
|
|
|
|
delete ifNames;
|
|
|
|
if (done == 0)
|
|
Console.WriteLine("No adapters present.");
|
|
}
|
|
|
|
public static void ConfigureInterface(IPContract.Imp! ipConn,
|
|
string! adapterName,
|
|
string! addressString,
|
|
string! netmaskString,
|
|
string! gatewayString)
|
|
{
|
|
IPv4 ifAddress, netmask, gateway;
|
|
|
|
if (IPv4.Parse(addressString, out ifAddress) == false ||
|
|
IPv4.Parse(netmaskString, out netmask) == false ||
|
|
IPv4.Parse(gatewayString, out gateway) == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ipConn.SendSetInterfaceState(Bitter.FromString2(adapterName),
|
|
(uint)ifAddress, (uint)netmask, (uint)gateway);
|
|
|
|
switch receive
|
|
{
|
|
case ipConn.InterfaceNotFound() :
|
|
Console.WriteLine("No such interface found");
|
|
break;
|
|
|
|
case ipConn.Err() :
|
|
Console.WriteLine("Error occurred setting interface state");
|
|
break;
|
|
|
|
case ipConn.OK() :
|
|
Console.WriteLine("Successfully set interface state");
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static void ShowInterface([Claims] InterfaceInfo ifInfo, string! ifName)
|
|
{
|
|
Console.WriteLine("Interface: {0}", ifName);
|
|
Console.WriteLine("Adapter: {0}",
|
|
Bitter.ToString(ifInfo.driverName));
|
|
Console.WriteLine("Version: {0}",
|
|
Bitter.ToString(ifInfo.driverVersion));
|
|
Console.WriteLine("MAC address: {0}",
|
|
ChannelUtils.HardwareAddressToString(ifInfo.hardwareAddress));
|
|
|
|
bool found = false;
|
|
|
|
delete ifInfo.driverName;
|
|
delete ifInfo.driverVersion;
|
|
|
|
InterfaceIPInfo[] in ExHeap ipConfigs = ifInfo.ipConfigs;
|
|
|
|
if (ipConfigs != null) {
|
|
for (int i = 0; i < ipConfigs.Length; i++)
|
|
{
|
|
InterfaceIPInfo ipc = ipConfigs[i];
|
|
Console.WriteLine(" Address: {0,-14} NetMask: {1, -14} Gateway: {2, -14}", new IPv4(ipc.address), new IPv4(ipc.netmask), new IPv4(ipc.gateway));
|
|
found |= true;
|
|
}
|
|
delete ipConfigs;
|
|
}
|
|
|
|
if (found == false)
|
|
Console.WriteLine(" Not configured.");
|
|
}
|
|
|
|
public static void StartDhcp(IPContract.Imp! ipConn,
|
|
string! adapterName)
|
|
{
|
|
ipConn.SendStartDhcp(Bitter.FromString2(adapterName));
|
|
|
|
switch receive
|
|
{
|
|
case ipConn.InterfaceNotFound() :
|
|
Console.WriteLine("No such interface found");
|
|
break;
|
|
|
|
case ipConn.OK() :
|
|
Console.WriteLine("Successfully started DHCP");
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static void StopDhcp(IPContract.Imp! ipConn,
|
|
string! adapterName)
|
|
{
|
|
ipConn.SendStopDhcp(Bitter.FromString2(adapterName));
|
|
|
|
switch receive
|
|
{
|
|
case ipConn.InterfaceNotFound() :
|
|
Console.WriteLine("No such interface found");
|
|
break;
|
|
|
|
case ipConn.OK() :
|
|
Console.WriteLine("Successfully stopped DHCP");
|
|
break;
|
|
}
|
|
}
|
|
|
|
internal static int Show(ShowConfig! config)
|
|
{
|
|
IPContract.Imp ipConn = (config.ipRef).Acquire();
|
|
if (ipConn == null) {
|
|
throw new Exception("Unable to acquire handle to the IP network");
|
|
}
|
|
ipConn.RecvReady();
|
|
|
|
DNSContract.Imp dnsConn = (config.dnsRef).Acquire();
|
|
if (dnsConn == null)
|
|
{
|
|
Console.WriteLine("Could not initialize DNS endpoint.");
|
|
delete ipConn;
|
|
return -1;
|
|
}
|
|
dnsConn.RecvReady();
|
|
|
|
ShowConfig(ipConn, dnsConn);
|
|
delete ipConn;
|
|
delete dnsConn;
|
|
return 0;
|
|
}
|
|
|
|
|
|
internal static int Dhcp(DhcpConfig! config)
|
|
{
|
|
IPContract.Imp ipConn = (config.ipRef).Acquire();
|
|
if (ipConn == null) {
|
|
throw new Exception("Unable to acquire handle to the IP network");
|
|
}
|
|
ipConn.RecvReady();
|
|
|
|
if (config.action == "start") {
|
|
StartDhcp(ipConn, config.device);
|
|
}
|
|
else if (config.action == "stop") {
|
|
StopDhcp(ipConn, config.device);
|
|
}
|
|
else {
|
|
Console.WriteLine("Unknown dhcp action:{0}", config.action);
|
|
}
|
|
delete ipConn;
|
|
return 0;
|
|
}
|
|
|
|
internal static int Verify(VerifyConfig! config)
|
|
{
|
|
string! arg1 = config.device;
|
|
|
|
IPContract.Imp ipConn = (config.ipRef).Acquire();
|
|
if (ipConn == null) {
|
|
throw new Exception("Unable to acquire handle to the IP network");
|
|
}
|
|
ipConn.RecvReady();
|
|
ipConn.SendGetInterfaceState(Bitter.FromString2(arg1));
|
|
|
|
switch receive
|
|
{
|
|
case ipConn.InterfaceNotFound() :
|
|
Console.WriteLine("Interface not found: \"" + arg1 + "\"");
|
|
break;
|
|
|
|
case ipConn.InterfaceState(InterfaceInfo ifInfo) :
|
|
ShowInterface(ifInfo, arg1);
|
|
break;
|
|
|
|
case ipConn.ChannelClosed() :
|
|
throw new Exception("ipConn channel closed");
|
|
}
|
|
delete ipConn;
|
|
return 0;
|
|
}
|
|
|
|
internal static int DefaultMain(DefaultConfig! config)
|
|
{
|
|
|
|
IPContract.Imp ipConn = (config.ipRef).Acquire();
|
|
if (ipConn == null) {
|
|
throw new Exception("Unable to acquire handle to the IP network");
|
|
}
|
|
ipConn.RecvReady();
|
|
|
|
try {
|
|
ConfigureInterface(ipConn,
|
|
config.device,
|
|
config.address,
|
|
config.mask,
|
|
config.gateway);
|
|
delete ipConn;
|
|
return 0;
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
Console.WriteLine("Caught exception: " + e);
|
|
}
|
|
finally
|
|
{
|
|
}
|
|
delete ipConn;
|
|
return 1;
|
|
}
|
|
} // end class IPConfig
|
|
}
|