public void ServiceResolved
(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String fullName,
String hostName,
ushort port,
TXTRecord txtRecord
)
{
ResolveData data = new ResolveData();
data.InterfaceIndex = ifIndex;
data.FullName = fullName;
data.HostName = hostName;
data.Port = port;
data.TxtRecord = txtRecord;
//
// Don't forget to stop the resolver. This eases the burden on the network
//
resolver.Stop();
resolver = null;
Populate((BrowseData)browseList.SelectedItem, data);
}
public void ServiceLost
(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain
)
{
int index = browseList.Items.IndexOf(serviceName);
//
// See above comment in ServiceFound about reference counting
//
if (index != -1)
{
BrowseData data = (BrowseData)browseList.Items[index];
data.Refs--;
if (data.Refs == 0)
{
browseList.Items.Remove(data);
browseList.Invalidate();
}
}
}
static public void Start(string service_name, ushort port)
{
try
{
if (!Settings.Default.Run)
{
return;
}
Stop();
Name = service_name;
Port = port;
service = new DNSSDService();
var bs = BitConverter.GetBytes(port);
Array.Reverse(bs);
port = BitConverter.ToUInt16(bs, 0);
if (null == service.Register(0, 0, Name, "_cisterarb._tcp", null, null, Port, null, eventManager))
{
throw new Exception("Register returned NULL.");
}
}
catch (Exception e)
{
Message.Error("Bonjour Service is not available: " + e.Message);
Application.Exit();
}
}
public void ServiceLost(DNSSDService service, DNSSDFlags flags, uint ifIndex, String serviceName, String regType,
String domain)
{
string fullname = serviceName + "." + regType + domain;
base.remove(fullname);
}
private void M_eventManager_QueryRecordAnswered(DNSSDService service, DNSSDFlags flags, uint ifIndex, string fullname, DNSSDRRType rrtype, DNSSDRRClass rrclass, object rdata, uint ttl)
{
if (rdata is byte[])
{
IPAddress addr = new IPAddress(rdata as byte[]);
}
}
ServiceResolved
(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String fullName,
String hostName,
ushort port,
TXTRecord txtRecord
)
{
m_resolver.Stop();
m_resolver = null;
PeerData peer = (PeerData)comboBox1.SelectedItem;
peer.Port = port;
try
{
m_resolver = m_service.QueryRecord(0, ifIndex, hostName, DNSSDRRType.kDNSSDType_A, DNSSDRRClass.kDNSSDClass_IN, m_eventManager);
}
catch
{
MessageBox.Show("QueryRecord Failed", "Error");
Application.Exit();
}
}
public void ServiceResolved(DNSSDService sref, DNSSDFlags flags, uint ifIndex, string serviceName, string hostName, ushort port, TXTRecord txtRecord)
{
var comm = foundComms.SingleOrDefault(r => r.NetworkResolverInfo.Resolver == sref);
comm.NetworkResolverInfo.InterfaceIndex = ifIndex;
comm.NetworkResolverInfo.HostName = hostName;
comm.NetworkResolverInfo.Port = port;
if (txtRecord != null)
{
try
{
comm.NetworkResolverInfo.DeviceName = Encoding.ASCII.GetString((byte[])txtRecord.GetValueForKey(DeviceNameKey));
comm.NetworkResolverInfo.SerialNumber = Encoding.ASCII.GetString((byte[])txtRecord.GetValueForKey(SerialNumberKey));
}
catch (Exception e)
{
//Log.Error("Error reading address info", e);
}
}
(comm.NetworkResolverInfo.Resolver as DNSSDService).Stop();
comm.NetworkResolverInfo.Resolver = sref.GetAddrInfo(flags, ifIndex, DNSSDAddressFamily.kDNSSDAddressFamily_IPv4, hostName, this.eventManager);
}
ServiceRegistered
(
DNSSDService service,
DNSSDFlags flags,
String name,
String regType,
String domain
)
{
m_name = name;
try
{
m_browser = m_service.Browse(0, 0, "_p2pchat._udp", null, m_eventManager);
}
catch
{
MessageBox.Show("Browse Failed", "Error");
Application.Exit();
}
}
void ReadService()
{
strRoutine = this.Name + "; " + MethodBase.GetCurrentMethod().Name + "; ";
try
{
dataGridView1.DataSource = null;
//Sharvari:15/03/2019
dataGridView1.Rows.Clear();
dataGridView1.ColumnCount = 4;
dataGridView1.Columns[0].Name = "MAC";
dataGridView1.Columns[1].Name = "MACHost";
dataGridView1.Columns[2].Name = "Host Name";
dataGridView1.Columns[3].Name = "IP";
DNSSDService service = new DNSSDService();
DNSSDEventManager eventManager = new DNSSDEventManager();
//**********ServiceFound************//
eventManager.ServiceFound += new _IDNSSDEvents_ServiceFoundEventHandler(eventManager_ServiceFound);
// DNSSDService browse = service.Browse(0, 0, "_axis-video._tcp", null, eventManager);
//DNSSDService browser = service.Browse(0, 0, "_http._tcp", null, eventManager);
DNSSDService browser1 = service.Browse(0, 0, "_Workstation._tcp", "local.", eventManager);
DNSSDRecord records = new DNSSDRecord();
//Application.EnableVisualStyles();
//Application.SetCompatibleTextRenderingDefault(false);
//Application.Run(new frmBonjour());
}
catch (Exception ex)
{
csLog.LogError(strRoutine + ex.Message);
}
}
QueryAnswered
(
DNSSDService service,
DNSSDFlags flags,
uint ifIndex,
String fullName,
DNSSDRRType rrtype,
DNSSDRRClass rrclass,
Object rdata,
uint ttl
)
{
//
// Stop the resolve to reduce the burden on the network
//
m_resolver.Stop();
m_resolver = null;
PeerData peer = (PeerData)comboBox1.SelectedItem;
uint bits = BitConverter.ToUInt32((Byte[])rdata, 0);
System.Net.IPAddress address = new System.Net.IPAddress(bits);
peer.Address = address;
}
ServiceFound
(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain
)
{
if (serviceName != m_name)
{
PeerData peer = new PeerData();
peer.InterfaceIndex = ifIndex;
peer.Name = serviceName;
peer.Type = regType;
peer.Domain = domain;
peer.Address = null;
comboBox1.Items.Add(peer);
if (comboBox1.Items.Count == 1)
{
comboBox1.SelectedIndex = 0;
}
}
}
public void ServiceResolved(DNSSDService service,
DNSSDFlags flags,
uint ifIndex,
String fullName,
String hostName,
ushort port,
TXTRecord txtRecord)
{
String user = null;
String password = null;
String path = null;
if (txtRecord.ContainsKey("u"))
{
user = txtRecord.GetValueForKey("u").ToString();
}
if (txtRecord.ContainsKey("p"))
{
password = txtRecord.GetValueForKey("p").ToString();
}
if (txtRecord.ContainsKey("path"))
{
path = txtRecord.GetValueForKey("path").ToString();
}
base.add(fullName, hostName, port, user, password, path);
service.Stop();
}
public void OperationFailed
(
DNSSDService sref,
DNSSDError error
)
{
MessageBox.Show("Operation failed: error code: " + error, "Error");
}
private void M_eventManager_ServiceFound(DNSSDService browser, DNSSDFlags flags, uint ifIndex, string serviceName, string regtype, string domain)
{
Program.logIt($"serviceName={serviceName}");
if (string.Compare("mywebservice", serviceName) == 0)
{
m_service.Resolve(0, ifIndex, serviceName, regtype, domain, m_eventManager);
}
}
OperationFailed
(
DNSSDService service,
DNSSDError error
)
{
MessageBox.Show("Operation returned an error code " + error, "Error");
}
//
// ServiceFound
//
// This call is invoked by the DNSService core. We create
// a BrowseData object and invoked the appropriate method
// in the GUI thread so we can update the UI
//
public void ServiceFound(DNSSDService service,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain)
{
service.Resolve(flags, ifIndex, serviceName, regType, domain, eventManager);
}
private void ServiceFound(DNSSDService browser, DNSSDFlags flags, uint ifIndex, string serviceName, string regType, string domain)
{
Log("Service " + serviceName + " found ");
try {
DNSSDService resolver = browser.Resolve(0, ifIndex, serviceName, regType, domain, eventManager);
resolvers.Add(resolver, serviceName);
} catch {
Log("DNSSDService.Resolve() failed");
}
}
private void Btn_Refresh_Click(object sender, EventArgs e)
{
//Sharvari:15/03/2019
dtMain.Clear();
dataGridView1.DataSource = null;
dgvOpenProBrowser.DataSource = null;
DNSSDService service = new DNSSDService();
ReadService();
timer1.Enabled = true;
}
private void EventManager_AddressFound(DNSSDService service, DNSSDFlags flags, uint ifIndex, string hostname, DNSSDAddressFamily addressFamily, string address, uint ttl)
{
var comm = foundComms.SingleOrDefault(r => r.NetworkResolverInfo.Resolver == service);
if (comm != null)
{
comm.NetworkResolverInfo.IpAddress = address;
comm.NetworkResolverInfo.Active = true;
(comm.NetworkResolverInfo.Resolver as DNSSDService).Stop();
comm.NetworkResolverInfo.Resolver = null;
}
}
public override void init()
{
_eventManager = new DNSSDEventManager();
_eventManager.ServiceFound += ServiceFound;
_eventManager.ServiceLost += ServiceLost;
_eventManager.ServiceResolved += ServiceResolved;
_eventManager.OperationFailed += OperationFailed;
_service = new DNSSDService();
for (int i = 0; i < getServiceTypes().Length; i++)
{
_browsers.Add(getServiceTypes()[i], _service.Browse(0, 0, getServiceTypes()[i], null, _eventManager));
}
}
private void ServiceResolved(DNSSDService resolver, DNSSDFlags flags, uint ifIndex, string fullName, string hostName, ushort port, TXTRecord txtRecord)
{
Log("Service " + hostName + ":" + port + " resolved");
resolver.Stop();
string serviceName = resolvers[resolver];
Server server = new Server(serviceName, hostName, port, this);
Mutex.WaitOne();
servers.Add(server);
resolvers.Remove(resolver);
ServerAdded?.Invoke(server);
Mutex.ReleaseMutex();
}
public override void init()
{
eventManager = new DNSSDEventManager();
eventManager.ServiceFound += ServiceFound;
eventManager.ServiceLost += ServiceLost;
eventManager.ServiceResolved += ServiceResolved;
eventManager.OperationFailed += OperationFailed;
service = new DNSSDService();
for (int i = 0; i < getServiceTypes().Length; i++)
{
browsers.Add(getServiceTypes()[i], service.Browse(0, 0, getServiceTypes()[i], null, eventManager));
}
}
public Client()
{
Log("Client started ");
eventManager.ServiceFound += new _IDNSSDEvents_ServiceFoundEventHandler(ServiceFound);
eventManager.ServiceLost += new _IDNSSDEvents_ServiceLostEventHandler(ServiceLost);
eventManager.ServiceResolved += new _IDNSSDEvents_ServiceResolvedEventHandler(ServiceResolved);
eventManager.OperationFailed += new _IDNSSDEvents_OperationFailedEventHandler(OperationFailed);
try {
browser = service.Browse(0, 0, "_indigo._tcp", null, eventManager);
} catch {
Log("DNSSDService.Browse() failed");
}
}
private void M_eventManager_ServiceResolved(DNSSDService service, DNSSDFlags flags, uint ifIndex, string fullname, string hostname, ushort port, TXTRecord record)
{
Program.logIt($"fullname={fullname}, hostname={hostname}, port={port}");
if (record != null)
{
uint count = record.GetCount();
for (uint i = 0; i < count; i++)
{
string k = record.GetKeyAtIndex(i);
dynamic v = record.GetValueAtIndex(i);
}
}
m_service.QueryRecord(0, ifIndex, hostname, DNSSDRRType.kDNSSDType_A, DNSSDRRClass.kDNSSDClass_IN, m_eventManager);
}
public async override Task <bool> Initialize()
{
this.service = new DNSSDService();
this.eventManager = new DNSSDEventManager();
this.eventManager.ServiceFound += new _IDNSSDEvents_ServiceFoundEventHandler(this.ServiceFound);
this.eventManager.ServiceLost += new _IDNSSDEvents_ServiceLostEventHandler(this.ServiceLost);
this.eventManager.ServiceResolved += new _IDNSSDEvents_ServiceResolvedEventHandler(this.ServiceResolved);
this.eventManager.OperationFailed += new _IDNSSDEvents_OperationFailedEventHandler(this.OperationFailed);
this.eventManager.AddressFound += EventManager_AddressFound;
//NetworkChange.NetworkAddressChanged += OnNetworkAddressChanged;
browser = service.Browse(0, 0, "_Breas._tcp", null, eventManager);
return(true);
}
public void ServiceLost(DNSSDService sref, DNSSDFlags flags, uint ifIndex, string serviceName, string regType, string domain)
{
var itemToRemove = foundComms.SingleOrDefault(r => r.NetworkResolverInfo.Name == serviceName);
if (itemToRemove != null)
{
if (itemToRemove.NetworkResolverInfo.Resolver != null)
{
(itemToRemove.NetworkResolverInfo.Resolver as DNSSDService).Stop();
}
itemToRemove.NetworkResolverInfo.Connected = false;
itemToRemove.NetworkResolverInfo.Active = false;
foundComms.Remove(itemToRemove);
}
}
public BonjourTest(System.Collections.Specialized.StringDictionary args)
{
m_service = new Bonjour.DNSSDService();
m_eventManager = new DNSSDEventManager();
m_eventManager.ServiceFound += M_eventManager_ServiceFound;
m_eventManager.ServiceResolved += M_eventManager_ServiceResolved;
m_eventManager.QueryRecordAnswered += M_eventManager_QueryRecordAnswered;
//m_service.Browse(0, 0, "_p2pchat._udp", null, m_eventManager);
//m_service.Browse(0, 0, "_services._dns-sd._udp", null, m_eventManager);
//m_service.Browse(0, 0, "_airplay._tcp", null, m_eventManager);
m_service.Browse(0, 0, "_http._tcp", null, m_eventManager);
//Task a = Task.Run(()=> { run(); });
this.ThreadExit += BonjourTest_ThreadExit;
}
public void ServiceLost(DNSSDService sref, DNSSDFlags flags, uint ifIndex, string serviceName, string regType, string domain)
{
Log.InfoFormat("Bonjour lost service: serviceName: {0}, domain: {1}, ifIndex: {2}", serviceName, domain, ifIndex);
var itemToRemove = foundComms.SingleOrDefault(r => r.NetworkResolverInfo.Name == serviceName);
if (itemToRemove != null)
{
if (itemToRemove.NetworkResolverInfo.Resolver != null)
{
(itemToRemove.NetworkResolverInfo.Resolver as DNSSDService).Stop();
}
itemToRemove.NetworkResolverInfo.Connected = false;
itemToRemove.NetworkResolverInfo.Active = false;
foundComms.Remove(itemToRemove);
}
}
public void ServiceFound(DNSSDService sref, DNSSDFlags flags, uint ifIndex, string serviceName, string regType, string domain)
{
if (foundComms.Any(r => r.NetworkResolverInfo.Name == serviceName)) //TODO we have an issue with same device discovered many times
{
return;
}
NetworkCommunication comm = new NetworkCommunication(new NetworkResolverInfo());
comm.NetworkResolverInfo.InterfaceIndex = ifIndex;
comm.NetworkResolverInfo.Name = serviceName;
comm.NetworkResolverInfo.Type = regType;
comm.NetworkResolverInfo.Domain = domain;
comm.NetworkResolverInfo.Refs = 1;
comm.NetworkResolverInfo.Connected = true;
foundComms.Add(comm);
comm.NetworkResolverInfo.Resolver = service.Resolve(0, comm.NetworkResolverInfo.InterfaceIndex, comm.NetworkResolverInfo.Name, comm.NetworkResolverInfo.Type, comm.NetworkResolverInfo.Domain, eventManager);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConnectionDialog"/> class.
/// </summary>
public ConnectionDialog()
{
this.InitializeComponent();
this.DataContext = this;
#if USING_BONJOUR
this.eventManager = new DNSSDEventManager();
this.eventManager.ServiceFound += this.ServiceFound;
this.eventManager.ServiceLost += this.ServiceLost;
this.eventManager.ServiceResolved += this.ServiceResolved;
this.eventManager.AddressFound += this.AddressFound;
this.service = new DNSSDService();
this.browser = this.service.Browse(0, 0, RfbType, null, this.eventManager);
#endif
}
static public bool Start(string name, string type, string domain, string host, ushort port)
{
try
{
Stop();
service = new DNSSDService();
//if (null == service.Register(0, 0, Name, "_cisterarb._tcp", null, null, Port, null, eventManager))
if (null == service.Register(0, 0, name, type, domain, host, port, null, eventManager))
{
throw new Exception("Register returned NULL.");
}
return(true);
}
catch (Exception e)
{
Message.Warning("Bonjour Service is not available: " + e.Message);
return(false);
}
}
private void eventManager_AddressFound(DNSSDService service, DNSSDFlags flags, uint ifIndex, string hostname, DNSSDAddressFamily addressFamily, string address, uint ttl)
{
try
{
strRoutine = this.Name + "; " + MethodBase.GetCurrentMethod().Name + "; ";
Console.WriteLine("----------------------------------------");
Console.WriteLine("FOUND ADDRESS");
Console.WriteLine("----------------------------------------");
int pFrom1 = hostname.IndexOf("") + "".Length;
int pTo1 = hostname.LastIndexOf(".l");
String result1 = hostname.Substring(pFrom1, pTo1 - pFrom1);
row = new string[] { "-", hostname, result1, address };
dataGridView1.Rows.Add(row);
}
catch (Exception ex)
{
csLog.LogError(strRoutine + ex.Message);
}
}
public DVBServer()
{
InitializeComponent();
cbDebug.Checked = Properties.Settings.Default.debug;
cbMinimizeOnStart.Checked = Properties.Settings.Default.minimizeOnStart;
cbStartServer.Checked = Properties.Settings.Default.startServer;
recIP = Properties.Settings.Default.recIP;
recPort = Properties.Settings.Default.recPort;
tbPort.Text = Properties.Settings.Default.port;
if (Properties.Settings.Default.startServer)
{
startServer();
}
if (Properties.Settings.Default.minimizeOnStart)
{
WindowState = FormWindowState.Minimized;
Hide();
}
updateDebugDisplay();
/**
* Zeroconf
*/
try
{
mService = new DNSSDService();
}
catch
{
MessageBox.Show("Bonjour Service is not available", "Error");
Application.Exit();
}
mEventManager = new DNSSDEventManager();
mEventManager.ServiceRegistered += new _IDNSSDEvents_ServiceRegisteredEventHandler(this.ServiceRegistered);
}
// QueryAnswered
//
// Called by DNSServices core as a result of DNSService.QueryRecord()
public void QueryAnswered(DNSSDService service, DNSSDFlags flags, uint ifIndex, String fullName, DNSSDRRType rrtype, DNSSDRRClass rrclass, Object rdata, uint ttl)
{
m_resolver.Stop();
m_resolver = null;
PeerData peer = this.selectedPeer;
uint bits = BitConverter.ToUInt32((Byte[])rdata, 0);
System.Net.IPAddress address = new System.Net.IPAddress(bits);
peer.Address = address;
try
{
IPEndPoint ipe = new IPEndPoint(address, peer.Port);
m_socket.Connect(ipe);
m_socket.BeginReceive(m_buffer, 0, BUFFER_SIZE, 0, new AsyncCallback(this.OnReadSocket), this);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
}
}
/// <summary>Handles the user clicking the refresh button</summary>
/// <param name="sender">The parameter is not used.</param>
/// <param name="e">The parameter is not used.</param>
private void RefreshClick(object sender, RoutedEventArgs e)
{
#if USING_BONJOUR
if (this.browser != null)
{
this.browser.Stop();
}
Servers.Clear();
this.browser = this.service.Browse(0, 0, RfbType, null, this.eventManager);
#endif
}
private void startServer()
{
tbPort.Enabled = false;
bool error = false;
try
{
port = Convert.ToInt16(tbPort.Text);
}
catch (Exception ex)
{
MessageBox.Show("Bitte Zahl als Port angeben!");
}
try
{
mService = new DNSSDService();
}
catch
{
new BonjourErrorForm().ShowDialog();
Application.Exit();
}
try
{
mRegistrar = mService.Register(0, 0, System.Environment.UserName, "_dvbctrl._tcp", "local", null, (ushort)this.port, null, mEventManager);
}
catch (Exception ex)
{
addLog(ex.Message);
}
if (!error)
{
try
{
runServer.Visible = false;
stopServer.Visible = true;
listener = new MessagingServer(new DVBServiceFactory(this), new MessagingServerConfiguration(new HttpMessageFactory()));
listener.Start(new IPEndPoint(IPAddress.Any, port));
addLog("Server running on Port " + port.ToString() + "...");
}
catch (Exception ex)
{
addLog(ex.Message);
}
}
}
void AddressFound(DNSSDService service, DNSSDFlags flags, uint ifIndex, string hostname, DNSSDAddressFamily addressFamily, string address, uint ttl)
{
service.Stop();
DoInvoke(() => SetServerAddress(hostname, address));
}
public void ServiceLost(DNSSDService service,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain)
{
string fullname = serviceName + "." + regType + domain;
base.remove(fullname);
}
public void OperationFailed(DNSSDService service, DNSSDError error)
{
service.Stop();
}
//
// ServiceResolved
//
// Called by DNSServices core as a result of DNSService.Resolve()
// call
//
public void ServiceResolved(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String fullName,
String hostName,
ushort port,
TXTRecord txtRecord
)
{
m_resolver.Stop();
m_resolver = null;
PeerData peer = (PeerData)comboBox1.SelectedItem;
peer.Port = port;
try
{
m_resolver = m_service.QueryRecord(0, ifIndex, hostName, DNSSDRRType.kDNSSDType_A, DNSSDRRClass.kDNSSDClass_IN, m_eventManager );
}
catch
{
MessageBox.Show("QueryRecord Failed", "Error");
Application.Exit();
}
}
public void ServiceRegistered(DNSSDService service, DNSSDFlags flags, String name, String regType, String domain)
{
Logger.Instance.eventLog.WriteEntry("Bonjour service running", EventLogEntryType.Information);
}
//
// QueryAnswered
//
// Called by DNSServices core as a result of DNSService.QueryRecord()
// call
//
public void QueryAnswered(
DNSSDService service,
DNSSDFlags flags,
uint ifIndex,
String fullName,
DNSSDRRType rrtype,
DNSSDRRClass rrclass,
Object rdata,
uint ttl
)
{
m_resolver.Stop();
m_resolver = null;
PeerData peer = (PeerData) comboBox1.SelectedItem;
uint bits = BitConverter.ToUInt32( (Byte[])rdata, 0);
System.Net.IPAddress address = new System.Net.IPAddress(bits);
peer.Address = address;
}
//
// ServiceLost
//
// Called by DNSServices core as a result of a Browse call
//
public void ServiceLost(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain
)
{
PeerData peer = new PeerData();
peer.InterfaceIndex = ifIndex;
peer.Name = serviceName;
peer.Type = regType;
peer.Domain = domain;
peer.Address = null;
comboBox1.Items.Remove(peer);
}
void ServiceFound(DNSSDService browser, DNSSDFlags flags, uint ifIndex, string serviceName, string regtype, string domain)
{
var resolver = service.Resolve(flags, ifIndex, serviceName, regtype, domain, this.eventManager);
this.inProgress.Add(resolver, serviceName);
}
void ServiceLost(DNSSDService browser, DNSSDFlags flags, uint ifIndex, string serviceName, string regtype, string domain)
{
DoInvoke(() => RemoveServer(serviceName));
}
void ServiceResolved(DNSSDService resolver, DNSSDFlags flags, uint ifIndex, string fullname, string hostname, ushort port, TXTRecord record)
{
var info = new ServerInfo
{
Index = (int)ifIndex,
FullName = fullname,
HostName = hostname,
Port = port
};
if (this.inProgress.ContainsKey(resolver))
{
info.Name = this.inProgress[resolver];
this.inProgress.Remove(resolver);
}
resolver.Stop();
this.service.GetAddrInfo(
flags,
ifIndex,
DNSSDAddressFamily.kDNSSDAddressFamily_IPv4,
hostname,
this.eventManager);
DoInvoke(() => Servers.Add(info));
}
public void ServiceResolved(DNSSDService service,
DNSSDFlags flags,
uint ifIndex,
String fullName,
String hostName,
ushort port,
TXTRecord txtRecord)
{
String user = null;
String password = null;
String path = null;
if (txtRecord.ContainsKey("u"))
{
user = ByteArrayToString((byte[]) txtRecord.GetValueForKey("u"));
}
if (txtRecord.ContainsKey("p"))
{
password = ByteArrayToString((byte[]) txtRecord.GetValueForKey("p"));
}
if (txtRecord.ContainsKey("path"))
{
path = ByteArrayToString((byte[]) txtRecord.GetValueForKey("path"));
}
base.add(fullName, hostName, port, user, password, path);
service.Stop();
}
// callback from browse
// params service discovery ref, status flags, interface index, error code ?, service name,
// registration type, domain, context=null
public void ServiceFound(DNSSDService sref, DNSSDFlags flags, uint ifIndex, String serviceName,
String regType, String domain)
{
m_browser.Stop();
m_eventManager.ServiceFound -= new _IDNSSDEvents_ServiceFoundEventHandler(ServiceFound);
m_eventManager.ServiceResolved += new _IDNSSDEvents_ServiceResolvedEventHandler(ServiceResolved);
try
{
m_resolver = m_service.Resolve(0, ifIndex, serviceName, regType, domain, m_eventManager);
}
catch
{
log("Unable to Resolve service");
Thread.Sleep(1000);
// tidy up
m_eventManager.ServiceResolved -= new _IDNSSDEvents_ServiceResolvedEventHandler(ServiceResolved);
Application.Exit();
}
}
public void OperationFailed(
DNSSDService service,
DNSSDError error
)
{
MessageBox.Show("Operation returned an error code " + error, "Error");
}
//
// ServiceFound
//
// This call is invoked by the DNSService core. We create
// a BrowseData object and invoked the appropriate method
// in the GUI thread so we can update the UI
//
public void ServiceFound(DNSSDService service,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain)
{
service.Resolve(flags, ifIndex, serviceName, regType, domain, _eventManager);
}
//
// ServiceFound
//
// Called by DNSServices core as a result of a Browse call
//
public void ServiceFound(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain
)
{
if (serviceName != m_name)
{
PeerData peer = new PeerData();
peer.InterfaceIndex = ifIndex;
peer.Name = serviceName;
peer.Type = regType;
peer.Domain = domain;
peer.Address = null;
comboBox1.Items.Add(peer);
if (comboBox1.Items.Count == 1)
{
comboBox1.SelectedIndex = 0;
}
}
}
//
// ServiceFound
//
// This call is invoked by the DNSService core. We create
// a BrowseData object and invoked the appropriate method
// in the GUI thread so we can update the UI
//
public void ServiceFound(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain
)
{
int index = browseList.Items.IndexOf(serviceName);
//
// Check to see if we've seen this service before. If the machine has multiple
// interfaces, we could potentially get called back multiple times for the
// same service. Implementing a simple reference counting scheme will address
// the problem of the same service showing up more than once in the browse list.
//
if (index == -1)
{
BrowseData data = new BrowseData();
data.InterfaceIndex = ifIndex;
data.Name = serviceName;
data.Type = regType;
data.Domain = domain;
data.Refs = 1;
browseList.Items.Add(data);
browseList.Invalidate();
}
else
{
BrowseData data = (BrowseData) browseList.Items[index];
data.Refs++;
}
}
// ServiceRegistered
//
// Called by DNSServices core as a result of Register()
// call
//
public void ServiceRegistered(
DNSSDService service,
DNSSDFlags flags,
String name,
String regType,
String domain
)
{
m_name = name;
try
{
m_browser = m_service.Browse(0, 0, "_p2pchat._udp", null, m_eventManager);
}
catch
{
MessageBox.Show("Browse Failed", "Error");
Application.Exit();
}
}
public void ServiceLost(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain
)
{
int index = browseList.Items.IndexOf(serviceName);
//
// See above comment in ServiceFound about reference counting
//
if (index != -1)
{
BrowseData data = (BrowseData) browseList.Items[index];
data.Refs--;
if (data.Refs == 0)
{
browseList.Items.Remove(data);
browseList.Invalidate();
}
}
}
public void ServiceResolved(DNSSDService sref, DNSSDFlags flags, uint ifIndex, String fullName, String hostName, ushort port, TXTRecord txtRecord)
{
m_resolver.Stop();
m_eventManager.ServiceResolved -= new _IDNSSDEvents_ServiceResolvedEventHandler(ServiceResolved);
try
{
// connect to server
int i = 0;
IPAddress[] ipa = Dns.GetHostAddresses(hostName);
for (i = 0; i < ipa.Length; i++)
{
if (!(ipa[i].IsIPv6LinkLocal || ipa[i].IsIPv6SiteLocal || ipa[i].IsIPv6Multicast))
break;
}
IPEndPoint ep = new IPEndPoint(ipa[i], port);
skt.Connect(ep);
byte[] buffer = new byte[12];
skt.Receive(buffer);
if ((buffer[1] << 8) + buffer[2] == NODENUMBER)
{
nodenumber = ((long)buffer[3] << 40) + ((long)buffer[4] << 32) + (buffer[5] << 24) + (buffer[6] << 16)
+ (buffer[7] << 8) + buffer[8];
}
else
{
return;
}
skt.BeginReceive(inputbuffer, 0, 2000, SocketFlags.None, (AsyncCallback)InputTask, skt);
serverconnected = true;
SendHexString(INITCOMPLETE + nodenumber.ToString("X12") + nodenumber.ToString("X12"));
}
catch
{
}
}
public void ServiceResolved(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String fullName,
String hostName,
ushort port,
TXTRecord txtRecord
)
{
ResolveData data = new ResolveData();
data.InterfaceIndex = ifIndex;
data.FullName = fullName;
data.HostName = hostName;
data.Port = port;
data.TxtRecord = txtRecord;
//
// Don't forget to stop the resolver. This eases the burden on the network
//
resolver.Stop();
resolver = null;
Populate((BrowseData) browseList.SelectedItem, data);
}
public void OperationFailed(DNSSDService service, DNSSDError err)
{
m_error = err;
if (err == DNSSDError.kDNSSDError_NameConflict)
log("Bonjour error, Hub service already started.");
else
log("Bonjour error " + err);
}
public void OperationFailed(
DNSSDService sref,
DNSSDError error
)
{
MessageBox.Show("Operation failed: error code: " + error, "Error");
}
public void ServiceResolved(DNSSDService sref, DNSSDFlags flags, uint ifIndex, String fullName,
String hostName, ushort port, TXTRecord txtRecord)
{
m_resolver.Stop();
m_eventManager.ServiceResolved -= new _IDNSSDEvents_ServiceResolvedEventHandler(ServiceResolved);
log("OpenLCB service on " + hostName + ":" + port.ToString());
try
{
// connect to server
int i = 0;
IPAddress[] ipa = Dns.GetHostAddresses(hostName);
for (i = 0; i < ipa.Length; i++)
{
if (ipa[i].AddressFamily == AddressFamily.InterNetwork)
break;
}
IPEndPoint ep = new IPEndPoint(ipa[i], port);
connects[0].skt.Connect(ep);
connects[0].inuse = true;
byte[] buffer = new byte[12];
connects[0].skt.Receive(buffer);
if ((buffer[1] << 8) + buffer[2] == NODENUMBER)
{
connects[0].nodenumber = ((long)buffer[3] << 40) + ((long)buffer[4] << 32) + (buffer[5] << 24)
+ (buffer[6] << 16) + (buffer[7] << 8) + buffer[8];
log("OpenLCB Node Number " + connects[0].nodenumber.ToString("X12"));
}
else
{
log("No node number allocated.");
return;
}
while (true)
{
int size = connects[0].skt.Receive(connects[0].buffer);
if (size == 0)
break;
if (LogCB.Checked)
{
string l = "";
for (i = 0; i < size; i++)
l += connects[0].buffer[i].ToString("X2");
log("< (" + 0.ToString() + ") " + l);
}
int p = 0;
while (p < size)
{
connects[0].UpdateFilters(connects[0].buffer, p, localhub);
SendToAll(connects[0].buffer, p, 0);
p += connects[0].buffer[p];
}
} // end of while true
}
catch (Exception e)
{
log("OpenLCB server connection failed " + e.ToString());
}
}
protected override void OnClosed(EventArgs e)
{
base.OnClosed(e);
if (this.browser != null)
{
this.browser.Stop();
this.browser = null;
}
if (this.service != null)
{
this.service.Stop();
this.service = null;
}
if (this.eventManager != null)
{
this.eventManager.ServiceFound -= ServiceFound;
this.eventManager.ServiceLost -= ServiceLost;
this.eventManager.ServiceResolved -= ServiceResolved;
}
}
