815 lines
28 KiB
C#
815 lines
28 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.Collections.Generic;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using SharpCifs.Smb;
|
|
using SharpCifs.Util;
|
|
using SharpCifs.Util.DbsHelper;
|
|
using SharpCifs.Util.Sharpen;
|
|
|
|
using Thread = SharpCifs.Util.Sharpen.Thread;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace SharpCifs.Netbios
|
|
{
|
|
internal class NameServiceClient : IRunnable
|
|
{
|
|
internal const int DefaultSoTimeout = 5000;
|
|
|
|
internal const int DefaultRcvBufSize = 576;
|
|
|
|
internal const int DefaultSndBufSize = 576;
|
|
|
|
internal const int NameServiceUdpPort = 137;
|
|
|
|
internal const int DefaultRetryCount = 2;
|
|
|
|
internal const int DefaultRetryTimeout = 3000;
|
|
|
|
internal const int ResolverLmhosts = 1;
|
|
|
|
internal const int ResolverBcast = 2;
|
|
|
|
internal const int ResolverWins = 3;
|
|
|
|
private static readonly int SndBufSize
|
|
= Config.GetInt("jcifs.netbios.snd_buf_size", DefaultSndBufSize);
|
|
|
|
private static readonly int RcvBufSize
|
|
= Config.GetInt("jcifs.netbios.rcv_buf_size", DefaultRcvBufSize);
|
|
|
|
private static readonly int SoTimeout
|
|
= Config.GetInt("jcifs.netbios.soTimeout", DefaultSoTimeout);
|
|
|
|
private static readonly int RetryCount
|
|
= Config.GetInt("jcifs.netbios.retryCount", DefaultRetryCount);
|
|
|
|
private static readonly int RetryTimeout
|
|
= Config.GetInt("jcifs.netbios.retryTimeout", DefaultRetryTimeout);
|
|
|
|
private static readonly int Lport
|
|
= Config.GetInt("jcifs.netbios.lport", 137);
|
|
|
|
private static readonly IPAddress Laddr
|
|
= Config.GetInetAddress("jcifs.netbios.laddr", null);
|
|
|
|
private static readonly string Ro
|
|
= Config.GetProperty("jcifs.resolveOrder");
|
|
|
|
private static LogStream _log = LogStream.GetInstance();
|
|
|
|
private readonly object _lock = new object();
|
|
|
|
private int _lport;
|
|
|
|
private int _closeTimeout;
|
|
|
|
private byte[] _sndBuf;
|
|
|
|
private byte[] _rcvBuf;
|
|
|
|
private SocketEx _socketSender;
|
|
|
|
private Hashtable _responseTable = new Hashtable();
|
|
|
|
private Thread _thread;
|
|
|
|
private int _nextNameTrnId;
|
|
|
|
private int[] _resolveOrder;
|
|
|
|
private bool _waitResponse = true;
|
|
|
|
private bool _isActive = false;
|
|
|
|
private AutoResetEvent _autoResetWaitReceive;
|
|
|
|
internal IPAddress laddr;
|
|
|
|
internal IPAddress Baddr;
|
|
|
|
public NameServiceClient()
|
|
: this(Lport, Laddr)
|
|
{
|
|
}
|
|
|
|
internal NameServiceClient(int lport, IPAddress laddr)
|
|
{
|
|
this._lport = lport;
|
|
|
|
this.laddr = laddr
|
|
?? Config.GetLocalHost()
|
|
?? Extensions.GetLocalAddresses()?.FirstOrDefault();
|
|
|
|
if (this.laddr == null)
|
|
throw new ArgumentNullException("IPAddress NOT found. if exec on localhost, set vallue to [jcifs.smb.client.laddr]");
|
|
|
|
try
|
|
{
|
|
Baddr = Config.GetInetAddress("jcifs.netbios.baddr",
|
|
Extensions.GetAddressByName("255.255.255.255"));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
}
|
|
|
|
_sndBuf = new byte[SndBufSize];
|
|
_rcvBuf = new byte[RcvBufSize];
|
|
|
|
|
|
if (string.IsNullOrEmpty(Ro))
|
|
{
|
|
if (NbtAddress.GetWinsAddress() == null)
|
|
{
|
|
_resolveOrder = new int[2];
|
|
_resolveOrder[0] = ResolverLmhosts;
|
|
_resolveOrder[1] = ResolverBcast;
|
|
}
|
|
else
|
|
{
|
|
_resolveOrder = new int[3];
|
|
_resolveOrder[0] = ResolverLmhosts;
|
|
_resolveOrder[1] = ResolverWins;
|
|
_resolveOrder[2] = ResolverBcast;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int[] tmp = new int[3];
|
|
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 (NbtAddress.GetWinsAddress() == null)
|
|
{
|
|
if (_log.Level > 1)
|
|
{
|
|
_log.WriteLine("NetBIOS 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"))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
// skip
|
|
if (_log.Level > 1)
|
|
{
|
|
_log.WriteLine("unknown resolver method: " + s);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_resolveOrder = new int[i];
|
|
Array.Copy(tmp, 0, _resolveOrder, 0, i);
|
|
}
|
|
}
|
|
|
|
internal virtual int GetNextNameTrnId()
|
|
{
|
|
if ((++_nextNameTrnId & unchecked(0xFFFF)) == 0)
|
|
{
|
|
_nextNameTrnId = 1;
|
|
}
|
|
return _nextNameTrnId;
|
|
}
|
|
|
|
/// <exception cref="System.IO.IOException"></exception>
|
|
internal virtual void EnsureOpen(int timeout)
|
|
{
|
|
//Log.Out($"NameServiceClient.EnsureOpen");
|
|
|
|
_closeTimeout = 0;
|
|
if (SoTimeout != 0)
|
|
{
|
|
_closeTimeout = Math.Max(SoTimeout, timeout);
|
|
}
|
|
|
|
var localPort = (SmbConstants.Lport == 0) ? _lport : SmbConstants.Lport;
|
|
|
|
// If socket is still good, the new closeTimeout will
|
|
// be ignored; see tryClose comment.
|
|
if (
|
|
_socketSender == null
|
|
|| _socketSender.LocalEndPoint == null
|
|
|| _socketSender.GetLocalPort() != localPort
|
|
|| !IPAddress.Any.Equals(_socketSender.GetLocalInetAddress())
|
|
)
|
|
{
|
|
if (_socketSender != null)
|
|
{
|
|
_socketSender.Dispose();
|
|
_socketSender = null;
|
|
}
|
|
|
|
_socketSender = new SocketEx(AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
_socketSender.Bind(new IPEndPoint(IPAddress.Any, localPort));
|
|
|
|
|
|
if (_waitResponse)
|
|
{
|
|
if (_thread != null)
|
|
{
|
|
_thread.Cancel(true);
|
|
_thread.Dispose();
|
|
}
|
|
|
|
_thread = new Thread(this);
|
|
_thread.SetDaemon(true);
|
|
_thread.Start(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal virtual void TryClose()
|
|
{
|
|
//Log.Out("NameSerciceClient.TryClose");
|
|
|
|
if (this._isActive)
|
|
{
|
|
//Log.Out("NameSerciceClient.TryClose - Now in Processing... Exit.");
|
|
return;
|
|
}
|
|
|
|
lock (_lock)
|
|
{
|
|
if (_socketSender != null)
|
|
{
|
|
_socketSender.Dispose();
|
|
_socketSender = null;
|
|
//Log.Out("NameSerciceClient.TryClose - _socketSender.Disposed");
|
|
}
|
|
|
|
if (_thread != null)
|
|
{
|
|
_thread.Cancel(true);
|
|
_thread.Dispose();
|
|
_thread = null;
|
|
//Log.Out("NameSerciceClient.TryClose - _thread.Aborted");
|
|
}
|
|
|
|
if (_waitResponse)
|
|
{
|
|
_responseTable.Clear();
|
|
}
|
|
else
|
|
{
|
|
_autoResetWaitReceive.Set();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private int _recievedLength = -1;
|
|
public virtual void Run()
|
|
{
|
|
int nameTrnId;
|
|
NameServicePacket response;
|
|
|
|
try
|
|
{
|
|
while (Thread.CurrentThread().Equals(_thread))
|
|
{
|
|
if (_thread.IsCanceled)
|
|
break;
|
|
|
|
var localPort = (SmbConstants.Lport == 0) ? _lport : SmbConstants.Lport;
|
|
|
|
var sockEvArg = new SocketAsyncEventArgs();
|
|
sockEvArg.RemoteEndPoint = new IPEndPoint(IPAddress.Any, localPort);
|
|
sockEvArg.SetBuffer(_rcvBuf, 0, RcvBufSize);
|
|
sockEvArg.Completed += this.OnReceiveCompleted;
|
|
|
|
_socketSender.SoTimeOut = _closeTimeout;
|
|
|
|
this._recievedLength = -1;
|
|
|
|
//Log.Out($"NameServiceClient.Run - Wait Recieve: {IPAddress.Any}: {localPort}");
|
|
_socketSender.ReceiveFromAsync(sockEvArg);
|
|
|
|
while (this._recievedLength == -1)
|
|
{
|
|
if (_thread.IsCanceled)
|
|
break;
|
|
|
|
Task.Delay(300).GetAwaiter().GetResult();
|
|
}
|
|
|
|
sockEvArg?.Dispose();
|
|
|
|
|
|
if (_thread.IsCanceled)
|
|
break;
|
|
|
|
if (_log.Level > 3)
|
|
{
|
|
_log.WriteLine("NetBIOS: new data read from socket");
|
|
}
|
|
nameTrnId = NameServicePacket.ReadNameTrnId(_rcvBuf, 0);
|
|
response = (NameServicePacket)_responseTable.Get(nameTrnId);
|
|
|
|
|
|
if (response == null || response.Received)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
lock (response)
|
|
{
|
|
if (_thread.IsCanceled)
|
|
break;
|
|
|
|
response.ReadWireFormat(_rcvBuf, 0);
|
|
|
|
if (_log.Level > 3)
|
|
{
|
|
_log.WriteLine(response);
|
|
Hexdump.ToHexdump(_log, _rcvBuf, 0, this._recievedLength);
|
|
}
|
|
|
|
if (response.IsResponse)
|
|
{
|
|
response.Received = true;
|
|
|
|
Runtime.Notify(response);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (TimeoutException) { }
|
|
catch (Exception ex)
|
|
{
|
|
if (_log.Level > 2)
|
|
{
|
|
Runtime.PrintStackTrace(ex, _log);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
TryClose();
|
|
}
|
|
}
|
|
|
|
|
|
private void OnReceiveCompleted(object sender, SocketAsyncEventArgs e)
|
|
{
|
|
//Log.Out("NameServiceClient.OnReceiveCompleted");
|
|
this._recievedLength = e.BytesTransferred;
|
|
}
|
|
|
|
|
|
/// <exception cref="System.IO.IOException"></exception>
|
|
internal virtual void Send(NameServicePacket request,
|
|
NameServicePacket response,
|
|
int timeout)
|
|
{
|
|
//Log.Out("NameSerciceClient.Send - Start");
|
|
|
|
int nid = 0;
|
|
int max = NbtAddress.Nbns.Length;
|
|
if (max == 0)
|
|
{
|
|
max = 1;
|
|
}
|
|
|
|
lock (response)
|
|
{
|
|
this._isActive = true;
|
|
|
|
while (max-- > 0)
|
|
{
|
|
try
|
|
{
|
|
lock (_lock)
|
|
{
|
|
request.NameTrnId = GetNextNameTrnId();
|
|
nid = request.NameTrnId;
|
|
|
|
response.Received = false;
|
|
_responseTable.Put(nid, response);
|
|
|
|
//Log.Out($"NameSerciceClient.Send - timeout = {timeout}");
|
|
EnsureOpen(timeout + 1000);
|
|
|
|
int requestLenght = request.WriteWireFormat(_sndBuf, 0);
|
|
byte[] msg = new byte[requestLenght];
|
|
Array.Copy(_sndBuf, msg, requestLenght);
|
|
|
|
_socketSender.SetSocketOption(SocketOptionLevel.Socket,
|
|
SocketOptionName.Broadcast,
|
|
request.IsBroadcast
|
|
? 1
|
|
: 0);
|
|
|
|
_socketSender.SendTo(msg, new IPEndPoint(request.Addr, _lport));
|
|
//Log.Out("NameSerciceClient.Send - Sended");
|
|
|
|
if (_log.Level > 3)
|
|
{
|
|
_log.WriteLine(request);
|
|
Hexdump.ToHexdump(_log, _sndBuf, 0, requestLenght);
|
|
}
|
|
}
|
|
|
|
if (_waitResponse)
|
|
{
|
|
long start = Runtime.CurrentTimeMillis();
|
|
var isRecieved = false;
|
|
var startTime = DateTime.Now;
|
|
while (timeout > 0)
|
|
{
|
|
Runtime.Wait(response, timeout);
|
|
if (response.Received && request.QuestionType == response.RecordType)
|
|
{
|
|
//return;
|
|
isRecieved = true;
|
|
break;
|
|
}
|
|
response.Received = false;
|
|
timeout -= (int)(Runtime.CurrentTimeMillis() - start);
|
|
|
|
//if (timeout <= 0)
|
|
//{
|
|
// Log.Out($"NameSerciceClient.Send Timeout! - {(DateTime.Now - startTime).TotalMilliseconds} msec");
|
|
//}
|
|
}
|
|
|
|
if (isRecieved)
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception ie)
|
|
{
|
|
if (_waitResponse)
|
|
_responseTable.Remove(nid);
|
|
|
|
//Log.Out("NameSerciceClient.Send - IOException");
|
|
|
|
throw new IOException(ie.Message);
|
|
}
|
|
finally
|
|
{
|
|
if (_waitResponse)
|
|
_responseTable.Remove(nid);
|
|
}
|
|
|
|
if (_waitResponse)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
if (NbtAddress.IsWins(request.Addr) == false)
|
|
{
|
|
break;
|
|
}
|
|
if (request.Addr == NbtAddress.GetWinsAddress())
|
|
{
|
|
NbtAddress.SwitchWins();
|
|
}
|
|
request.Addr = NbtAddress.GetWinsAddress();
|
|
}
|
|
}
|
|
}
|
|
|
|
this._isActive = false;
|
|
//Log.Out("NameSerciceClient.Send - Normaly Ended.");
|
|
}
|
|
}
|
|
|
|
/// <exception cref="UnknownHostException"></exception>
|
|
internal virtual NbtAddress[] GetAllByName(Name name, IPAddress addr)
|
|
{
|
|
//Log.Out("NameSerciceClient.GetAllByName");
|
|
|
|
int n;
|
|
NameQueryRequest request = new NameQueryRequest(name);
|
|
NameQueryResponse response = new NameQueryResponse();
|
|
request.Addr = addr ?? NbtAddress.GetWinsAddress();
|
|
request.IsBroadcast = (request.Addr == null
|
|
|| request.Addr.ToString() == Baddr.ToString());
|
|
|
|
if (request.IsBroadcast)
|
|
{
|
|
request.Addr = Baddr;
|
|
n = RetryCount;
|
|
}
|
|
else
|
|
{
|
|
request.IsBroadcast = false;
|
|
n = 1;
|
|
}
|
|
do
|
|
{
|
|
try
|
|
{
|
|
Send(request, response, RetryTimeout);
|
|
}
|
|
catch (IOException ioe)
|
|
{
|
|
if (_log.Level > 1)
|
|
{
|
|
Runtime.PrintStackTrace(ioe, _log);
|
|
}
|
|
throw new UnknownHostException(ioe);
|
|
}
|
|
if (response.Received && response.ResultCode == 0)
|
|
{
|
|
return response.AddrEntry;
|
|
}
|
|
}
|
|
while (--n > 0 && request.IsBroadcast);
|
|
throw new UnknownHostException();
|
|
}
|
|
|
|
/// <exception cref="UnknownHostException"></exception>
|
|
internal virtual NbtAddress GetByName(Name name, IPAddress addr)
|
|
{
|
|
//Log.Out("NameSerciceClient.GetByName");
|
|
|
|
int n;
|
|
NameQueryRequest request = new NameQueryRequest(name);
|
|
NameQueryResponse response = new NameQueryResponse();
|
|
|
|
if (addr != null)
|
|
{
|
|
request.Addr = addr;
|
|
request.IsBroadcast = (addr.GetAddressBytes()[3] == unchecked(unchecked(0xFF)));
|
|
n = RetryCount;
|
|
do
|
|
{
|
|
try
|
|
{
|
|
Send(request, response, RetryTimeout);
|
|
}
|
|
catch (IOException ioe)
|
|
{
|
|
if (_log.Level > 1)
|
|
{
|
|
Runtime.PrintStackTrace(ioe, _log);
|
|
}
|
|
throw new UnknownHostException(ioe);
|
|
}
|
|
|
|
if (response.Received
|
|
&& response.ResultCode == 0
|
|
&& response.IsResponse)
|
|
{
|
|
int last = response.AddrEntry.Length - 1;
|
|
response.AddrEntry[last].HostName.SrcHashCode = addr.GetHashCode();
|
|
return response.AddrEntry[last];
|
|
}
|
|
}
|
|
|
|
while (--n > 0 && request.IsBroadcast);
|
|
throw new UnknownHostException();
|
|
}
|
|
|
|
for (int i = 0; i < _resolveOrder.Length; i++)
|
|
{
|
|
try
|
|
{
|
|
switch (_resolveOrder[i])
|
|
{
|
|
case ResolverLmhosts:
|
|
{
|
|
NbtAddress ans = Lmhosts.GetByName(name);
|
|
if (ans != null)
|
|
{
|
|
ans.HostName.SrcHashCode = 0;
|
|
// just has to be different
|
|
// from other methods
|
|
return ans;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ResolverWins:
|
|
case ResolverBcast:
|
|
{
|
|
if (_resolveOrder[i] == ResolverWins
|
|
&& name.name != NbtAddress.MasterBrowserName
|
|
&& name.HexCode != unchecked(0x1d))
|
|
{
|
|
request.Addr = NbtAddress.GetWinsAddress();
|
|
request.IsBroadcast = false;
|
|
}
|
|
else
|
|
{
|
|
request.Addr = Baddr;
|
|
request.IsBroadcast = true;
|
|
}
|
|
n = RetryCount;
|
|
while (n-- > 0)
|
|
{
|
|
try
|
|
{
|
|
Send(request, response, RetryTimeout);
|
|
}
|
|
catch (IOException ioe)
|
|
{
|
|
if (_log.Level > 1)
|
|
{
|
|
Runtime.PrintStackTrace(ioe, _log);
|
|
}
|
|
throw new UnknownHostException(ioe);
|
|
}
|
|
if (response.Received
|
|
&& response.ResultCode == 0
|
|
&& response.IsResponse)
|
|
{
|
|
response.AddrEntry[0].HostName.SrcHashCode
|
|
= request.Addr.GetHashCode();
|
|
return response.AddrEntry[0];
|
|
}
|
|
if (_resolveOrder[i] == ResolverWins)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (IOException)
|
|
{
|
|
}
|
|
}
|
|
|
|
throw new UnknownHostException();
|
|
}
|
|
|
|
/// <exception cref="UnknownHostException"></exception>
|
|
internal virtual NbtAddress[] GetNodeStatus(NbtAddress addr)
|
|
{
|
|
//Log.Out("NameSerciceClient.GetNodeStatus");
|
|
|
|
int n;
|
|
int srcHashCode;
|
|
NodeStatusRequest request;
|
|
NodeStatusResponse response;
|
|
response = new NodeStatusResponse(addr);
|
|
request = new NodeStatusRequest(new Name(NbtAddress.AnyHostsName, unchecked(0x00), null));
|
|
request.Addr = addr.GetInetAddress();
|
|
n = RetryCount;
|
|
|
|
while (n-- > 0)
|
|
{
|
|
try
|
|
{
|
|
Send(request, response, RetryTimeout);
|
|
}
|
|
catch (IOException ioe)
|
|
{
|
|
if (_log.Level > 1)
|
|
{
|
|
Runtime.PrintStackTrace(ioe, _log);
|
|
}
|
|
throw new UnknownHostException(ioe);
|
|
}
|
|
if (response.Received && response.ResultCode == 0)
|
|
{
|
|
srcHashCode = request.Addr.GetHashCode();
|
|
for (int i = 0; i < response.AddressArray.Length; i++)
|
|
{
|
|
response.AddressArray[i].HostName.SrcHashCode = srcHashCode;
|
|
}
|
|
return response.AddressArray;
|
|
}
|
|
}
|
|
throw new UnknownHostException();
|
|
}
|
|
|
|
internal virtual NbtAddress[] GetHosts()
|
|
{
|
|
//Log.Out("NbtServiceClient.GetHosts");
|
|
|
|
try
|
|
{
|
|
_waitResponse = false;
|
|
|
|
byte[] bAddrBytes = laddr.GetAddressBytes();
|
|
|
|
for (int i = 1; i <= 254; i++)
|
|
{
|
|
//Log.Out($"NbtServiceClient.GetHosts - {i}");
|
|
|
|
NodeStatusRequest request;
|
|
NodeStatusResponse response;
|
|
|
|
byte[] addrBytes = {
|
|
bAddrBytes[0],
|
|
bAddrBytes[1],
|
|
bAddrBytes[2],
|
|
(byte)i
|
|
};
|
|
|
|
IPAddress addr = new IPAddress(addrBytes);
|
|
|
|
response = new NodeStatusResponse(
|
|
new NbtAddress(NbtAddress.UnknownName,
|
|
BitConverter.ToInt32(addr.GetAddressBytes(), 0),
|
|
false,
|
|
0x20)
|
|
);
|
|
|
|
request = new NodeStatusRequest(new Name(NbtAddress.AnyHostsName,
|
|
unchecked(0x20),
|
|
null))
|
|
{
|
|
Addr = addr
|
|
};
|
|
|
|
Send(request, response, 0);
|
|
}
|
|
}
|
|
catch (IOException ioe)
|
|
{
|
|
//Log.Out(ioe);
|
|
|
|
if (_log.Level > 1)
|
|
{
|
|
Runtime.PrintStackTrace(ioe, _log);
|
|
}
|
|
throw new UnknownHostException(ioe);
|
|
}
|
|
|
|
_autoResetWaitReceive = new AutoResetEvent(false);
|
|
|
|
if (_thread != null)
|
|
{
|
|
_thread.Cancel(true);
|
|
_thread.Dispose();
|
|
}
|
|
|
|
_thread = new Thread(this);
|
|
_thread.SetDaemon(true);
|
|
_thread.Start(true);
|
|
|
|
_autoResetWaitReceive.WaitOne();
|
|
|
|
var result = new List<NbtAddress>();
|
|
|
|
foreach (var key in _responseTable.Keys)
|
|
{
|
|
var resp = (NodeStatusResponse)_responseTable[key];
|
|
|
|
if (!resp.Received || resp.ResultCode != 0)
|
|
continue;
|
|
|
|
result.AddRange(resp.AddressArray
|
|
.Where(entry => entry.HostName.HexCode == 0x20));
|
|
}
|
|
|
|
_responseTable.Clear();
|
|
|
|
_waitResponse = true;
|
|
|
|
return result.Count > 0 ? result.ToArray() : null;
|
|
}
|
|
}
|
|
}
|