public Client(NetworkInterface networkInterface) { network_interface_info = NetworkInterfaceInfo.GetNetworkInterfaceInfo(networkInterface); service_cache = new ServiceCache(this); notify_listener = new NotifyListener(this); browsers = new Dictionary <string, Browser> (); }
public Server(string defaultLocation, NetworkInterface networkInterface) { default_location = defaultLocation; network_interface_info = NetworkInterfaceInfo.GetNetworkInterfaceInfo(networkInterface); request_listener = new RequestListener(this); announcers = new Dictionary <string, Announcer> (); }
public PcapNgFileOutput(NetworkInterfaceInfo nic, string filename) { this.nic = nic; this.fileStream = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None); this.writer = new BinaryWriter(this.fileStream); this.WriteHeader(); }
private static void Main(string[] args) { // You can only create raw sockets with elevated privileges if (!UserInformation.IsAdmin()) { var message = SystemInformation.IsWindows ? "Please run with elevated prilileges" : "Please run using sudo"; Console.WriteLine(message); Environment.Exit(1); } var appOptions = ParseCommandLine(args); if (appOptions.ShowHelp) { ShowHelp(appOptions); Environment.Exit(0); } var nics = NetworkInterfaceInfo.GetInterfaces(); if (!appOptions.InterfaceId.HasValue || appOptions.InterfaceId > nics.Count - 1 || appOptions.InterfaceId < 0) { Console.WriteLine("Invalid interface ID"); ShowHelp(appOptions); Environment.Exit(3); } var filters = appOptions.BuildFilters(); var nic = nics[appOptions.InterfaceId !.Value];
private void updateStatus() { NetworkInterfaceList networkInterfaceList = new NetworkInterfaceList(); NetworkInterfaceInfo wifiInfo = null; foreach (NetworkInterfaceInfo netInfo in networkInterfaceList) { if (netInfo.InterfaceSubtype == NetworkInterfaceSubType.WiFi && netInfo.InterfaceState == ConnectState.Connected) { wifiInfo = netInfo; break; } } if (wifiInfo != null) { Name = wifiInfo.InterfaceName; } else { Name = ""; } if (wifiTextBlock != null) { wifiTextBlock.Text = Name; } }
/// <summary> /// /// </summary> /// <param name="InterfaceGuid">The GUID of the network adapter.</param> /// <exception cref="NetworkInformationException"/> /// <exception cref="ArgumentNullException"/> /// <exception cref="FormatException"/> /// <returns>NetworkInterfaceInfo</returns> internal static NetworkInterfaceInfo GetNetworkInterfaceInformation(Guid InterfaceGuid) { NetworkInterfaceInfo NetITFInfo = new NetworkInterfaceInfo(); foreach (NetworkInterface NetITF in NetworkInterface.GetAllNetworkInterfaces()) { if (!InterfaceGuid.Equals(Guid.Parse(NetITF.Id))) { continue; } IPInterfaceProperties IPITFProps = NetITF.GetIPProperties(); foreach (UnicastIPAddressInformation uIPAddrInfo in IPITFProps.UnicastAddresses) { if (!uIPAddrInfo.Address.IsIPv6LinkLocal && !uIPAddrInfo.Address.IsIPv6Teredo) { NetITFInfo.DeviceDescription = NetITF.Description; NetITFInfo.DeviceName = NetITF.Name; NetITFInfo.IPAddress = uIPAddrInfo.Address; NetITFInfo.PhysicalAddress = NetITF.GetPhysicalAddress(); NetITFInfo.GatewayAddress = IPITFProps.GatewayAddresses.Count > 0 ? IPITFProps.GatewayAddresses[0].Address : IPAddress.None; return(NetITFInfo); } } } return(NetITFInfo); }
public PcapNgFileOutput(NetworkInterfaceInfo nic, string filename) { this.nic = nic; this.fileStream = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None); this.writer = new BinaryWriter(fileStream); this.WriteHeader(); }
private static void NetworkInformationCallback(NetworkInterfaceInfo netInfo) { // set encoding behavior based on speed of network: wifi networks don't need encoding, // but cellular networks do string encString; if (IsSlowNetwork(netInfo)) { encode = true; encString = "application/speex"; } else { encode = false; encString = "application/pcm"; } // initialize the encoding encoding = String.Format("{0}-{1}-{2}-{3}", encString, mic.SampleRate, "16", // 16 bits per sample ((int)AudioChannels.Mono).ToString()); // 1 audio channel (mono) // Trace the operation TraceHelper.AddMessage("POST: " + encoding); // send the HTTP POST to initialize the speech operation // upon completion it will invoke the StartMic delegate to start the microphone NetworkHelper.SendPost( user, "Zaplify-Speech-Encoding: " + encoding, new StartMicDelegate(StartMic), new NetworkDelegate(NetworkCallback)); }
public int getStatisticsNetType() { NetworkInterfaceList interfaceList = new NetworkInterfaceList(); NetworkInterfaceInfo interfaceInfo = interfaceList.First(); switch (interfaceInfo.InterfaceSubtype) { case NetworkInterfaceSubType.Cellular_3G: case NetworkInterfaceSubType.Cellular_EVDO: case NetworkInterfaceSubType.Cellular_EVDV: case NetworkInterfaceSubType.Cellular_HSPA: return(NETTYPE_3G); case NetworkInterfaceSubType.Cellular_GPRS: case NetworkInterfaceSubType.Cellular_EDGE: case NetworkInterfaceSubType.Cellular_1XRTT: return(NETTYPE_2G); case NetworkInterfaceSubType.Cellular_EHRPD: case NetworkInterfaceSubType.Cellular_LTE: return(NETTYPE_4G); case NetworkInterfaceSubType.WiFi: return(NETTYPE_WIFI); default: return(NETTYPE_NON); } }
public void Start() { var conn = ConnectionPicker.GetGameConnections(ProcessWorking); var filters = FilterBuilder.BuildDefaultFilter(conn); var nic = NetworkInterfaceInfo.GetDefaultInterface(); Start(nic.IPAddress, filters); }
private static void StartSniffing(NetworkInterfaceInfo nic, out PcapNgFileOutput output, out SocketSniffer sniffer) { var appOptions = new AppOptions(); appOptions.Parse(new string[] { "" }); var filters = appOptions.BuildFilters(); output = new PcapNgFileOutput(nic, appOptions.Filename); sniffer = new SocketSniffer(nic, filters, output); sniffer.Start(); }
public CurWifiInfo getCurWifiInfo() { CurWifiInfo info = new CurWifiInfo(); NetworkInterfaceList interfaceList = new NetworkInterfaceList(); NetworkInterfaceInfo interfaceInfo = interfaceList.First(); if (!DeviceNetworkInformation.IsWiFiEnabled) { return(null); } info.ssid = interfaceInfo.InterfaceName; return(info); }
private static NetworkInterface GetDotNetNetworkInterfaceByIndex(int index) { #if FIRST_PASS return(null); #else NetworkInterfaceInfo nii = GetInterfaces(); for (int i = 0; i < nii.javaInterfaces.Length; i++) { if (nii.javaInterfaces[i].getIndex() == index) { return(nii.dotnetInterfaces[i]); } } throw new java.net.SocketException("interface index not found"); #endif }
void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e) { System.Diagnostics.Debug.WriteLine(e.NotificationType); System.Diagnostics.Debug.WriteLine(e.NetworkInterface.InterfaceName); System.Diagnostics.Debug.WriteLine(e.NetworkInterface.Description); System.Diagnostics.Debug.WriteLine(e.NetworkInterface.InterfaceState); System.Diagnostics.Debug.WriteLine(e.NetworkInterface.Bandwidth); if (e.NotificationType == NetworkNotificationType.InterfaceConnected) { this.CurrentNetwork = e.NetworkInterface; } else if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected && e.NetworkInterface == this.CurrentNetwork) { this.CurrentNetwork = null; } }
public bool isNetworkConnected() { NetworkInterfaceList interfaceList = new NetworkInterfaceList(); NetworkInterfaceInfo interfaceInfo = interfaceList.First(); if (interfaceInfo.InterfaceState == ConnectState.Connected) { return(true); } else if (interfaceInfo.InterfaceState == ConnectState.Disconnected) { return(false); } else { return(false); } }
public InterfaceDescriptionBlock(NetworkInterfaceInfo nic) { // Options: Interface Name (if_name) this.interfaceNameOption = new OptionalField(OptionTypeCode.InterfaceName, $"\\Device\\NPF_{nic.Id}"); // Options: Interface Description (if_description) this.interfaceDescriptionOption = new OptionalField(OptionTypeCode.InterfaceDescription, nic.Name); this.TotalBlockLength = BlockType.Length + sizeof(int) + LinkType.Length + SnapLen.Length + this.interfaceNameOption.Length + this.interfaceDescriptionOption.Length + TsResolutionOption.Length + OptionalField.EndOfOptions.Length + sizeof(int); }
async Task BroadcastSocket(NetworkInterfaceInfo adapter) { using (var udpClient = new UdpClient(adapter.IPAddress.AddressFamily)) { var socket = udpClient.Client; socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastInterface, IPAddress.HostToNetworkOrder(adapter.InterfaceIndex)); socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); udpClient.ExclusiveAddressUse = false; socket.Bind(new IPEndPoint(adapter.IPAddress, SSDP_UNICAST_PORT)); socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(SSDP_IP, adapter.InterfaceIndex)); var receiveTask = ReceiveServicer(udpClient); var broadcastTask = BroadcastServicer(udpClient); await Task.WhenAll(receiveTask, broadcastTask); } }
public int getNetInfo() { NetworkInterfaceList interfaceList = new NetworkInterfaceList(); NetworkInterfaceInfo interfaceInfo = interfaceList.First(); Debug.WriteLine("NetInfo:" + interfaceInfo.InterfaceType); switch (interfaceInfo.InterfaceType) { case NetworkInterfaceType.None: return(ENoNet); case NetworkInterfaceType.Wireless80211: return(EWifi); case NetworkInterfaceType.MobileBroadbandCdma: case NetworkInterfaceType.MobileBroadbandGsm: return(EMobile); default: return(EOther); } }
private async static Task <JavaMapletGaussOutput> MatrixTutorResult(MapleLinearAlgebra engine, MapleMatrix matrix, string methodName) { await semaphore.WaitAsync();//Since same protocol is used for every Tutor we have to wait for other tutor's to be closed before we can recall. try { var engineType = typeof(MapleLinearAlgebra); var method = engineType.GetMethod(methodName); //reflection used since each Tutor uses same protocol, for linearalgebra, (but different call methods to maple) IWindow window = await(Task <IWindow>) method.Invoke(engine, new object[] { matrix }); // await engine.GaussJordanEliminationTutor(matrix); if (window is MSWindow) // Microsoft Windows { // Find Loopback Pseudo interface for sniffing. var nic = NetworkInterfaceInfo .GetInterfaces() .FirstOrDefault(c => c.Name.Contains("Loopback Pseudo")); // Ensure loopback pseudo interface is found before we start trying to sniff. if (nic != default(NetworkInterfaceInfo)) { PcapNgFileOutput output; SocketSniffer sniffer; StartSniffing(nic, out output, out sniffer); await InteractWithDefaultTutor((MSWindow)window, sniffer); StopSniffing(output, sniffer); return(InterpretMatrixSniffedData()); } } } finally { semaphore.Release(); } return(null); }
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 void OnShareButtonClick(object sender, MouseEventArgs e) { if (SSIDText.Text.Length < 5) { MessageBox.Show("SSID Name must be at least 5 characters long." , Text, MessageBoxButtons.OK, MessageBoxIcon.Warning); } else if (KeyText.Text.Length < 6) { MessageBox.Show("Password must be at least 6 characters long." , Text, MessageBoxButtons.OK, MessageBoxIcon.Warning); } else if (NetIList.SelectedIndex < 0) { MessageBox.Show("Network interface not selected.\n\n" + "Please select a network interface that you want to share its internet connection." , Text, MessageBoxButtons.OK, MessageBoxIcon.Warning); } else { ((Button)sender).Enabled = false; NetworkInterfaceInfo NetITFInfo = NetInterfaceList[NetIList.SelectedIndex]; Settings.Save(SSIDText.Text, KeyText.Text); new Thread(() => { Settings.Read(); StartHostedNetwork(Settings.SSID, Settings.Key, NetITFInfo.InterfaceGuid); this?.Invoke(new Action(() => ((Button)sender).Enabled = true)); }) { IsBackground = false, Priority = ThreadPriority.AboveNormal }.Start(); } }
public SocketSniffer(NetworkInterfaceInfo nic, ILogger logger, PacketDataAnalyzer analyzer) { _logger = logger; _outputQueue = new BlockingCollection <TimestampedData>(); _analyzer = analyzer; _bufferManager = new BufferManager(BUFFER_SIZE, MAX_RECEIVE); _receivePool = new ConcurrentStack <SocketAsyncEventArgs>(); // IPv4 this._socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP); this._socket.Bind(new IPEndPoint(nic.IPAddress, 0)); this._socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, true); // Enter promiscuous mode try { this._socket.IOControl(IOControlCode.ReceiveAll, BitConverter.GetBytes(1), new byte[4]); } catch (Exception ex) { _logger.Log(Severity.Debug, $"Unable to enter promiscuous mode: {ex}"); throw; } }
private static bool IsSlowNetwork(NetworkInterfaceInfo netInfo) { switch (netInfo.InterfaceType) { case NetworkInterfaceType.MobileBroadbandCdma: case NetworkInterfaceType.MobileBroadbandGsm: return(true); case NetworkInterfaceType.Ethernet: case NetworkInterfaceType.Wireless80211: return(false); default: switch (netInfo.InterfaceSubtype) { case NetworkInterfaceSubType.WiFi: case NetworkInterfaceSubType.Desktop_PassThru: return(false); default: return(true); } } }
private async static Task <JavaMapletGaussOutput> TutorResult(MapleLinearAlgebra engine, MapleMatrix matrix, string methodName) { List <string> operations = new List <string>(); var gaussOutput = new JavaMapletGaussOutput(); await semaphoreSlim.WaitAsync();//Since same protocol is used for every Tutor we have to wait for other tutor's to be closed before we can recall. try { var engineType = typeof(MapleLinearAlgebra); var method = engineType.GetMethod(methodName); //reflection used since each Tutor uses same protocol, for linearalgebra, (but different call methods to maple) IWindow window = await(Task <IWindow>) method.Invoke(engine, new object[] { matrix }); // await engine.GaussJordanEliminationTutor(matrix); if (window is MSWindow) // Microsoft Windows { // Find interfaces for sniffing. var nics = NetworkInterfaceInfo.GetInterfaces(); var nic = nics.FirstOrDefault(c => c.Name.Contains("Loopback Pseudo")); // Ensure loopback pseudo interface is found... if (nic != default(NetworkInterfaceInfo)) { #region Start Sniffing var appOptions = new AppOptions(); appOptions.Parse(new string[] { "" }); var filters = appOptions.BuildFilters(); var output = new PcapNgFileOutput(nic, appOptions.Filename); var sniffer = new SocketSniffer(nic, filters, output); sniffer.Start(); #endregion #region MSWIN var mswin = (MSWindow)window; mswin.WindowPos(0, 0, 400, 800); for (int i = 0; i < 4; i++) { mswin.SendKeyStroke(System.Windows.Forms.Keys.Tab); await Task.Delay(60); } mswin.SendKeyStroke(System.Windows.Forms.Keys.Enter); mswin.Hide(); long LastPackageCount = 0; int WaitTries = 0; while (true) // wait for program to stop sending packages to intercept. { await Task.Delay(400); LastPackageCount = sniffer.PacketsCaptured; if (LastPackageCount > 0 && LastPackageCount == sniffer.PacketsCaptured) { WaitTries++; } if (WaitTries > 4) { break; } } mswin.Close(); #endregion #region Interpret Sniffed Data sniffer.Stop(); output.Dispose(); using (var reader = new StreamReader("snifter.pcapng")) { var content = reader.ReadToEnd(); var regex = new Regex(@"\<application_communications.*?\<content\>Applied operation\:\ (.*?)\<\/content\>", RegexOptions.Singleline); var match = regex.Match(content); while (match.Success) { var operation = match.Groups[1].Value.Trim();//initial space operations.Add(operation); match = match.NextMatch(); } var mapleMatrixRegex = new Regex(@"\<content\>(\<\;.*?)\<", RegexOptions.Singleline); var mapleMatrixMatch = mapleMatrixRegex.Match(content); var lastMatchStr = ""; while (mapleMatrixMatch.Success) { lastMatchStr = mapleMatrixMatch.Groups[1].Value; mapleMatrixMatch = mapleMatrixMatch.NextMatch(); } StringBuilder builder = new StringBuilder(lastMatchStr); gaussOutput.Operations = operations.ToArray(); int ra_index = 0; int index = 0; var search = "mtext>&NewLine;"; while ((ra_index = builder.ToString().IndexOf(search, ra_index)) != -1) { ra_index += search.Length; if (index >= operations.Count) { break; } builder.Insert(ra_index, $" {gaussOutput.OperationsDa[index++]} &NewLine;&NewLine;&NewLine;"); } gaussOutput.MathML = HttpUtility.HtmlDecode(builder.ToString()); } #endregion } } } finally { semaphoreSlim.Release(); } return(gaussOutput); }
public static void GetNetName() { DeviceNetworkInformation.ResolveHostNameAsync( new DnsEndPoint("www.microsoft.com", 80), new NameResolutionCallback(handle => { string Name = ""; string NetName = ""; NetworkInterfaceInfo info = handle.NetworkInterface; if (info != null) { Name = info.InterfaceName + " " + info.Description + " "; switch (info.InterfaceType) { case NetworkInterfaceType.Ethernet: NetName = "Ethernet"; break; case NetworkInterfaceType.MobileBroadbandCdma: case NetworkInterfaceType.MobileBroadbandGsm: switch (info.InterfaceSubtype) { case NetworkInterfaceSubType.Cellular_3G: //NetName = "Cellular_3G + 3G"; NetName = "3G"; break; case NetworkInterfaceSubType.Cellular_EVDO: //NetName = "Cellular_EVDO + 3G"; NetName = "3G"; break; case NetworkInterfaceSubType.Cellular_EVDV: //NetName = "Cellular_EVDV + 3G"; NetName = "3G"; break; case NetworkInterfaceSubType.Cellular_HSPA: NetName = "3G"; //NetName = "Cellular_HSPA + 3G"; break; case NetworkInterfaceSubType.Cellular_GPRS: //NetName = "Cellular_GPRS + 2G"; NetName = "2G"; break; case NetworkInterfaceSubType.Cellular_EDGE: NetName = "2G"; // NetName = "Cellular_EDGE + 2G"; break; case NetworkInterfaceSubType.Cellular_1XRTT: //NetName = "Cellular_1XRTT + 2G"; NetName = "2G"; break; default: NetName = "None"; break; } break; case NetworkInterfaceType.Wireless80211: NetName = "WiFi"; break; default: NetName = "None"; break; } } else { NetName = "None"; } CommonData.NetworkStatus = NetName; string tip = ""; if (NetName == "None") { tip = AppResources.NoneNetwork; } else { tip = AppResources.ShowNetwork.Replace("#name#", NetName); } if (NetName != "WiFi") { App.DownVideoModel.StopGetVideoData(); } else { App.DownVideoModel.CheckLocalData(); } ShowToast(tip); }), null); }
public NetworkInterfaceModel(NetworkInterfaceInfo info) { Data = info; }
private static bool IsSlowNetwork(NetworkInterfaceInfo netInfo) { switch (netInfo.InterfaceType) { case NetworkInterfaceType.MobileBroadbandCdma: case NetworkInterfaceType.MobileBroadbandGsm: return true; case NetworkInterfaceType.Ethernet: case NetworkInterfaceType.Wireless80211: return false; default: switch (netInfo.InterfaceSubtype) { case NetworkInterfaceSubType.WiFi: case NetworkInterfaceSubType.Desktop_PassThru: return false; default: return true; } } }
public static List <NetworkInterfaceInfo> GetLocalNetworkInterfaces( SubnetClass subnetClasses = SubnetClass.C, bool flushCache = false) { if (flushCache) { localNetworkInterfaces = null; } if (localNetworkInterfaces != null) { return(localNetworkInterfaces); } List <NetworkInterfaceInfo> workingInterfaces = new List <NetworkInterfaceInfo>(); NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces(); foreach (NetworkInterface networkInterface in networkInterfaces) { if ((networkInterface.NetworkInterfaceType == NetworkInterfaceType.Loopback) || (networkInterface.NetworkInterfaceType == NetworkInterfaceType.Tunnel) || (networkInterface.OperationalStatus != OperationalStatus.Up)) { continue; } IPInterfaceProperties ipProperties = networkInterface.GetIPProperties(); foreach (UnicastIPAddressInformation ipInformation in ipProperties.UnicastAddresses) { IPAddress ipv4Mask = null; if (OSVersionPlatform.GetGenericPlatform() == PlatformID.Unix) { //Mono does not implement IPv4Mask //see https://bugzilla.xamarin.com/show_bug.cgi?id=2033 string mask = IPInfoTools.GetIPv4Mask(networkInterface.Name); if (mask == null || IPAddress.TryParse(mask, out ipv4Mask) == false) { ipv4Mask = IPAddress.Parse("255.255.255.0"); // default to this } } else { ipv4Mask = ipInformation.IPv4Mask; } SubnetClass interfaceClass = ipv4Mask.GetSubnetClass(); //optionally scan class A & B subnets if (!((subnetClasses & interfaceClass) == interfaceClass)) { continue; } IPAddress ipAddress = ipInformation.Address; if (ipAddress.AddressFamily == AddressFamily.InterNetwork) { NetworkInterfaceInfo interfaceInfo = new NetworkInterfaceInfo(); interfaceInfo.Host = ipAddress; interfaceInfo.Netmask = ipv4Mask; interfaceInfo.Broadcast = GetBroadcastAddress(interfaceInfo.Host, interfaceInfo.Netmask); //deprecations are known - we only support IPv4 scanning with this code //see above check for AddressFamily.InterNetwork long host = (long)(uint)IPAddress.NetworkToHostOrder((int)interfaceInfo.Host.Address); long netmask = (long)(uint)IPAddress.NetworkToHostOrder((int)interfaceInfo.Netmask.Address); long broadcast = (long)(uint)IPAddress.NetworkToHostOrder((int)interfaceInfo.Broadcast.Address); long network = host & netmask; long rangeStart = network + 1; long rangeEnd = broadcast - 1; //e.g. if host == broadcast, netmask == 255.255.255.255 if (rangeEnd < rangeStart) { long swap = rangeEnd; rangeEnd = rangeStart; rangeStart = swap; } interfaceInfo.RangeStart = new IPAddress((long)(uint)IPAddress.HostToNetworkOrder((int)rangeStart)); interfaceInfo.RangeEnd = new IPAddress((long)(uint)IPAddress.HostToNetworkOrder((int)rangeEnd)); workingInterfaces.Add(interfaceInfo); } } } //cache the results localNetworkInterfaces = workingInterfaces; return(localNetworkInterfaces); }
public InterfaceDescriptionBlock(NetworkInterfaceInfo nic) { this.nic = nic; }
public static IObservable <NameResolutionResult> ResolveHostName(DnsEndPoint endPoint, NetworkInterfaceInfo networkInterface) { Contract.Requires(endPoint != null); Contract.Requires(networkInterface != null); Contract.Ensures(Contract.Result <IObservable <NameResolutionResult> >() != null); var subject = new AsyncSubject <NameResolutionResult>(); try { DeviceNetworkInformation.ResolveHostNameAsync( endPoint, networkInterface, result => { var s = (AsyncSubject <NameResolutionResult>)result.AsyncState; s.OnNext(result); s.OnCompleted(); }, subject); } catch (Exception ex) { subject.OnError(ex); } return(subject.AsObservable()); }
public static List<NetworkInterfaceInfo> GetLocalNetworkInterfaces( SubnetClass subnetClasses = SubnetClass.C, bool flushCache = false) { if (flushCache) localNetworkInterfaces = null; if (localNetworkInterfaces != null) return localNetworkInterfaces; List<NetworkInterfaceInfo> workingInterfaces = new List<NetworkInterfaceInfo>(); NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces(); foreach (NetworkInterface networkInterface in networkInterfaces) { if ((networkInterface.NetworkInterfaceType == NetworkInterfaceType.Loopback) || (networkInterface.NetworkInterfaceType == NetworkInterfaceType.Tunnel) || (networkInterface.OperationalStatus != OperationalStatus.Up)) continue; IPInterfaceProperties ipProperties = networkInterface.GetIPProperties(); foreach (UnicastIPAddressInformation ipInformation in ipProperties.UnicastAddresses) { IPAddress ipv4Mask = null; if (OSVersionPlatform.GetGenericPlatform() == PlatformID.Unix) { //Mono does not implement IPv4Mask //see https://bugzilla.xamarin.com/show_bug.cgi?id=2033 string mask = IPInfoTools.GetIPv4Mask(networkInterface.Name); if (mask == null || IPAddress.TryParse(mask, out ipv4Mask) == false) ipv4Mask = IPAddress.Parse("255.255.255.0"); // default to this } else ipv4Mask = ipInformation.IPv4Mask; SubnetClass interfaceClass = ipv4Mask.GetSubnetClass(); //optionally scan class A & B subnets if (!((subnetClasses & interfaceClass) == interfaceClass)) continue; IPAddress ipAddress = ipInformation.Address; if (ipAddress.AddressFamily == AddressFamily.InterNetwork) { NetworkInterfaceInfo interfaceInfo = new NetworkInterfaceInfo(); interfaceInfo.Host = ipAddress; interfaceInfo.Netmask = ipv4Mask; interfaceInfo.Broadcast = GetBroadcastAddress(interfaceInfo.Host, interfaceInfo.Netmask); //deprecations are known - we only support IPv4 scanning with this code //see above check for AddressFamily.InterNetwork long host = (long)(uint)IPAddress.NetworkToHostOrder((int)interfaceInfo.Host.Address); long netmask = (long)(uint)IPAddress.NetworkToHostOrder((int)interfaceInfo.Netmask.Address); long broadcast = (long)(uint)IPAddress.NetworkToHostOrder((int)interfaceInfo.Broadcast.Address); long network = host & netmask; long rangeStart = network + 1; long rangeEnd = broadcast - 1; //e.g. if host == broadcast, netmask == 255.255.255.255 if (rangeEnd < rangeStart) { long swap = rangeEnd; rangeEnd = rangeStart; rangeStart = swap; } interfaceInfo.RangeStart = new IPAddress((long)(uint)IPAddress.HostToNetworkOrder((int)rangeStart)); interfaceInfo.RangeEnd = new IPAddress((long)(uint)IPAddress.HostToNetworkOrder((int)rangeEnd)); workingInterfaces.Add(interfaceInfo); } } } //cache the results localNetworkInterfaces = workingInterfaces; return localNetworkInterfaces; }
private static NetworkInterfaceInfo GetInterfaces() { // Since many of the methods in java.net.NetworkInterface end up calling this method and the underlying stuff this is // based on isn't very quick either, we cache the array for a couple of seconds. if (cache != null && DateTime.UtcNow - cachedSince < new TimeSpan(0, 0, 5)) { return(cache); } NetworkInterface[] ifaces = NetworkInterface.GetAllNetworkInterfaces(); // on Mono (on Windows) we need to filter out the network interfaces that don't have any IP properties ifaces = Array.FindAll(ifaces, IsValid); Array.Sort(ifaces, Compare); java.net.NetworkInterface[] ret = new java.net.NetworkInterface[ifaces.Length]; int eth = 0; int tr = 0; int fddi = 0; int lo = 0; int ppp = 0; int sl = 0; int net = 0; for (int i = 0; i < ifaces.Length; i++) { string name; switch (ifaces[i].NetworkInterfaceType) { case NetworkInterfaceType.Ethernet: name = "eth" + eth++; break; case NetworkInterfaceType.TokenRing: name = "tr" + tr++; break; case NetworkInterfaceType.Fddi: name = "fddi" + fddi++; break; case NetworkInterfaceType.Loopback: if (lo > 0) { continue; } name = "lo"; lo++; break; case NetworkInterfaceType.Ppp: name = "ppp" + ppp++; break; case NetworkInterfaceType.Slip: name = "sl" + sl++; break; default: name = "net" + net++; break; } java.net.NetworkInterface netif = new java.net.NetworkInterface(); ret[i] = netif; netif._set1(name, ifaces[i].Description, GetIndex(ifaces[i])); UnicastIPAddressInformationCollection uipaic = ifaces[i].GetIPProperties().UnicastAddresses; List <java.net.InetAddress> addresses = new List <java.net.InetAddress>(); List <java.net.InterfaceAddress> bindings = new List <java.net.InterfaceAddress>(); for (int j = 0; j < uipaic.Count; j++) { IPAddress addr = uipaic[j].Address; if (addr.AddressFamily == AddressFamily.InterNetwork) { java.net.Inet4Address address = new java.net.Inet4Address(null, addr.GetAddressBytes()); java.net.InterfaceAddress binding = new java.net.InterfaceAddress(); short mask = 32; java.net.Inet4Address broadcast = null; IPAddress v4mask; try { v4mask = uipaic[j].IPv4Mask; } catch (NotImplementedException) { // Mono (as of 2.6.7) doesn't implement the IPv4Mask property v4mask = null; } if (v4mask != null && !v4mask.Equals(IPAddress.Any)) { broadcast = new java.net.Inet4Address(null, -1); mask = 0; foreach (byte b in v4mask.GetAddressBytes()) { mask += (short)java.lang.Integer.bitCount(b); } } else if (address.isLoopbackAddress()) { mask = 8; broadcast = new java.net.Inet4Address(null, 0xffffff); } binding._set(address, broadcast, mask); addresses.Add(address); bindings.Add(binding); } else if (Java_java_net_InetAddressImplFactory.isIPv6Supported()) { int scope = 0; if (addr.IsIPv6LinkLocal || addr.IsIPv6SiteLocal) { scope = (int)addr.ScopeId; } java.net.Inet6Address ia6 = new java.net.Inet6Address(); ia6._holder().ipaddress = addr.GetAddressBytes(); if (scope != 0) { ia6._holder().scope_id = scope; ia6._holder().scope_id_set = true; ia6._holder().scope_ifname = netif; ia6._holder().scope_ifname_set = true; } java.net.InterfaceAddress binding = new java.net.InterfaceAddress(); // TODO where do we get the IPv6 subnet prefix length? short mask = 128; binding._set(ia6, null, mask); addresses.Add(ia6); bindings.Add(binding); } } netif._set2(addresses.ToArray(), bindings.ToArray(), new java.net.NetworkInterface[0]); } NetworkInterfaceInfo nii = new NetworkInterfaceInfo(); nii.dotnetInterfaces = ifaces; nii.javaInterfaces = ret; cache = nii; cachedSince = DateTime.UtcNow; return(nii); }
public static IObservable<NameResolutionResult> ResolveHostName(DnsEndPoint endPoint, NetworkInterfaceInfo networkInterface) { Contract.Requires(endPoint != null); Contract.Requires(networkInterface != null); Contract.Ensures(Contract.Result<IObservable<NameResolutionResult>>() != null); var subject = new AsyncSubject<NameResolutionResult>(); try { DeviceNetworkInformation.ResolveHostNameAsync( endPoint, networkInterface, result => { var s = (AsyncSubject<NameResolutionResult>) result.AsyncState; s.OnNext(result); s.OnCompleted(); }, subject); } catch (Exception ex) { subject.OnError(ex); } return subject.AsObservable(); }
private static NetworkInterfaceInfo GetInterfaces() { // Since many of the methods in java.net.NetworkInterface end up calling this method and the underlying stuff this is // based on isn't very quick either, we cache the array for a couple of seconds. if (cache != null && DateTime.UtcNow - cachedSince < new TimeSpan(0, 0, 5)) { return cache; } NetworkInterface[] ifaces = NetworkInterface.GetAllNetworkInterfaces(); // on Mono (on Windows) we need to filter out the network interfaces that don't have any IP properties ifaces = Array.FindAll(ifaces, IsValid); Array.Sort(ifaces, Compare); java.net.NetworkInterface[] ret = new java.net.NetworkInterface[ifaces.Length]; int eth = 0; int tr = 0; int fddi = 0; int lo = 0; int ppp = 0; int sl = 0; int net = 0; for (int i = 0; i < ifaces.Length; i++) { string name; switch (ifaces[i].NetworkInterfaceType) { case NetworkInterfaceType.Ethernet: name = "eth" + eth++; break; case NetworkInterfaceType.TokenRing: name = "tr" + tr++; break; case NetworkInterfaceType.Fddi: name = "fddi" + fddi++; break; case NetworkInterfaceType.Loopback: if (lo > 0) { continue; } name = "lo"; lo++; break; case NetworkInterfaceType.Ppp: name = "ppp" + ppp++; break; case NetworkInterfaceType.Slip: name = "sl" + sl++; break; default: name = "net" + net++; break; } java.net.NetworkInterface netif = new java.net.NetworkInterface(); ret[i] = netif; netif._set1(name, ifaces[i].Description, GetIndex(ifaces[i])); UnicastIPAddressInformationCollection uipaic = ifaces[i].GetIPProperties().UnicastAddresses; List<java.net.InetAddress> addresses = new List<java.net.InetAddress>(); List<java.net.InterfaceAddress> bindings = new List<java.net.InterfaceAddress>(); for (int j = 0; j < uipaic.Count; j++) { IPAddress addr = uipaic[j].Address; if (addr.AddressFamily == AddressFamily.InterNetwork) { java.net.Inet4Address address = new java.net.Inet4Address(null, addr.GetAddressBytes()); java.net.InterfaceAddress binding = new java.net.InterfaceAddress(); short mask = 32; java.net.Inet4Address broadcast = null; IPAddress v4mask; try { v4mask = uipaic[j].IPv4Mask; } catch (NotImplementedException) { // Mono (as of 2.6.7) doesn't implement the IPv4Mask property v4mask = null; } if (v4mask != null && !v4mask.Equals(IPAddress.Any)) { broadcast = new java.net.Inet4Address(null, -1); mask = 0; foreach (byte b in v4mask.GetAddressBytes()) { mask += (short)java.lang.Integer.bitCount(b); } } else if (address.isLoopbackAddress()) { mask = 8; broadcast = new java.net.Inet4Address(null, 0xffffff); } binding._set(address, broadcast, mask); addresses.Add(address); bindings.Add(binding); } else if (Java_java_net_InetAddressImplFactory.isIPv6Supported()) { int scope = 0; if (addr.IsIPv6LinkLocal || addr.IsIPv6SiteLocal) { scope = (int)addr.ScopeId; } java.net.Inet6Address ia6 = new java.net.Inet6Address(); ia6._holder().ipaddress = addr.GetAddressBytes(); if (scope != 0) { ia6._holder().scope_id = scope; ia6._holder().scope_id_set = true; ia6._holder().scope_ifname = netif; ia6._holder().scope_ifname_set = true; } java.net.InterfaceAddress binding = new java.net.InterfaceAddress(); // TODO where do we get the IPv6 subnet prefix length? short mask = 128; binding._set(ia6, null, mask); addresses.Add(ia6); bindings.Add(binding); } } netif._set2(addresses.ToArray(), bindings.ToArray(), new java.net.NetworkInterface[0]); } NetworkInterfaceInfo nii = new NetworkInterfaceInfo(); nii.dotnetInterfaces = ifaces; nii.javaInterfaces = ret; cache = nii; cachedSince = DateTime.UtcNow; return nii; }
private async Task<Host> GetEc2Instance(string id) { var instance = await ec2.DescribeInstanceAsync(id).ConfigureAwait(false); var host = new Host { Type = HostType.VirtualInstance, RefId = instance.InstanceId, Addresses = new List<IPAddress>() { IPAddress.Parse(instance.IpAddress), IPAddress.Parse(instance.PrivateIpAddress) }, Details = new JsonObject { { "availabilityZone", instance.Placement.AvailabilityZone }, { "instanceType", instance.InstanceType }, { "hypervisor", instance.Hypervisor }, { "vpcId", instance.VpcId } }, Provider = PlatformProviderId.Amazon, Status = GetStatus(instance.InstanceState), Modified = DateTime.UtcNow, Created = instance.LaunchTime }; // "imageId": "ami-1647537c", if (instance.ImageId != null) { // Images may be shared var image = (await db.Images.QueryFirstOrDefaultAsync(Eq("refId", instance.ImageId))); if (image == null) { image = new Image { RefId = instance.ImageId, // Architecture = instance.Architecture, Created = DateTime.UtcNow }; await db.Images.InsertAsync(image).ConfigureAwait(false); host.ImageId = image.Id; } } await db.Hosts.InsertAsync(host); foreach (var v in instance.BlockDeviceMappings) { if (v.Ebs != null) { var vv = await ec2.DescribeVolumeAsync(v.Ebs.VolumeId).ConfigureAwait(false); var vol = new VolumeInfo { RefId = v.Ebs.VolumeId, Provider = PlatformProviderId.Amazon, Status = VolumeStatus.Online, Size = (long)vv.Size * 1073741824, HostId = host.Id, Created = vv.CreateTime }; await db.Volumes.InsertAsync(vol).ConfigureAwait(false); } } foreach (var ni in instance.NetworkInterfaces) { var networkInterface = new NetworkInterfaceInfo { MacAddress = ni.MacAddress, Provider = PlatformProviderId.Amazon, RefId = ni.NetworkInterfaceId, HostId = host.Id, Details = new JsonObject { { "subnetId", ni.SubnetId }, { "vpcId", ni.VpcId } }, Created = DateTime.UtcNow }; /* if (ni.Groups != null) { var list = new XList<string>(ni.Groups.Select(ni ); foreach (var group in ni.Groups) { } } */ // ? IP addresses // ? Security groups await db.NetworkInterfaces.InsertAsync(networkInterface).ConfigureAwait(false); } return host; }
private static void InvokeNetworkRequest(Delegate del, Delegate netOpInProgressDel) { // this code is non-reentrant if (isRequestInProgress == true) { return; } // set the request in progress flag isRequestInProgress = true; // signal that a network operation is starting netOpInProgressDel.DynamicInvoke(true, OperationStatus.Started); // get a Uri for the service - this will be used to decode the host / port Uri uri = new Uri(SpeechUrl); // create the socket if (socket == null) { socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); if (uri.Host == "localhost") { endPoint = new IPEndPoint(IPAddress.Loopback, uri.Port); } else { endPoint = new DnsEndPoint(uri.Host, uri.Port, AddressFamily.InterNetwork); } } SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs(); socketEventArg.RemoteEndPoint = endPoint; // set the connect completion delegate socketEventArg.Completed += new EventHandler <SocketAsyncEventArgs>(delegate(object o, SocketAsyncEventArgs e) { if (e.SocketError != SocketError.Success) { // signal that a network operation is done and unsuccessful netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed); // clean up the socket CleanupSocket(); return; } // get the current network interface info NetworkInterfaceInfo netInterfaceInfo = socket.GetCurrentNetworkInterface(); // invoke the completion delegate with the network type info del.DynamicInvoke(netInterfaceInfo); }); // if the socket isn't connected, connect now if (socket.Connected == false) { // connect to the service try { bool ret = socket.ConnectAsync(socketEventArg); if (ret == false) { // signal that a network operation is done and unsuccessful netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed); // clean up the socket CleanupSocket(); } } catch (Exception ex) { // trace network error TraceHelper.AddMessage("InvokeNetworkRequest: ex: " + ex.Message); // signal that a network operation is done and unsuccessful netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed); // clean up the socket CleanupSocket(); } } else { // socket already connected // get the current network interface info NetworkInterfaceInfo netInterfaceInfo = socket.GetCurrentNetworkInterface(); // invoke the completion delegate with the network type info del.DynamicInvoke(netInterfaceInfo); } }