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[]);
}
}
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;
}
public void ServiceLost(DNSSDService service, DNSSDFlags flags, uint ifIndex, String serviceName, String regType,
String domain)
{
string fullname = serviceName + "." + regType + domain;
base.remove(fullname);
}
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 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();
}
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 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();
}
}
}
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);
}
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);
}
}
//
// 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 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;
}
}
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();
}
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 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 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);
}
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 void ServiceFound(DNSSDService sref, DNSSDFlags flags, uint ifIndex, string serviceName, string regType, string domain)
{
Log.InfoFormat("Bonjour found service: serviceName: {0}, domain: {1}, ifIndex: {2}", serviceName, domain, ifIndex);
if (foundComms.Any(r => r.NetworkResolverInfo.Name == serviceName))
{
return;
}
V45NetworkCommunication comm = new V45NetworkCommunication(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);
}
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);
}
public void ServiceLost
(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain
)
{
BrowseData data = new BrowseData();
data.InterfaceIndex = ifIndex;
data.Name = serviceName;
data.Type = regType;
data.Domain = domain;
browseList.Items.Remove(data);
browseList.Invalidate();
}
private void ServiceLost(DNSSDService browser, DNSSDFlags flags, uint ifIndex, string serviceName, string regType, string domain)
{
Log("Service " + serviceName + " lost");
Server server = null;
Mutex.WaitOne();
foreach (Server item in servers)
{
if (item.Name == serviceName)
{
server = item;
break;
}
}
if (server != null)
{
servers.Remove(server);
ServerRemoved?.Invoke(server);
}
Mutex.ReleaseMutex();
}
private void EventManager_ServiceResolved(DNSSDService service, DNSSDFlags flags, uint ifIndex, string fullname, string hostname, ushort port, TXTRecord record)
{
try
{
strRoutine = this.Name + "; " + MethodBase.GetCurrentMethod().Name + "; ";
//throw new NotImplementedException();
Console.WriteLine("-------------------eventManager_ServiceResolved---------------------");
Console.WriteLine("DNSSDService " + service + "\nDNSSDFlags " + flags + "\nifindex " + ifIndex + "\nfullname " + fullname + "hostname " + hostname + "\nport " + port + "\nrecord " + record);
//var str = System.Text.Encoding.Default.GetString(record.GetValueForKey("macaddress"));
//Console.WriteLine("mac " + str);
Console.WriteLine("----------------------------------------");
DNSSDEventManager eventManager = new DNSSDEventManager();
//**********AddressFound************//
eventManager.AddressFound += new _IDNSSDEvents_AddressFoundEventHandler(eventManager_AddressFound);
DNSSDAddressFamily family = new DNSSDAddressFamily();
service.GetAddrInfo(flags, ifIndex, family, hostname, eventManager);
}
catch (Exception ex)
{
csLog.LogError(strRoutine + ex.Message);
}
}
// 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);
}
}
//
// 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++;
}
}
void eventManager_ServiceFound(DNSSDService browser1, DNSSDFlags flags, uint ifIndex, string serviceName, string regtype, string domain)
{
strRoutine = this.Name + "; " + MethodBase.GetCurrentMethod().Name + "; ";
try
{
Console.WriteLine("browser: " + browser1 + "\nDNSSDFlags " + flags + "\nifIndex " + ifIndex + "\nserviceName: " + serviceName + "\nregtype: " + regtype + "\ndomain: " + domain);
mac = serviceName;
String St = serviceName;
int pFrom = St.IndexOf("[") + "[".Length;
int pTo = St.LastIndexOf("]");
int pFrom1 = St.IndexOf("") + "".Length;
int pTo1 = St.LastIndexOf("[");
String result = St.Substring(pFrom, pTo - pFrom);
String result1 = St.Substring(pFrom1, pTo1 - pFrom1);
mac = result;
macHost = result1;
row = new string[] { mac, macHost, "-", "-" };
dataGridView1.Rows.Add(row);
DNSSDEventManager eventManager = new DNSSDEventManager();
//**********ServiceResolved************//
eventManager.ServiceResolved += new _IDNSSDEvents_ServiceResolvedEventHandler(EventManager_ServiceResolved);
//eventManager.AddressFound += new _IDNSSDEvents_AddressFoundEventHandler(eventManager_AddressFound);
browser1.Resolve(flags, ifIndex, serviceName, regtype, domain, eventManager);
DNSSDAddressFamily family = new DNSSDAddressFamily();
browser1.GetAddrInfo(flags, ifIndex, family, "", eventManager);
}
catch (Exception ex)
{
csLog.LogError(strRoutine + ex.Message);
}
//var ipAddress = IPMacMapper.FindIPFromMacAddress("mac-address");
}
// ServiceRegistered
//
// Called by DNSServices core as a result of Register()
public void ServiceRegistered(DNSSDService service, DNSSDFlags flags, String name, String regType, String domain)
{
m_name = name;
try
{
m_browser = m_service.Browse(0, 0, regName, null, m_eventManager);
System.Console.WriteLine("Registered as " + m_name + "...");
System.Console.WriteLine("Waiting for a connection...");
}
catch
{
System.Console.WriteLine("Error - Browse Failed");
}
}
// 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;
System.Console.WriteLine("Service Lost - " + peer);
}
// 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();
}
}
// ServiceResolved
//
// Called by DNSServices core as a result of DNSService.Resolve()
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 = this.selectedPeer;
peer.Port = port;
try
{
m_resolver = m_service.QueryRecord(0, ifIndex, hostName, DNSSDRRType.kDNSSDType_A, DNSSDRRClass.kDNSSDClass_IN, m_eventManager);
}
catch
{
System.Console.WriteLine("Error - QueryRecord Failed");
}
}
//
// 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;
}
//
// 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);
}
void AddressFound(DNSSDService service, DNSSDFlags flags, uint ifIndex, string hostname, DNSSDAddressFamily addressFamily, string address, uint ttl)
{
service.Stop();
DoInvoke(() => SetServerAddress(hostname, address));
}
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();
}
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));
}
// 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;
this.selectedPeer = peer;
System.Console.WriteLine("Connected to " + peer + "...");
this.selectNewPeer();
}
}
//
// 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);
}
private static void EventManager_ServiceFound(DNSSDService browser, DNSSDFlags flags, uint ifIndex, string serviceName, string regtype, string domain)
{
throw new NotImplementedException();
}
public void ServiceLost(DNSSDService service,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain)
{
string fullname = serviceName + "." + regType + domain;
base.remove(fullname);
}
//
// 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;
}
}
}
private static void EventManager_ServiceRegistered(DNSSDService service, DNSSDFlags flags, string name, string regtype, string domain)
{
}
// 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();
}
}
//
// 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++;
}
}
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 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 ServiceRegistered(DNSSDService service, DNSSDFlags flags, String name, String regType, String domain)
{
Logger.Instance.eventLog.WriteEntry("Bonjour service running", EventLogEntryType.Information);
}
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 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());
}
}
public void ServiceLost(
DNSSDService sref,
DNSSDFlags flags,
uint ifIndex,
String serviceName,
String regType,
String domain
)
{
BrowseData data = new BrowseData();
data.InterfaceIndex = ifIndex;
data.Name = serviceName;
data.Type = regType;
data.Domain = domain;
browseList.Items.Remove(data);
browseList.Invalidate();
}
