/*******************************************************************************
* Copyright (c) 2010 Markus Alexander Kuppe.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Markus Alexander Kuppe (ecf-dev_eclipse.org <at> lemmster <dot> de) - initial API and implementation
******************************************************************************/
package org.eclipse.ecf.provider.dnssd;
import java.io.EOFException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.SortedSet;
import org.eclipse.core.runtime.Assert;
import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.events.ContainerConnectedEvent;
import org.eclipse.ecf.core.events.ContainerConnectingEvent;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDCreateException;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.identity.Namespace;
import org.eclipse.ecf.core.security.IConnectContext;
import org.eclipse.ecf.core.util.Trace;
import org.eclipse.ecf.discovery.DiscoveryContainerConfig;
import org.eclipse.ecf.discovery.IServiceInfo;
import org.eclipse.ecf.discovery.identity.IServiceTypeID;
import org.xbill.DNS.DClass;
import org.xbill.DNS.Lookup;
import org.xbill.DNS.Message;
import org.xbill.DNS.NSRecord;
import org.xbill.DNS.Name;
import org.xbill.DNS.Rcode;
import org.xbill.DNS.Record;
import org.xbill.DNS.SOARecord;
import org.xbill.DNS.SRVRecord;
import org.xbill.DNS.SimpleResolver;
import org.xbill.DNS.TextParseException;
import org.xbill.DNS.Type;
import org.xbill.DNS.Update;
public class DnsSdDiscoveryAdvertiser extends DnsSdDiscoveryContainerAdapter {
private static final String _DNS_UPDATE = "_dns-update._udp."; //$NON-NLS-1$
private static final boolean ADD = true;
private static final boolean REMOVE = false;
public DnsSdDiscoveryAdvertiser() {
super(DnsSdNamespace.NAME, new DiscoveryContainerConfig(IDFactory
.getDefault().createStringID(
DnsSdDiscoveryAdvertiser.class.getName())));
}
/* (non-Javadoc)
* @see org.eclipse.ecf.provider.dnssd.DnsSdDiscoveryLocator#registerService(org.eclipse.ecf.discovery.IServiceInfo)
*/
public void registerService(final IServiceInfo serviceInfo) {
Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "registerService(IServiceInfo serviceInfo)", "Registering service"); //$NON-NLS-1$ //$NON-NLS-2$
sendToServer(serviceInfo, ADD);
}
/* (non-Javadoc)
* @see org.eclipse.ecf.provider.dnssd.DnsSdDiscoveryLocator#unregisterService(org.eclipse.ecf.discovery.IServiceInfo)
*/
public void unregisterService(final IServiceInfo serviceInfo) {
Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "unregisterService(IServiceInfo serviceInfo)", "Unregistering service"); //$NON-NLS-1$ //$NON-NLS-2$
sendToServer(serviceInfo, REMOVE);
}
/* (non-Javadoc)
* @see org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter#unregisterAllServices()
*/
public void unregisterAllServices() {
Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "unregisterAllServices()", "Unregistering all services"); //$NON-NLS-1$ //$NON-NLS-2$
throw new UnsupportedOperationException("Not yet implemented, see http://bugs.eclipse.org/321959"); //$NON-NLS-1$
}
/* (non-Javadoc)
* @see org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter#purgeCache()
*/
public IServiceInfo[] purgeCache() {
// purge cache means renew resolver?
throw new UnsupportedOperationException("Not yet implemented, see http://bugs.eclipse.org/"); //$NON-NLS-1$
}
/* (non-Javadoc)
* @see org.eclipse.ecf.provider.dnssd.DnsSdDiscoveryLocator#connect(org.eclipse.ecf.core.identity.ID, org.eclipse.ecf.core.security.IConnectContext)
*/
public void connect(final ID aTargetID, final IConnectContext connectContext)
throws ContainerConnectException {
Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "connect(ID aTargetID, IConnectContext connectContext)", "connecting container"); //$NON-NLS-1$ //$NON-NLS-2$
// connect can only be called once
if (targetID != null || getConfig() == null) {
throw new ContainerConnectException(Messages.DnsSdDiscoveryAdvertiser_Container_Already_Connected);
}
//TODO convert non DnsSdServiceTypeIDs into DSTIDs
if(aTargetID == null) {
targetID = new DnsSdServiceTypeID();
} else {
final Namespace ns = getConnectNamespace();
try {
targetID = (DnsSdServiceTypeID) ns.createInstance(new Object[]{aTargetID});
} catch(IDCreateException e) {
throw new ContainerConnectException(e);
}
}
// instantiate a default resolver
if(resolver == null) {
try {
resolver = new SimpleResolver();
resolver.setTCP(true);
} catch (UnknownHostException e) {
throw new ContainerConnectException(e);
}
}
// done setting up this provider, send event
fireContainerEvent(new ContainerConnectingEvent(this.getID(), targetID,
connectContext));
fireContainerEvent(new ContainerConnectedEvent(this.getID(), targetID));
}
protected void sendToServer(final IServiceInfo serviceInfo, final boolean mode) {
Assert.isNotNull(serviceInfo);
Assert.isLegal(serviceInfo.getServiceID() instanceof DnsSdServiceID);
final DnsSdServiceID serviceID = (DnsSdServiceID) serviceInfo.getServiceID();
try {
final Record srvRecord = serviceID.toSRVRecord(); // TYPE.SRV
final Record[] txtRecords = serviceID.toTXTRecords(srvRecord); // TYPE.TXT
final Name name = serviceID.getDnsName();
final String[] registrationDomains = getRegistrationDomains(serviceID.getServiceTypeID());
for (int i = 0; i < registrationDomains.length; i++) {
final Name zone = new Name(registrationDomains[i]);
final Name fqdn = new Name(name.toString() + "." + zone.toString()); //$NON-NLS-1$
final Update update = new Update(zone);
//TYPE.SRV
if(mode == ADD) {
//TODO add absent/present condition checks
update.replace(srvRecord.withName(fqdn));
} else {
update.delete(srvRecord.withName(fqdn));
}
//TYPE.TXT
for (int j = 0; j < txtRecords.length; j++) {
if(mode == ADD) {
update.add(txtRecords[j].withName(fqdn));
} else {
update.delete(txtRecords[j].withName(fqdn));
}
}
// set up a the resolver for the given domain (a scope might use different domains)
final Collection dnsServers = getUpdateDomain(zone);
if(dnsServers.size() == 0) {
throw new DnsSdDiscoveryException(Messages.DnsSdDiscoveryAdvertiser_No_DynDns_Servers_Found);
}
for (final Iterator iterator = dnsServers.iterator(); iterator.hasNext();) {
final SRVRecord dnsServer = (SRVRecord) iterator.next();
// try to send msg and fail gracefully if more dns servers are available
final Name target = dnsServer.getTarget();
final Message response;
final InetAddress byName;
try {
byName = InetAddress.getByName(target.toString());
((SimpleResolver) resolver).setAddress(byName);
((SimpleResolver) resolver).setPort(dnsServer.getPort());
response = resolver.send(update);
} catch (UnknownHostException uhe) {
if(iterator.hasNext()) {
continue;
} else {
throw new DnsSdDiscoveryException(uhe);
}
} catch (EOFException eof) {
if(iterator.hasNext()) {
continue;
} else {
throw new DnsSdDiscoveryException(eof);
}
}
// catch some errors and fall back to the next dnsServer
if (response.getRcode() != Rcode.NOERROR) {
if(iterator.hasNext()) {
continue;
} else {
throw DnsSdDiscoveryException.getException(response.getRcode());
}
}
}
}
} catch (Exception e) {
throw new DnsSdDiscoveryException(e);
}
}
protected Collection getUpdateDomain(final Name zone) throws TextParseException {
Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "getUpdateDomain(Name zone)", "Getting update domain"); //$NON-NLS-1$ //$NON-NLS-2$
// query for special "_dns-update" SRV records which mark the server to use for dyndns
final Lookup query = new Lookup(_DNS_UPDATE + zone, Type.SRV);
// use the SRV record with the lowest priority/weight first
final SortedSet srvRecords = getSRVRecord(query, new SRVRecordComparator());
// if no dedicated "_dns-update" server is configured, fall back to regular authoritative server
if(srvRecords.size() == 0) {
Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "getUpdateDomain(Name zone)", "Found no _dns-update SRV records in zone"); //$NON-NLS-1$ //$NON-NLS-2$
return getAuthoritativeNameServer(zone);
}
return srvRecords;
}
protected Collection getAuthoritativeNameServer(final Name zone) throws TextParseException {
Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "getAuthoritativeNameServer(Name zone)", "Trying to find authoritative name server"); //$NON-NLS-1$ //$NON-NLS-2$
final Set result = new HashSet();
final Name name = new Name(_DNS_UPDATE + zone);
//query for NS records
Lookup query = new Lookup(zone, Type.NS);
query.setResolver(resolver);
Record[] queryResult = query.run();
//TODO file bug upstream that queryResult may never be null
int length = queryResult == null ? 0 : queryResult.length;
for (int j = 0; j < length; j++) {
final Record record = queryResult[j];
if(record instanceof NSRecord) {
final NSRecord nsRecord = (NSRecord) record;
final Name target = nsRecord.getTarget();
result.add(new SRVRecord(name, DClass.IN, nsRecord.getTTL(), 0, 0, SimpleResolver.DEFAULT_PORT, target));
}
}
//query for primary ns in SOA record (may overwrite/be equal to one of the ns records)
query = new Lookup(zone, Type.SOA);
query.setResolver(resolver);
queryResult = query.run();
//TODO file bug upstream that queryResult may never be null
length = queryResult == null ? 0 : queryResult.length;
for (int j = 0; j < length; j++) {
final Record record = queryResult[j];
if(record instanceof SOARecord) {
final SOARecord soaRecord = (SOARecord) record;
result.add(new SRVRecord(name, DClass.IN, soaRecord.getTTL(), 0, 0, SimpleResolver.DEFAULT_PORT, soaRecord.getHost()));
}
}
return result;
}
protected String[] getRegistrationDomains(final IServiceTypeID aServiceTypeId) {
Trace.trace(Activator.PLUGIN_ID, DnsSdDebugOptions.METHODS_TRACING, this.getClass(), "getRegistrationDomains(IServiceTypeID aServiceTypeId)", "Getting registration domains"); //$NON-NLS-1$ //$NON-NLS-2$
final String[] rrs = new String[] {BnRDnsSdServiceTypeID.REG_DOMAINS, BnRDnsSdServiceTypeID.DEFAULT_REG_DOMAIN};
final Collection registrationDomains = getBrowsingOrRegistrationDomains(aServiceTypeId, rrs);
final String[] scopes = aServiceTypeId.getScopes();
for (int i = 0; i < scopes.length; i++) {
scopes[i] = scopes[i].concat("."); //$NON-NLS-1$
}
return registrationDomains.size() == 0 ? scopes : (String[]) registrationDomains.toArray(new String[registrationDomains.size()]);
}
/* (non-Javadoc)
* @see org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter#getContainerName()
*/
public String getContainerName() {
return Activator.DISCOVERY_CONTAINER_NAME_VALUE + Activator.ADVERTISER;
}
}