// 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.IO;
using System.Linq;
using System.Net;
using SharpCifs.Netbios;
using SharpCifs.Util;
using SharpCifs.Util.Sharpen;
using Extensions = SharpCifs.Util.Sharpen.Extensions;
using System.Threading.Tasks;
namespace SharpCifs
{
/// <summary>
/// <p>Under normal conditions it is not necessary to use
/// this class to use jCIFS properly.
/// </summary>
/// <remarks>
/// <p>Under normal conditions it is not necessary to use
/// this class to use jCIFS properly. Name resolusion is
/// handled internally to the <code>jcifs.smb</code> package.
/// <p>
/// This class is a wrapper for both
/// <see cref="Jcifs.Netbios.NbtAddress">Jcifs.Netbios.NbtAddress</see>
/// and
/// <see cref="System.Net.IPAddress">System.Net.IPAddress</see>
/// . The name resolution mechanisms
/// used will systematically query all available configured resolution
/// services including WINS, broadcasts, DNS, and LMHOSTS. See
/// <a href="../../resolver.html">Setting Name Resolution Properties</a>
/// and the <code>jcifs.resolveOrder</code> property. Changing
/// jCIFS name resolution properties can greatly affect the behavior of
/// the client and may be necessary for proper operation.
/// <p>
/// This class should be used in favor of <tt>InetAddress</tt> to resolve
/// hostnames on LANs and WANs that support a mixture of NetBIOS/WINS and
/// DNS resolvable hosts.
/// </remarks>
public class UniAddress
{
private const int ResolverWins = 0;
private const int ResolverBcast = 1;
private const int ResolverDns = 2;
private const int ResolverLmhosts = 3;
private static int[] _resolveOrder;
private static IPAddress _baddr;
private static LogStream _log = LogStream.GetInstance();
static UniAddress()
{
string ro = Config.GetProperty("jcifs.resolveOrder");
IPAddress nbns = NbtAddress.GetWinsAddress();
try
{
_baddr = Config.GetInetAddress("jcifs.netbios.baddr",
Extensions.GetAddressByName("255.255.255.255"));
}
catch (UnknownHostException)
{
}
if (string.IsNullOrEmpty(ro))
{
if (nbns == null)
{
_resolveOrder = new int[3];
_resolveOrder[0] = ResolverLmhosts;
_resolveOrder[1] = ResolverDns;
_resolveOrder[2] = ResolverBcast;
}
else
{
_resolveOrder = new int[4];
_resolveOrder[0] = ResolverLmhosts;
_resolveOrder[1] = ResolverWins;
_resolveOrder[2] = ResolverDns;
_resolveOrder[3] = ResolverBcast;
}
}
else
{
int[] tmp = new int[4];
StringTokenizer st = new StringTokenizer(ro, ",");
int i = 0;
while (st.HasMoreTokens())
{
string s = st.NextToken().Trim();
if (Runtime.EqualsIgnoreCase(s, "LMHOSTS"))
{
tmp[i++] = ResolverLmhosts;
}
else
{
if (Runtime.EqualsIgnoreCase(s, "WINS"))
{
if (nbns == null)
{
if (_log.Level > 1)
{
_log.WriteLine(
"UniAddress resolveOrder specifies WINS however the "
+ "jcifs.netbios.wins property has not been set");
}
continue;
}
tmp[i++] = ResolverWins;
}
else
{
if (Runtime.EqualsIgnoreCase(s, "BCAST"))
{
tmp[i++] = ResolverBcast;
}
else
{
if (Runtime.EqualsIgnoreCase(s, "DNS"))
{
tmp[i++] = ResolverDns;
}
else
{
if (_log.Level > 1)
{
_log.WriteLine("unknown resolver method: " + s);
}
}
}
}
}
}
_resolveOrder = new int[i];
Array.Copy(tmp, 0, _resolveOrder, 0, i);
}
}
internal class Sem
{
internal Sem(int count)
{
this.Count = count;
}
internal int Count;
}
internal class QueryThread : Thread
{
internal Sem Sem;
internal string Host;
internal string Scope;
internal int Type;
internal NbtAddress[] Ans;
internal IPAddress Svr;
internal UnknownHostException Uhe;
internal QueryThread(Sem sem,
string host,
int type,
string scope,
IPAddress svr)
: base("JCIFS-QueryThread: " + host)
{
this.Sem = sem;
this.Host = host;
this.Type = type;
this.Scope = scope;
this.Svr = svr;
}
public override void Run()
{
try
{
//Ans = new [] { NbtAddress.GetByName(Host, Type, Scope, Svr) };
Ans = NbtAddress.GetAllByName(Host, Type, Scope, Svr);
}
catch (UnknownHostException uhe)
{
this.Uhe = uhe;
}
catch (Exception ex)
{
Uhe = new UnknownHostException(ex.Message);
}
finally
{
lock (Sem)
{
Sem.Count--;
Runtime.Notify(Sem);
}
}
}
}
/// <exception cref="UnknownHostException"></exception>
internal static NbtAddress[] LookupServerOrWorkgroup(string name, IPAddress svr)
{
Sem sem = new Sem(2);
int type = NbtAddress.IsWins(svr) ? unchecked(0x1b) : unchecked(0x1d);
QueryThread q1X = new QueryThread(sem, name, type, null, svr);
QueryThread q20 = new QueryThread(sem, name, unchecked(0x20), null, svr);
q1X.SetDaemon(true);
q20.SetDaemon(true);
try
{
lock (sem)
{
q1X.Start();
q20.Start();
while (sem.Count > 0 && q1X.Ans == null && q20.Ans == null)
{
Runtime.Wait(sem);
}
}
}
catch (Exception)
{
throw new UnknownHostException(name);
}
if (q1X.Ans != null)
{
return q1X.Ans;
}
if (q20.Ans != null)
{
return q20.Ans;
}
throw q1X.Uhe;
}
/// <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
/// machine name like "jcifs.samba.org", or an IP address like "192.168.1.15".
/// </remarks>
/// <param name="hostname">NetBIOS or DNS hostname to resolve</param>
/// <exception cref="UnknownHostException">if there is an error resolving the name
/// </exception>
public static UniAddress GetByName(string hostname)
{
return GetByName(hostname, false);
}
internal static bool IsDotQuadIp(string hostname)
{
if (char.IsDigit(hostname[0]))
{
int i;
int len;
int dots;
char[] data;
i = dots = 0;
len = hostname.Length;
data = hostname.ToCharArray();
while (i < len && char.IsDigit(data[i++]))
{
if (i == len && dots == 3)
{
// probably an IP address
return true;
}
if (i < len && data[i] == '.')
{
dots++;
i++;
}
}
}
return false;
}
internal static bool IsAllDigits(string hostname)
{
for (int i = 0; i < hostname.Length; i++)
{
if (char.IsDigit(hostname[i]) == false)
{
return false;
}
}
return true;
}
/// <summary>Lookup <tt>hostname</tt> and return it's <tt>UniAddress</tt>.</summary>
/// <remarks>
/// Lookup <tt>hostname</tt> and return it's <tt>UniAddress</tt>. If the
/// <tt>possibleNTDomainOrWorkgroup</tt> parameter is <tt>true</tt> an
/// addtional name query will be performed to locate a master browser.
/// </remarks>
/// <exception cref="UnknownHostException"></exception>
public static UniAddress GetByName(string hostname, bool possibleNtDomainOrWorkgroup)
{
UniAddress[] addrs = GetAllByName(hostname,
possibleNtDomainOrWorkgroup);
return addrs[0];
}
/// <exception cref="UnknownHostException"></exception>
public static UniAddress[] GetAllByName(string hostname, bool possibleNtDomainOrWorkgroup)
{
object addr;
int i;
if (string.IsNullOrEmpty(hostname))
{
throw new UnknownHostException();
}
if (IsDotQuadIp(hostname))
{
UniAddress[] addrs = new UniAddress[1];
addrs[0] = new UniAddress(NbtAddress.GetByName(hostname));
return addrs;
}
for (i = 0; i < _resolveOrder.Length; i++)
{
try
{
switch (_resolveOrder[i])
{
case ResolverLmhosts:
{
if ((addr = Lmhosts.GetByName(hostname)) == null)
{
continue;
}
break;
}
case ResolverWins:
{
if (hostname == NbtAddress.MasterBrowserName
|| hostname.Length > 15)
{
// invalid netbios name
continue;
}
if (possibleNtDomainOrWorkgroup)
{
addr = LookupServerOrWorkgroup(hostname,
NbtAddress.GetWinsAddress());
}
else
{
addr = NbtAddress.GetByName(hostname,
unchecked(0x20),
null,
NbtAddress.GetWinsAddress());
}
break;
}
case ResolverBcast:
{
if (hostname.Length > 15)
{
// invalid netbios name
continue;
}
try
{
if (possibleNtDomainOrWorkgroup)
{
NbtAddress[] iaddrs = LookupServerOrWorkgroup(hostname,
_baddr);
UniAddress[] addrs = new UniAddress[iaddrs.Length];
for (int ii = 0; ii < iaddrs.Length; ii++)
{
addrs[ii] = new UniAddress(iaddrs[ii]);
}
return addrs;
}
else
{
addr = NbtAddress.GetByName(hostname,
unchecked(0x20),
null,
_baddr);
}
}
catch (Exception ex)
{
if (i == _resolveOrder.Length - 1)
{
throw ex;
}
else
{
continue;
}
}
break;
}
case ResolverDns:
{
if (IsAllDigits(hostname))
{
throw new UnknownHostException(hostname);
}
IPAddress[] iaddrs = Extensions.GetAddressesByName(hostname);
if (iaddrs == null || iaddrs.Length == 0)
{
continue;
}
return iaddrs.Select(iaddr => new UniAddress(iaddr)).ToArray();
}
default:
{
// Success
throw new UnknownHostException(hostname);
}
}
UniAddress[] addrs1 = new UniAddress[1];
addrs1[0] = new UniAddress(addr);
return addrs1;
}
catch (IOException)
{
}
}
// Success
// Failure
throw new UnknownHostException(hostname);
}
internal object Addr;
internal string CalledName;
/// <summary>
/// Create a <tt>UniAddress</tt> by wrapping an <tt>InetAddress</tt> or
/// <tt>NbtAddress</tt>.
/// </summary>
/// <remarks>
/// Create a <tt>UniAddress</tt> by wrapping an <tt>InetAddress</tt> or
/// <tt>NbtAddress</tt>.
/// </remarks>
public UniAddress(object addr)
{
if (addr == null)
{
throw new ArgumentException();
}
this.Addr = addr;
}
/// <summary>Return the IP address of this address as a 32 bit integer.</summary>
/// <remarks>Return the IP address of this address as a 32 bit integer.</remarks>
public override int GetHashCode()
{
return Addr.GetHashCode();
}
/// <summary>Compare two addresses for equality.</summary>
/// <remarks>
/// Compare two addresses for equality. Two <tt>UniAddress</tt>s are equal
/// if they are both <tt>UniAddress</tt>' and refer to the same IP address.
/// </remarks>
public override bool Equals(object obj)
{
return obj is UniAddress && Addr.Equals(((UniAddress)obj).Addr);
}
/// <summary>Guess first called name to try for session establishment.</summary>
/// <remarks>
/// Guess first called name to try for session establishment. This
/// method is used exclusively by the <tt>jcifs.smb</tt> package.
/// </remarks>
public virtual string FirstCalledName()
{
if (Addr is NbtAddress)
{
return ((NbtAddress)Addr).FirstCalledName();
}
CalledName = ((IPAddress)Addr).GetHostAddress();
if (IsDotQuadIp(CalledName))
{
CalledName = NbtAddress.SmbserverName;
}
else
{
int i = CalledName.IndexOf('.');
if (i > 1 && i < 15)
{
CalledName = Runtime.Substring(CalledName, 0, i).ToUpper();
}
else
{
if (CalledName.Length > 15)
{
CalledName = NbtAddress.SmbserverName;
}
else
{
CalledName = CalledName.ToUpper();
}
}
}
return CalledName;
}
/// <summary>Guess next called name to try for session establishment.</summary>
/// <remarks>
/// Guess next called name to try for session establishment. This
/// method is used exclusively by the <tt>jcifs.smb</tt> package.
/// </remarks>
public virtual string NextCalledName()
{
if (Addr is NbtAddress)
{
return ((NbtAddress)Addr).NextCalledName();
}
if (CalledName != NbtAddress.SmbserverName)
{
CalledName = NbtAddress.SmbserverName;
return CalledName;
}
return null;
}
/// <summary>Return the underlying <tt>NbtAddress</tt> or <tt>InetAddress</tt>.</summary>
/// <remarks>Return the underlying <tt>NbtAddress</tt> or <tt>InetAddress</tt>.</remarks>
public virtual object GetAddress()
{
return Addr;
}
/// <summary>Return the hostname of this address such as "MYCOMPUTER".</summary>
/// <remarks>Return the hostname of this address such as "MYCOMPUTER".</remarks>
public virtual string GetHostName()
{
if (Addr is NbtAddress)
{
return ((NbtAddress)Addr).GetHostName();
}
return ((IPAddress)Addr).GetHostAddress();
}
/// <summary>Return the IP address as text such as "192.168.1.15".</summary>
/// <remarks>Return the IP address as text such as "192.168.1.15".</remarks>
public virtual string GetHostAddress()
{
if (Addr is NbtAddress)
{
return ((NbtAddress)Addr).GetHostAddress();
}
return ((IPAddress)Addr).GetHostAddress();
}
public virtual IPAddress GetHostIpAddress()
{
return (IPAddress)Addr;
}
/// <summary>
/// Return the a text representation of this address such as
/// <tt>MYCOMPUTER/192.168.1.15</tt>.
/// </summary>
/// <remarks>
/// Return the a text representation of this address such as
/// <tt>MYCOMPUTER/192.168.1.15</tt>.
/// </remarks>
public override string ToString()
{
return Addr.ToString();
}
}
}