private void ScanNics(ISettings settings)
{
NetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
_hardware = NetworkInterfaces.Where(DesiredNetworkType)
.Select((x, i) => new Nic(x, settings, i))
.ToList();
}
private void WindowOnOkEvent(object sender, OkEventArgs e)
{
if (!UserSettings.Wifi)
{
MessageBox message = new MessageBox();
message.SetPrompt("WIFI");
message.SetCloseTime(2);
message.configure = _configure;
if (NetworkInterfaces.Test())
{
message.SetMessage("首先你要有无线网卡");
message.Show();
return;
}
if (User.Text.Length < 1)
{
message.SetMessage("名称不能为空");
message.Show();
return;
}
if (Password.Text.Length <= 7)
{
message.SetMessage("密码长度不能小于8位数");
message.Show();
return;
}
string [] strings = new string[2];
strings[0] = new string(User.Text.ToCharArray());
strings[1] = new string(Password.Text.ToCharArray());
Openwifi(strings);
message.SetMessage("已创建热点");
message.Show();
}
CloseEvent?.Invoke(this, new OkEventArgs());
}
void createElements(XmlNode configuration)
{
//create routing protocol
XmlNode routingProtocolNode = XmlParser.GetChildNode(configuration, RoutingProtocol.RoutingProtocolTag);
routingProtocol = RoutingProtocol.Create(routingProtocolNode, this);
interfaces = new NetworkInterfaces(this);
//create data destination
dataDestination = new DataDestination(this);
//create bundle protocol instance
XmlNode bundleProtocolNode = configuration[BundleInstance.BundleProtocolTag];
if (bundleProtocolNode != null)
{
bundleInstance = new BundleInstance(bundleProtocolNode, this);
}
else
{
bundleInstance = new BundleInstance(this);
}
//create data source(if any requested)
XmlNode dataSourceNode = configuration[DataSource.DataSourceTag];
if (dataSourceNode != null)
{
dataSource = new DataSource(dataSourceNode, this);
}
}
public async Task MainTest()
{
string rgName = SdkContext.RandomResourceName("rgRSMA", 24);
string networkInterfaceName = SdkContext.RandomResourceName("netinf", 24);
string ipLabel = SdkContext.RandomResourceName("rgRSMA", 12);
ResourceGroups oResourceGroups = new ResourceGroups(this.credentials, this.subscriptionId);
oResourceGroups.Create(rgName, this.region);
var networkInferface = new NetworkInterfaces(credentials, subscriptionId);
networkInferface.Create(networkInterfaceName, rgName, this.region, "10.0.0.0/28", "test");
var resources = await oResourceGroups.GetResources(rgName);
Assert.AreEqual(Formatter.CountPageable(resources), 2);
await networkInferface.Del(networkInterfaceName, rgName, true);
Thread.Sleep(20000);
var resourcesAfterDel = await oResourceGroups.GetResources(rgName);
// there is this thing called, smartDetectorAlertRules/Failure Anomalies
Assert.LessOrEqual(Formatter.CountPageable(resourcesAfterDel), 1);
oResourceGroups.Del(rgName);
}
public Task StartScanning()
{
var isWifiEnabled = NetworkInterfaces.IsWifiEnabled();
if (!isWifiEnabled)
{
throw new WiFiTurnedOffException();
}
var myPeerId = new MCPeerID(UIDevice.CurrentDevice.Name);
_session = new MCSession(myPeerId)
{
Delegate = new SessionDelegate(this)
};
MainThread.BeginInvokeOnMainThread(() =>
{
var browser = new MCNearbyServiceBrowser(myPeerId, BluetoothOperator.CROSSCAM_SERVICE)
{
Delegate = new NewBrowserDelegate(this)
};
browser.StartBrowsingForPeers();
});
Debug.WriteLine("### SCANNING START");
return(Task.FromResult(true));
}
private void InitializeNetworkInteraces()
{
// TODO : implement start/stop/change active interface
_loginServerIp = Dns.GetHostAddresses("game.survarium.com").FirstOrDefault();
var nic = NetworkInterfaces.GetBestInterface(_loginServerIp).FirstOrDefault();
Interfaces.Add(new NetworkInterfaceModel(nic));
SelectedNetworkInterface = Interfaces.FirstOrDefault();
}
//CONSTRUCTION
public NetworkInterface(NetworkInterfaces interfaces, LinkSide linkSide)
: base(interfaces, linkSide.Link.Identificator)
{
this.linkSide = linkSide;
this.interfaces = interfaces;
linkSide.OnLinkFree += onLinkFree;
linkSide.Interface = this;
buffer = new InterfaceBuffer(this);
}
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();
}
private void SetStats()
{
_speedMonitor.GetNetworkUsage(_seleectedInterface);
NetworkInterfaces = NetworkInterfaces ?? _speedMonitor.GetAvailableNetworkInterfaces();
SelectedInterface = SelectedInterface ?? NetworkInterfaces.First().Name;
DownloadSpeed = _speedMonitor.DownloadSpeed;
UploadSpeed = _speedMonitor.UploadSpeed;
NetworkSpeed = _speedMonitor.NetworkSpeed;
DownloadedData = _speedMonitor.DownloadedData;
UploadedData = _speedMonitor.UploadedData;
IsConnected = _speedMonitor.IsConnected;
}
public override async Task OnConnectAsync(object value = null)
{
NetworkInterfaces networkInterfaces = value as NetworkInterfaces;
if (networkInterfaces == null)
{
MessageBox.Show("Не выбран интерфейс для подключения");
}
else
{
await networkInterfaces.Plug();
}
}
public static void ShowNetworkInterfaces(ref NetworkInterfaces networkInterfaces)
{
IPGlobalProperties computerProperties = IPGlobalProperties.GetIPGlobalProperties();
NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();
//GICO.WriteLine("Interface information for {0}.{1} ",
// computerProperties.HostName, computerProperties.DomainName);
networkInterfaces.hostName = computerProperties.HostName;
if (nics == null || nics.Length < 1)
{
//GICO.WriteLine(" No network interfaces found.");
return;
}
//GICO.WriteLine(" Number of interfaces .................... : {0}", nics.Length);
foreach (NetworkInterface adapter in nics)
{
if (adapter.OperationalStatus == OperationalStatus.Up)
{
IPInterfaceProperties properties = adapter.GetIPProperties(); // .GetIPInterfaceProperties();
//GICO.WriteLine();
//GICO.WriteLine(adapter.Description);
//GICO.WriteLine(String.Empty.PadLeft(adapter.Description.Length, '='));
//GICO.WriteLine(" Interface type .......................... : {0}", adapter.NetworkInterfaceType);
//GICO.Write(" Physical address ........................ : ");
PhysicalAddress address = adapter.GetPhysicalAddress();
byte[] bytes = address.GetAddressBytes();
string tempMac = string.Empty;
for (int i = 0; i < bytes.Length; i++)
{
// Display the physical address in hexadouble.
tempMac += bytes[i].ToString("X2");
// Insert a hyphen after each byte, unless we are at the end of the
// address.
if (i != bytes.Length - 1)
{
tempMac += "-";
}
}
networkInterfaces.macAdress.Add(tempMac);
//GICO.Write(macAdress);
//GICO.WriteLine();
}
}
}
/// <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();
}
}
static void Main(string[] args)
{
var ni = new NetworkInterfaces();
var settings = new SocketSettings(ni);
var wrapper = new SocketWrapper(settings);
var sniffer = new SocketSniffer(wrapper);
var serverList = GetServers(Resources.Servers);
var teraSniffer = new DelegateSniffer(sniffer, new TeraServerList(Resources.Servers));
var meter = new DelegateNetworkWrapper(teraSniffer);
var cc = new DelegateCombatControl();
var parse = new DelegateMeter(meter, cc);
parse.CombatUpdatedEvent += OnUpdated;
teraSniffer.MessageReceived += HandleMessageReceived;
teraSniffer.NewConnection += HandleNewConnection;
Console.ReadLine();
}
private async void ReloadNetworkInterfacesAction()
{
IsNetworkInterfaceLoading = true;
await Task.Delay(2000); // Make the user happy, let him see a reload animation
string id = string.Empty;
if (SelectedNetworkInterface != null)
{
id = SelectedNetworkInterface.Id;
}
NetworkInterfaces = await Models.Network.NetworkInterface.GetNetworkInterfacesAsync();
SelectedNetworkInterface = NetworkInterfaces.Where(x => x.Id == id).FirstOrDefault();
IsNetworkInterfaceLoading = false;
}
private async void ReloadNetworkInterfacesAction()
{
IsNetworkInterfaceLoading = true;
await Task.Delay(2000); // Make the user happy, let him see a reload animation (and he cannot spam the reload command)
string id = string.Empty;
if (SelectedNetworkInterface != null)
{
id = SelectedNetworkInterface.Id;
}
NetworkInterfaces = await Models.Network.NetworkInterface.GetNetworkInterfacesAsync();
// Change interface...
SelectedNetworkInterface = string.IsNullOrEmpty(id) ? NetworkInterfaces.FirstOrDefault() : NetworkInterfaces.Where(x => x.Id == id).FirstOrDefault();
IsNetworkInterfaceLoading = false;
}
public Task BecomeDiscoverable()
{
var isWifiEnabled = NetworkInterfaces.IsWifiEnabled();
if (!isWifiEnabled)
{
throw new WiFiTurnedOffException();
}
var myPeerId = new MCPeerID(UIDevice.CurrentDevice.Name);
_session = new MCSession(myPeerId)
{
Delegate = new SessionDelegate(this)
};
var assistant = new MCAdvertiserAssistant(BluetoothOperator.CROSSCAM_SERVICE, new NSDictionary(), _session);
assistant.Start();
Debug.WriteLine("### DISCOVERABLE START");
return(Task.FromResult(true));
}
private async void LoadNetworkInterfaces()
{
IsNetworkInterfaceLoading = true;
NetworkInterfaces = await Models.Network.NetworkInterface.GetNetworkInterfacesAsync();
// Get the last selected interface, if it is still available on this machine...
if (NetworkInterfaces.Count > 0)
{
NetworkInterfaceInfo info = NetworkInterfaces.Where(s => s.Id == SettingsManager.Current.NetworkInterface_SelectedInterfaceId).FirstOrDefault();
if (info != null)
{
SelectedNetworkInterface = info;
}
else
{
SelectedNetworkInterface = NetworkInterfaces[0];
}
}
IsNetworkInterfaceLoading = false;
}
private static void Main(string[] args)
{
if (!IsElevated())
{
Console.WriteLine("Please run with elevated prilileges");
Environment.Exit(1);
}
IPAddress survLoginIp = Dns.GetHostAddresses("game.survarium.com").FirstOrDefault();
var nic = NetworkInterfaces.GetBestInterface(survLoginIp).FirstOrDefault();
var options = new PacketAnalyzerOptions()
{
FilterByIp = new System.Collections.Generic.List <IPAddress>()
{
survLoginIp
}
};
var sniffer = new SocketSniffer(nic, new ConsoleLogger(), new PacketDataAnalyzer(new ConsoleLogger(), options));
sniffer.Start();
Console.WriteLine();
Console.WriteLine("Capturing on interface {0} ({1})", nic.Name, nic.IPAddress);
Console.WriteLine("Press CTRL+C to stop");
Console.WriteLine();
// Shutdown gracefully on CTRL+C
Console.CancelKeyPress += ConsoleOnCancelKeyPress;
while (!_isStopping)
{
Thread.Sleep(200);
}
sniffer.Stop();
}
// if this is one of our locks, signal the ILockConsumer, then mark lock released
// server to client
public void LockReleased(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
if( locks.Contains( targetobject ) )
{
( (ILockConsumer)locks[ targetobject ] ).LockReleased( this, new LockReleasedEventArgs( targetobject ) );
locks.Remove( targetobject );
}
}
// client to server
public void ReleaseLock(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
}
public bool MeOwnsLock(NetworkInterfaces.IReplicated requester, NetworkInterfaces.IReplicated targetobject)
{
if( locks[ targetobject ] != null && ((LockInfo)locks[ targetobject ]).Requester == requester )
{
return true;
}
return false;
}
// if we are master, we can grant lock if available, then signal requester immediately
// otherwise we makes async rpc request to server
public void RequestLock(ILockConsumer requester, NetworkInterfaces.IReplicated targetobject)
{
if( ismaster )
{
bool lockgranted = _MasterRequestLock( requester, targetobject);
requester.LockResponse( this, new LockRequestEventArgs( targetobject, lockgranted ) );
}
else
{
if( ((LockInfo)locks[ targetobject ]).Requester == requester )
{
requester.LockResponse( this, new LockRequestEventArgs( targetobject, true ) );
}
else if( locks[ targetobject ] != null )
{
requester.LockResponse( this, new LockRequestEventArgs( targetobject, false ) );
}
else
{
pendingrpcrequests.Add( new object[]{ requester, targetobject } );
new LockRpcToServer( null ).ReleaseLock( null, targetobject );
}
}
}
// renew lock; no response required; if the lock gets released, we get the response in LockReleased anyway
// client to server
public void RenewLock(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
if( locks.ContainsKey( targetobject ) && ((LockInfo)locks[ targetobject ]).Requester == netconnection )
{
((LockInfo)locks[ targetobject ]).RenewTimestamp();
}
}
// runs on master, called by rpc call or non-rpc call
// returns true if lock granted successfully, or already owned by requester
bool _MasterRequestLock(object requester, NetworkInterfaces.IReplicated targetobject)
{
if( !locks.Contains( targetobject ) )
{
locks.Add( targetobject, new LockInfo( requester, targetobject ) );
return true;
}
else if( ((LockInfo)locks[ targetobject ]).Requester == requester )
{
return true;
}
return false;
}
// client to server
public void RequestLock(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
bool lockgranted = _MasterRequestLock( netconnection, targetobject);
new LockRpcToClient( netconnection ).LockRequestResponse( netconnection, targetobject, lockgranted );
}
public LockInfo(object Requester, NetworkInterfaces.IReplicated TargetObject)
{
this.Requester = Requester; this.TargetObject = TargetObject;
Timestamp = DateTime.Now;
}
public void LockReleased(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
LockController.GetInstance().LockReleased(netconnection, targetobject);
}
public void LockRequestResponse(object netconnection, NetworkInterfaces.IReplicated targetobject, bool LockCreated)
{
LockController.GetInstance().LockRequestResponse(netconnection, targetobject, LockCreated);
}
public void RequestLock(object netconnection, NetworkInterfaces.IReplicated targetobject)
{
LockController.GetInstance().RequestLock(netconnection, targetobject);
}
// send result to ILockConsumer, and add lock to locks
// server to client
public void LockRequestResponse(object netconnection, NetworkInterfaces.IReplicated targetobject, bool LockCreated)
{
for( int i = 0; i < pendingrpcrequests.Count; i++ )
{
object[]pendingrequest = (object[])pendingrpcrequests[i];
if( pendingrequest[1] == targetobject )
{
( (ILockConsumer)pendingrequest[0] ).LockResponse( this, new LockRequestEventArgs( targetobject, LockCreated ) );
if( locks.Contains( targetobject ) )
{
locks.Remove( targetobject );
}
locks.Add( targetobject, new LockInfo( pendingrequest[0], targetobject ) );
pendingrpcrequests.RemoveAt( i );
i--;
}
}
}
