jellyfin/Emby.Common.Implementations/IO/SharpCifs/Netbios/NbtAddress.cs
2017-04-01 20:36:06 -04:00

921 lines
27 KiB
C#

// This code is derived from jcifs smb client library <jcifs at samba dot org>
// Ported by J. Arturo <webmaster at komodosoft dot net>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
using System;
using System.Linq;
using System.Net;
using SharpCifs.Util;
using SharpCifs.Util.Sharpen;
using Extensions = SharpCifs.Util.Sharpen.Extensions;
namespace SharpCifs.Netbios
{
/// <summary>This class represents a NetBIOS over TCP/IP address.</summary>
/// <remarks>
/// This class represents a NetBIOS over TCP/IP address. Under normal
/// conditions, users of jCIFS need not be concerned with this class as
/// name resolution and session services are handled internally by the smb package.
/// <p> Applications can use the methods <code>getLocalHost</code>,
/// <code>getByName</code>, and
/// <code>getAllByAddress</code> to create a new NbtAddress instance. This
/// class is symmetric with
/// <see cref="System.Net.IPAddress">System.Net.IPAddress</see>
/// .
/// <p><b>About NetBIOS:</b> The NetBIOS name
/// service is a dynamic distributed service that allows hosts to resolve
/// names by broadcasting a query, directing queries to a server such as
/// Samba or WINS. NetBIOS is currently the primary networking layer for
/// providing name service, datagram service, and session service to the
/// Microsoft Windows platform. A NetBIOS name can be 15 characters long
/// and hosts usually registers several names on the network. From a
/// Windows command prompt you can see
/// what names a host registers with the nbtstat command.
/// <p><blockquote><pre>
/// C:\&gt;nbtstat -a 192.168.1.15
/// NetBIOS Remote Machine Name Table
/// Name Type Status
/// ---------------------------------------------
/// JMORRIS2 <00> UNIQUE Registered
/// BILLING-NY <00> GROUP Registered
/// JMORRIS2 <03> UNIQUE Registered
/// JMORRIS2 <20> UNIQUE Registered
/// BILLING-NY <1E> GROUP Registered
/// JMORRIS <03> UNIQUE Registered
/// MAC Address = 00-B0-34-21-FA-3B
/// </blockquote></pre>
/// <p> The hostname of this machine is <code>JMORRIS2</code>. It is
/// a member of the group(a.k.a workgroup and domain) <code>BILLING-NY</code>. To
/// obtain an
/// <see cref="System.Net.IPAddress">System.Net.IPAddress</see>
/// for a host one might do:
/// <pre>
/// InetAddress addr = NbtAddress.getByName( "jmorris2" ).getInetAddress();
/// </pre>
/// <p>From a UNIX platform with Samba installed you can perform similar
/// diagnostics using the <code>nmblookup</code> utility.
/// </remarks>
/// <author>Michael B. Allen</author>
/// <seealso cref="System.Net.IPAddress">System.Net.IPAddress</seealso>
/// <since>jcifs-0.1</since>
public sealed class NbtAddress
{
internal static readonly string AnyHostsName = "*\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000";
/// <summary>
/// This is a special name for querying the master browser that serves the
/// list of hosts found in "Network Neighborhood".
/// </summary>
/// <remarks>
/// This is a special name for querying the master browser that serves the
/// list of hosts found in "Network Neighborhood".
/// </remarks>
public static readonly string MasterBrowserName = "\u0001\u0002__MSBROWSE__\u0002";
/// <summary>
/// A special generic name specified when connecting to a host for which
/// a name is not known.
/// </summary>
/// <remarks>
/// A special generic name specified when connecting to a host for which
/// a name is not known. Not all servers respond to this name.
/// </remarks>
public static readonly string SmbserverName = "*SMBSERVER ";
/// <summary>A B node only broadcasts name queries.</summary>
/// <remarks>
/// A B node only broadcasts name queries. This is the default if a
/// nameserver such as WINS or Samba is not specified.
/// </remarks>
public const int BNode = 0;
/// <summary>
/// A Point-to-Point node, or P node, unicasts queries to a nameserver
/// only.
/// </summary>
/// <remarks>
/// A Point-to-Point node, or P node, unicasts queries to a nameserver
/// only. Natrually the <code>jcifs.netbios.nameserver</code> property must
/// be set.
/// </remarks>
public const int PNode = 1;
/// <summary>
/// Try Broadcast queries first, then try to resolve the name using the
/// nameserver.
/// </summary>
/// <remarks>
/// Try Broadcast queries first, then try to resolve the name using the
/// nameserver.
/// </remarks>
public const int MNode = 2;
/// <summary>A Hybrid node tries to resolve a name using the nameserver first.</summary>
/// <remarks>
/// A Hybrid node tries to resolve a name using the nameserver first. If
/// that fails use the broadcast address. This is the default if a nameserver
/// is provided. This is the behavior of Microsoft Windows machines.
/// </remarks>
public const int HNode = 3;
internal static readonly IPAddress[] Nbns = Config.GetInetAddressArray("jcifs.netbios.wins"
, ",", new IPAddress[0]);
private static readonly NameServiceClient Client = new NameServiceClient();
private const int DefaultCachePolicy = 30;
private static readonly int CachePolicy = Config.GetInt("jcifs.netbios.cachePolicy"
, DefaultCachePolicy);
private const int Forever = -1;
private static int _nbnsIndex;
private static readonly Hashtable AddressCache = new Hashtable();
private static readonly Hashtable LookupTable = new Hashtable();
internal static readonly Name UnknownName = new Name("0.0.0.0", unchecked(0x00), null);
internal static readonly NbtAddress UnknownAddress = new NbtAddress
(UnknownName, 0, false, BNode);
internal static readonly byte[] UnknownMacAddress = { unchecked(unchecked(0x00)), unchecked(unchecked(0x00)), unchecked(unchecked(0x00)), unchecked(unchecked(0x00)), unchecked(unchecked(0x00)), unchecked(unchecked(0x00)) };
internal sealed class CacheEntry
{
internal Name HostName;
internal NbtAddress Address;
internal long Expiration;
internal CacheEntry(Name hostName, NbtAddress address, long expiration)
{
this.HostName = hostName;
this.Address = address;
this.Expiration = expiration;
}
}
internal static NbtAddress Localhost;
static NbtAddress()
{
IPAddress localInetAddress;
string localHostname;
Name localName;
AddressCache.Put(UnknownName, new CacheEntry(UnknownName, UnknownAddress
, Forever));
localInetAddress = Client.laddr;
if (localInetAddress == null)
{
try
{
localInetAddress = Extensions.GetAddressByName("127.0.0.1");
}
catch (UnknownHostException)
{
}
}
localHostname = Config.GetProperty("jcifs.netbios.hostname", null);
if (string.IsNullOrEmpty(localHostname))
{
byte[] addr = localInetAddress.GetAddressBytes();
/*localHostname = "JCIFS" + (addr[2] & unchecked((int)(0xFF))) + "_" + (addr[3] & unchecked(
(int)(0xFF))) + "_" + Hexdump.ToHexString((int)(new Random().NextDouble() * (double)unchecked(
(int)(0xFF))), 2);*/
localHostname = "JCIFS_127_0_0_1";
}
localName = new Name(localHostname, unchecked(0x00), Config.GetProperty("jcifs.netbios.scope"
, null));
Localhost = new NbtAddress(localName, localInetAddress.GetHashCode(), false, BNode
, false, false, true, false, UnknownMacAddress);
CacheAddress(localName, Localhost, Forever);
}
internal static void CacheAddress(Name hostName, NbtAddress addr)
{
if (CachePolicy == 0)
{
return;
}
long expiration = -1;
if (CachePolicy != Forever)
{
expiration = Runtime.CurrentTimeMillis() + CachePolicy * 1000;
}
CacheAddress(hostName, addr, expiration);
}
internal static void CacheAddress(Name hostName, NbtAddress addr, long expiration
)
{
if (CachePolicy == 0)
{
return;
}
lock (AddressCache)
{
CacheEntry entry = (CacheEntry)AddressCache.Get(hostName);
if (entry == null)
{
entry = new CacheEntry(hostName, addr, expiration);
AddressCache.Put(hostName, entry);
}
else
{
entry.Address = addr;
entry.Expiration = expiration;
}
}
}
internal static void CacheAddressArray(NbtAddress[] addrs)
{
if (CachePolicy == 0)
{
return;
}
long expiration = -1;
if (CachePolicy != Forever)
{
expiration = Runtime.CurrentTimeMillis() + CachePolicy * 1000;
}
lock (AddressCache)
{
for (int i = 0; i < addrs.Length; i++)
{
CacheEntry entry = (CacheEntry)AddressCache.Get(addrs[i].HostName
);
if (entry == null)
{
entry = new CacheEntry(addrs[i].HostName, addrs[i], expiration);
AddressCache.Put(addrs[i].HostName, entry);
}
else
{
entry.Address = addrs[i];
entry.Expiration = expiration;
}
}
}
}
internal static NbtAddress GetCachedAddress(Name hostName)
{
if (CachePolicy == 0)
{
return null;
}
lock (AddressCache)
{
CacheEntry entry = (CacheEntry)AddressCache.Get(hostName);
if (entry != null && entry.Expiration < Runtime.CurrentTimeMillis() && entry.Expiration
>= 0)
{
entry = null;
}
return entry != null ? entry.Address : null;
}
}
/// <exception cref="UnknownHostException"></exception>
internal static NbtAddress DoNameQuery(Name name, IPAddress svr)
{
NbtAddress addr;
if (name.HexCode == unchecked(0x1d) && svr == null)
{
svr = Client.Baddr;
}
// bit of a hack but saves a lookup
name.SrcHashCode = svr != null ? svr.GetHashCode() : 0;
addr = GetCachedAddress(name);
if (addr == null)
{
if ((addr = (NbtAddress)CheckLookupTable(name)) == null)
{
try
{
addr = Client.GetByName(name, svr);
}
catch (UnknownHostException)
{
addr = UnknownAddress;
}
finally
{
CacheAddress(name, addr);
UpdateLookupTable(name);
}
}
}
if (addr == UnknownAddress)
{
throw new UnknownHostException(name.ToString());
}
return addr;
}
private static object CheckLookupTable(Name name)
{
object obj;
lock (LookupTable)
{
if (LookupTable.ContainsKey(name) == false)
{
LookupTable.Put(name, name);
return null;
}
while (LookupTable.ContainsKey(name))
{
try
{
Runtime.Wait(LookupTable);
}
catch (Exception)
{
}
}
}
obj = GetCachedAddress(name);
if (obj == null)
{
lock (LookupTable)
{
LookupTable.Put(name, name);
}
}
return obj;
}
private static void UpdateLookupTable(Name name)
{
lock (LookupTable)
{
//Sharpen.Collections.Remove(LOOKUP_TABLE, name);
LookupTable.Remove(name);
Runtime.NotifyAll(LookupTable);
}
}
/// <summary>Retrieves the local host address.</summary>
/// <remarks>Retrieves the local host address.</remarks>
/// <exception cref="UnknownHostException">
/// This is not likely as the IP returned
/// by <code>InetAddress</code> should be available
/// </exception>
public static NbtAddress GetLocalHost()
{
return Localhost;
}
public static NbtAddress[] GetHosts()
{
return new NameServiceClient().GetHosts();
}
public static Name GetLocalName()
{
return Localhost.HostName;
}
/// <summary>Determines the address of a host given it's host name.</summary>
/// <remarks>
/// Determines the address of a host given it's host name. The name can be a NetBIOS name like
/// "freto" or an IP address like "192.168.1.15". It cannot be a DNS name;
/// the analygous
/// <see cref="SharpCifs.UniAddress">Jcifs.UniAddress</see>
/// or
/// <see cref="System.Net.IPAddress">System.Net.IPAddress</see>
/// <code>getByName</code> methods can be used for that.
/// </remarks>
/// <param name="host">hostname to resolve</param>
/// <exception cref="UnknownHostException">if there is an error resolving the name
/// </exception>
public static NbtAddress GetByName(string host)
{
return GetByName(host, unchecked(0x00), null);
}
/// <summary>Determines the address of a host given it's host name.</summary>
/// <remarks>
/// Determines the address of a host given it's host name. NetBIOS
/// names also have a <code>type</code>. Types(aka Hex Codes)
/// are used to distiquish the various services on a host. &lt;a
/// href="../../../nbtcodes.html"&gt;Here</a> is
/// a fairly complete list of NetBIOS hex codes. Scope is not used but is
/// still functional in other NetBIOS products and so for completeness it has been
/// implemented. A <code>scope</code> of <code>null</code> or <code>""</code>
/// signifies no scope.
/// </remarks>
/// <param name="host">the name to resolve</param>
/// <param name="type">the hex code of the name</param>
/// <param name="scope">the scope of the name</param>
/// <exception cref="UnknownHostException">if there is an error resolving the name
/// </exception>
public static NbtAddress GetByName(string host, int type, string scope)
{
return GetByName(host, type, scope, null);
}
/// <exception cref="UnknownHostException"></exception>
public static NbtAddress GetByName(string host, int type, string scope, IPAddress
svr)
{
if (string.IsNullOrEmpty(host))
{
return GetLocalHost();
}
if (!char.IsDigit(host[0]))
{
return DoNameQuery(new Name(host, type, scope), svr);
}
int ip = unchecked(0x00);
int hitDots = 0;
char[] data = host.ToCharArray();
for (int i = 0; i < data.Length; i++)
{
char c = data[i];
if (c < 48 || c > 57)
{
return DoNameQuery(new Name(host, type, scope), svr);
}
int b = unchecked(0x00);
while (c != '.')
{
if (c < 48 || c > 57)
{
return DoNameQuery(new Name(host, type, scope), svr);
}
b = b * 10 + c - '0';
if (++i >= data.Length)
{
break;
}
c = data[i];
}
if (b > unchecked(0xFF))
{
return DoNameQuery(new Name(host, type, scope), svr);
}
ip = (ip << 8) + b;
hitDots++;
}
if (hitDots != 4 || host.EndsWith("."))
{
return DoNameQuery(new Name(host, type, scope), svr);
}
return new NbtAddress(UnknownName, ip, false, BNode);
}
/// <exception cref="UnknownHostException"></exception>
public static NbtAddress[] GetAllByName(string host, int type, string scope, IPAddress
svr)
{
return Client.GetAllByName(new Name(host, type, scope), svr);
}
/// <summary>Retrieve all addresses of a host by it's address.</summary>
/// <remarks>
/// Retrieve all addresses of a host by it's address. NetBIOS hosts can
/// have many names for a given IP address. The name and IP address make the
/// NetBIOS address. This provides a way to retrieve the other names for a
/// host with the same IP address.
/// </remarks>
/// <param name="host">hostname to lookup all addresses for</param>
/// <exception cref="UnknownHostException">if there is an error resolving the name
/// </exception>
public static NbtAddress[] GetAllByAddress(string host)
{
return GetAllByAddress(GetByName(host, unchecked(0x00), null));
}
/// <summary>Retrieve all addresses of a host by it's address.</summary>
/// <remarks>
/// Retrieve all addresses of a host by it's address. NetBIOS hosts can
/// have many names for a given IP address. The name and IP address make
/// the NetBIOS address. This provides a way to retrieve the other names
/// for a host with the same IP address. See
/// <see cref="GetByName(string)">GetByName(string)</see>
/// for a description of <code>type</code>
/// and <code>scope</code>.
/// </remarks>
/// <param name="host">hostname to lookup all addresses for</param>
/// <param name="type">the hexcode of the name</param>
/// <param name="scope">the scope of the name</param>
/// <exception cref="UnknownHostException">if there is an error resolving the name
/// </exception>
public static NbtAddress[] GetAllByAddress(string host, int type, string scope)
{
return GetAllByAddress(GetByName(host, type, scope));
}
/// <summary>Retrieve all addresses of a host by it's address.</summary>
/// <remarks>
/// Retrieve all addresses of a host by it's address. NetBIOS hosts can
/// have many names for a given IP address. The name and IP address make the
/// NetBIOS address. This provides a way to retrieve the other names for a
/// host with the same IP address.
/// </remarks>
/// <param name="addr">the address to query</param>
/// <exception cref="UnknownHostException">if address cannot be resolved</exception>
public static NbtAddress[] GetAllByAddress(NbtAddress addr)
{
try
{
NbtAddress[] addrs = Client.GetNodeStatus(addr);
CacheAddressArray(addrs);
return addrs;
}
catch (UnknownHostException)
{
throw new UnknownHostException("no name with type 0x" + Hexdump.ToHexString(addr.
HostName.HexCode, 2) + (((addr.HostName.Scope == null) || (addr.HostName.Scope.Length
== 0)) ? " with no scope" : " with scope " + addr.HostName.Scope) + " for host "
+ addr.GetHostAddress());
}
}
public static IPAddress GetWinsAddress()
{
return Nbns.Length == 0 ? null : Nbns[_nbnsIndex];
}
public static bool IsWins(IPAddress svr)
{
for (int i = 0; svr != null && i < Nbns.Length; i++)
{
if (svr.GetHashCode() == Nbns[i].GetHashCode())
{
return true;
}
}
return false;
}
internal static IPAddress SwitchWins()
{
_nbnsIndex = (_nbnsIndex + 1) < Nbns.Length ? _nbnsIndex + 1 : 0;
return Nbns.Length == 0 ? null : Nbns[_nbnsIndex];
}
internal Name HostName;
internal int Address;
internal int NodeType;
internal bool GroupName;
internal bool isBeingDeleted;
internal bool isInConflict;
internal bool isActive;
internal bool isPermanent;
internal bool IsDataFromNodeStatus;
internal byte[] MacAddress;
internal string CalledName;
internal NbtAddress(Name hostName, int address, bool groupName, int nodeType)
{
this.HostName = hostName;
this.Address = address;
this.GroupName = groupName;
this.NodeType = nodeType;
}
internal NbtAddress(Name hostName, int address, bool groupName, int nodeType, bool
isBeingDeleted, bool isInConflict, bool isActive, bool isPermanent, byte[] macAddress
)
{
this.HostName = hostName;
this.Address = address;
this.GroupName = groupName;
this.NodeType = nodeType;
this.isBeingDeleted = isBeingDeleted;
this.isInConflict = isInConflict;
this.isActive = isActive;
this.isPermanent = isPermanent;
this.MacAddress = macAddress;
IsDataFromNodeStatus = true;
}
public string FirstCalledName()
{
CalledName = HostName.name;
if (char.IsDigit(CalledName[0]))
{
int i;
int len;
int dots;
char[] data;
i = dots = 0;
len = CalledName.Length;
data = CalledName.ToCharArray();
while (i < len && char.IsDigit(data[i++]))
{
if (i == len && dots == 3)
{
// probably an IP address
CalledName = SmbserverName;
break;
}
if (i < len && data[i] == '.')
{
dots++;
i++;
}
}
}
else
{
switch (HostName.HexCode)
{
case unchecked(0x1B):
case unchecked(0x1C):
case unchecked(0x1D):
{
CalledName = SmbserverName;
break;
}
}
}
return CalledName;
}
public string NextCalledName()
{
if (CalledName == HostName.name)
{
CalledName = SmbserverName;
}
else
{
if (CalledName == SmbserverName)
{
NbtAddress[] addrs;
try
{
addrs = Client.GetNodeStatus(this);
if (HostName.HexCode == unchecked(0x1D))
{
for (int i = 0; i < addrs.Length; i++)
{
if (addrs[i].HostName.HexCode == unchecked(0x20))
{
return addrs[i].HostName.name;
}
}
return null;
}
if (IsDataFromNodeStatus)
{
CalledName = null;
return HostName.name;
}
}
catch (UnknownHostException)
{
CalledName = null;
}
}
else
{
CalledName = null;
}
}
return CalledName;
}
/// <exception cref="UnknownHostException"></exception>
internal void CheckData()
{
if (HostName == UnknownName)
{
GetAllByAddress(this);
}
}
/// <exception cref="UnknownHostException"></exception>
internal void CheckNodeStatusData()
{
if (IsDataFromNodeStatus == false)
{
GetAllByAddress(this);
}
}
/// <summary>Determines if the address is a group address.</summary>
/// <remarks>
/// Determines if the address is a group address. This is also
/// known as a workgroup name or group name.
/// </remarks>
/// <exception cref="UnknownHostException">if the host cannot be resolved to find out.
/// </exception>
public bool IsGroupAddress()
{
CheckData();
return GroupName;
}
/// <summary>Checks the node type of this address.</summary>
/// <remarks>Checks the node type of this address.</remarks>
/// <returns>
///
/// <see cref="BNode">B_NODE</see>
/// ,
/// <see cref="PNode">P_NODE</see>
/// ,
/// <see cref="MNode">M_NODE</see>
/// ,
/// <see cref="HNode">H_NODE</see>
/// </returns>
/// <exception cref="UnknownHostException">if the host cannot be resolved to find out.
/// </exception>
public int GetNodeType()
{
CheckData();
return NodeType;
}
/// <summary>Determines if this address in the process of being deleted.</summary>
/// <remarks>Determines if this address in the process of being deleted.</remarks>
/// <exception cref="UnknownHostException">if the host cannot be resolved to find out.
/// </exception>
public bool IsBeingDeleted()
{
CheckNodeStatusData();
return isBeingDeleted;
}
/// <summary>Determines if this address in conflict with another address.</summary>
/// <remarks>Determines if this address in conflict with another address.</remarks>
/// <exception cref="UnknownHostException">if the host cannot be resolved to find out.
/// </exception>
public bool IsInConflict()
{
CheckNodeStatusData();
return isInConflict;
}
/// <summary>Determines if this address is active.</summary>
/// <remarks>Determines if this address is active.</remarks>
/// <exception cref="UnknownHostException">if the host cannot be resolved to find out.
/// </exception>
public bool IsActive()
{
CheckNodeStatusData();
return isActive;
}
/// <summary>Determines if this address is set to be permanent.</summary>
/// <remarks>Determines if this address is set to be permanent.</remarks>
/// <exception cref="UnknownHostException">if the host cannot be resolved to find out.
/// </exception>
public bool IsPermanent()
{
CheckNodeStatusData();
return isPermanent;
}
/// <summary>Retrieves the MAC address of the remote network interface.</summary>
/// <remarks>Retrieves the MAC address of the remote network interface. Samba returns all zeros.
/// </remarks>
/// <returns>the MAC address as an array of six bytes</returns>
/// <exception cref="UnknownHostException">
/// if the host cannot be resolved to
/// determine the MAC address.
/// </exception>
public byte[] GetMacAddress()
{
CheckNodeStatusData();
return MacAddress;
}
/// <summary>The hostname of this address.</summary>
/// <remarks>
/// The hostname of this address. If the hostname is null the local machines
/// IP address is returned.
/// </remarks>
/// <returns>the text representation of the hostname associated with this address</returns>
public string GetHostName()
{
if (HostName == UnknownName)
{
return GetHostAddress();
}
return HostName.name;
}
/// <summary>Returns the raw IP address of this NbtAddress.</summary>
/// <remarks>
/// Returns the raw IP address of this NbtAddress. The result is in network
/// byte order: the highest order byte of the address is in getAddress()[0].
/// </remarks>
/// <returns>a four byte array</returns>
public byte[] GetAddress()
{
byte[] addr = new byte[4];
addr[0] = unchecked((byte)(((int)(((uint)Address) >> 24)) & unchecked(0xFF
)));
addr[1] = unchecked((byte)(((int)(((uint)Address) >> 16)) & unchecked(0xFF
)));
addr[2] = unchecked((byte)(((int)(((uint)Address) >> 8)) & unchecked(0xFF)
));
addr[3] = unchecked((byte)(Address & unchecked(0xFF)));
return addr;
}
/// <summary>To convert this address to an <code>InetAddress</code>.</summary>
/// <remarks>To convert this address to an <code>InetAddress</code>.</remarks>
/// <returns>
/// the
/// <see cref="System.Net.IPAddress">System.Net.IPAddress</see>
/// representation of this address.
/// </returns>
/// <exception cref="UnknownHostException"></exception>
public IPAddress GetInetAddress()
{
return Extensions.GetAddressByName(GetHostAddress());
}
/// <summary>
/// Returns this IP adress as a
/// <see cref="string">string</see>
/// in the form "%d.%d.%d.%d".
/// </summary>
public string GetHostAddress()
{
return (((int)(((uint)Address) >> 24)) & unchecked(0xFF)) + "." + (((int)(
((uint)Address) >> 16)) & unchecked(0xFF)) + "." + (((int)(((uint)Address
) >> 8)) & unchecked(0xFF)) + "." + (((int)(((uint)Address) >> 0)) & unchecked(
0xFF));
}
/// <summary>Returned the hex code associated with this name(e.g.</summary>
/// <remarks>Returned the hex code associated with this name(e.g. 0x20 is for the file service)
/// </remarks>
public int GetNameType()
{
return HostName.HexCode;
}
/// <summary>Returns a hashcode for this IP address.</summary>
/// <remarks>
/// Returns a hashcode for this IP address. The hashcode comes from the IP address
/// and is not generated from the string representation. So because NetBIOS nodes
/// can have many names, all names associated with an IP will have the same
/// hashcode.
/// </remarks>
public override int GetHashCode()
{
return Address;
}
/// <summary>Determines if this address is equal two another.</summary>
/// <remarks>
/// Determines if this address is equal two another. Only the IP Addresses
/// are compared. Similar to the
/// <see cref="GetHashCode()">GetHashCode()</see>
/// method, the comparison
/// is based on the integer IP address and not the string representation.
/// </remarks>
public override bool Equals(object obj)
{
return (obj != null) && (obj is NbtAddress) && (((NbtAddress)obj).Address == Address
);
}
/// <summary>
/// Returns the
/// <see cref="string">string</see>
/// representaion of this address.
/// </summary>
public override string ToString()
{
return HostName + "/" + GetHostAddress();
}
}
}