/* Register the out port with Bonjour -- might block so done in a separate thread */
static void *Announce(void *v)
{
struct connection_out *out = v;
DNSServiceRef sref = 0;
DNSServiceErrorType err;
struct sockaddr sa;
//socklen_t sl = sizeof(sa);
socklen_t sl = 128;
uint16_t port ;
char * service_name ;
char name[63] ;
DETACH_THREAD;
if (getsockname(out->file_descriptor, &sa, &sl)) {
LEVEL_CONNECT("Could not get port number of device.");
pthread_exit(NULL);
return VOID_RETURN;
}
port = ntohs(((struct sockaddr_in *) (&sa))->sin_port) ;
/* Add the service */
switch (Globals.program_type) {
case program_type_httpd:
service_name = (Globals.announce_name) ? Globals.announce_name : "OWFS (1-wire) Web" ;
UCLIBCLOCK;
snprintf(name,62,"%s <%d>",service_name,(int)port);
UCLIBCUNLOCK;
err = DNSServiceRegister(&sref, 0, 0, name,"_http._tcp", NULL, NULL, port, 0, NULL, RegisterBack, out) ;
Announce_Post_Register(sref, err) ;
err = DNSServiceRegister(&sref, 0, 0, name,"_owhttpd._tcp", NULL, NULL, port, 0, NULL, RegisterBack, out) ;
break ;
case program_type_server:
case program_type_external:
service_name = (Globals.announce_name) ? Globals.announce_name : "OWFS (1-wire) Server" ;
UCLIBCLOCK;
snprintf(name,62,"%s <%d>",service_name,(int)port);
UCLIBCUNLOCK;
err = DNSServiceRegister(&sref, 0, 0, name,"_owserver._tcp", NULL, NULL, port, 0, NULL, RegisterBack, out) ;
break;
case program_type_ftpd:
service_name = (Globals.announce_name) ? Globals.announce_name : "OWFS (1-wire) FTP" ;
UCLIBCLOCK;
snprintf(name,62,"%s <%d>",service_name,(int)port);
UCLIBCUNLOCK;
err = DNSServiceRegister(&sref, 0, 0, name,"_owftp._tcp", NULL, NULL, port, 0, NULL, RegisterBack, out) ;
break;
default:
err = kDNSServiceErr_NoError ;
break ;
}
Announce_Post_Register(sref, err) ;
LEVEL_DEBUG("Normal completion");
pthread_exit(NULL);
return VOID_RETURN;
}
/*!
* Attempts to register the service on the local network.
*
* If noAutoRename is set to true, registration will fail if another service of the same service type
* is already registered with the same service name. Otherwise, the service name will be updated with
* a number to make it unique.
*
* \sa registered
* \sa registrationError
*/
void QxtDiscoverableService::registerService(bool noAutoRename)
{
if(state() != Unknown) {
qWarning() << "QxtDiscoverableService: Cannot register service while not in Unknown state";
emit registrationError(0);
return;
}
QStringList subtypes = qxt_d().serviceSubTypes;
subtypes.prepend(fullServiceType());
DNSServiceErrorType err;
err = DNSServiceRegister(&(qxt_d().service),
noAutoRename ? kDNSServiceFlagsNoAutoRename : 0,
qxt_d().iface,
serviceName().isEmpty() ? 0 : serviceName().toUtf8().constData(),
subtypes.join(",_").toUtf8().constData(),
domain().isEmpty() ? 0 : domain().toUtf8().constData(),
host().isEmpty() ? 0 : host().toUtf8().constData(),
qxt_d().port,
1, // must include null terminator
"",
QxtDiscoverableServicePrivate::registerServiceCallback,
&qxt_d());
if(err != kDNSServiceErr_NoError) {
qxt_d().state = Unknown;
emit registrationError(err);
} else {
qxt_d().state = Registering;
qxt_d().notifier = new QSocketNotifier(DNSServiceRefSockFD(qxt_d().service), QSocketNotifier::Read, this);
QObject::connect(qxt_d().notifier, SIGNAL(activated(int)), &qxt_d(), SLOT(socketData()));
}
}
/*
* DnsServiceRegistrar::add
*
* Registers a new service.
*
* Parameters:
* - type: service type
* - port: port number of the registered service
* - name: service name (optional)
*
* Return value: reference of the DNS service if registration was successful, NULL otherwise
*/
DNSServiceRef DnsServiceRegistrar::add(const QString& type, quint16 port, const QString& name)
{
/* Deal with name default value */
char *nameStr;
if (name == "") {
nameStr = NULL;
} else {
nameStr = name.toUtf8().data();
}
/* Create and register the new service ref. */
DNSServiceRef ref;
DNSServiceErrorType err = DNSServiceRegister(&ref, 0, 0, nameStr, type.toUtf8().data(), NULL,
NULL, qToBigEndian(port), 0, NULL, registerCallback, this);
if (err != kDNSServiceErr_NoError) {
Model::logger().addEntry(Logger::Error, QString("Error while registering service (error code = %1)").arg(err));
return NULL;
}
/* Create the QSocketNotifier */
int sockFd = DNSServiceRefSockFD(ref);
RefNotifier *pNotif = new RefNotifier(ref, sockFd, QSocketNotifier::Read, this);
connect(pNotif, SIGNAL(activated(int)), this, SLOT(onNotifierActivated()));
return ref;
}
bool vvBonjourRegistrar::registerService(const vvBonjourEntry& entry, const ushort port)
{
#ifdef HAVE_BONJOUR
vvDebugMsg::msg(3, "vvBonjourRegistrar::registerService() Enter");
DNSServiceErrorType error = DNSServiceRegister(&::serviceRef,
0, // no flags
0, // all network interfaces
entry.getServiceName().c_str(),
entry.getRegisteredType().c_str(),
entry.getReplyDomain().c_str(),
NULL, // use default host name
htons(port), // port number
0, // length of TXT record
NULL, // no TXT record
RegisterCallBack, // call back function
this); // no context
if (error == kDNSServiceErr_NoError)
{
_eventLoop = new vvBonjourEventLoop(::serviceRef);
_eventLoop->run(false, -1.0);
return true;
}
else
{
vvDebugMsg::msg(2, "vvBonjourRegistrar::registerService(): DNSServiceResolve failed with error code ", error);
return false;
}
#else
(void)entry;
(void)port;
return false;
#endif
}
void
register_service (int port)
{
int dnsfd;
GSource *source;
if (DNSServiceRegister (&g_sdref, 0, 0, NULL, "_xmms2._tcp", NULL, NULL,
g_htons (port), 0, NULL, dns_callback, NULL)
!= kDNSServiceErr_NoError) {
printf ("failed to register!\n");
exit (1);
}
dnsfd = DNSServiceRefSockFD (g_sdref);
if (dnsfd == -1) {
printf ("no fd!?\n");
exit (1);
}
pollfd = g_new0 (GPollFD, 1);
pollfd->fd = dnsfd;
pollfd->events = G_IO_IN | G_IO_HUP | G_IO_ERR;
source = g_source_new (&dns_ipc_func, sizeof (GSource));
g_source_add_poll (source, pollfd);
g_source_attach (source, NULL);
}
void PublicService::publishAsync()
{
if(d->isRunning())
stop();
#ifdef HAVE_DNSSD
if(ServiceBrowser::isAvailable() == ServiceBrowser::Working)
{
TXTRecordRef txt;
TXTRecordCreate(&txt, 0, 0);
QMap< QString, QString >::ConstIterator itEnd = m_textData.end();
for(QMap< QString, QString >::ConstIterator it = m_textData.begin(); it != itEnd; ++it)
{
QCString value = it.data().utf8();
if(TXTRecordSetValue(&txt, it.key().utf8(), value.length(), value) != kDNSServiceErr_NoError)
{
TXTRecordDeallocate(&txt);
emit published(false);
return;
}
}
DNSServiceRef ref;
if(DNSServiceRegister(&ref, 0, 0, m_serviceName.utf8(), m_type.ascii(), domainToDNS(m_domain), NULL, htons(m_port), TXTRecordGetLength(&txt),
TXTRecordGetBytesPtr(&txt), publish_callback, reinterpret_cast< void * >(this))
== kDNSServiceErr_NoError)
d->setRef(ref);
TXTRecordDeallocate(&txt);
}
#endif
if(!d->isRunning())
emit published(false);
}
void MDnsSdListener::Handler::serviceRegister(SocketClient *cli, int requestId,
const char *interfaceName, const char *serviceName, const char *serviceType,
const char *domain, const char *host, int port, int txtLen, void *txtRecord) {
if (VDBG) {
ALOGD("serviceRegister(%d, %s, %s, %s, %s, %s, %d, %d, <binary>)", requestId,
interfaceName, serviceName, serviceType, domain, host, port, txtLen);
}
Context *context = new Context(requestId, mListener);
DNSServiceRef *ref = mMonitor->allocateServiceRef(requestId, context);
port = htons(port);
if (ref == NULL) {
ALOGE("requestId %d already in use during register call", requestId);
cli->sendMsg(ResponseCode::CommandParameterError,
"RequestId already in use during register call", false);
return;
}
DNSServiceFlags nativeFlags = 0;
int interfaceInt = ifaceNameToI(interfaceName);
DNSServiceErrorType result = DNSServiceRegister(ref, interfaceInt, nativeFlags, serviceName,
serviceType, domain, host, port, txtLen, txtRecord, &MDnsSdListenerRegisterCallback,
context);
if (result != kDNSServiceErr_NoError) {
ALOGE("service register request %d got an error from DNSServiceRegister %d", requestId,
result);
mMonitor->freeServiceRef(requestId);
cli->sendMsg(ResponseCode::CommandParameterError,
"serviceRegister request got an error from DNSServiceRegister", false);
return;
}
mMonitor->startMonitoring(requestId);
if (VDBG) ALOGD("serviceRegister successful");
cli->sendMsg(ResponseCode::CommandOkay, "serviceRegister started", false);
return;
}
boolean RegisterGameService() {
DNSServiceErrorType err = DNSServiceRegister(
&serviceRef,
kDNSServiceFlagsNoAutoRename, // we want a conflict error
InterfaceIndexForName( "en0" ), // pass 0 for all interfaces
"iPhone Doom Classic",
serviceName,
NULL, // domain
NULL, // host
htons( DOOM_PORT ),
0, // txtLen
NULL, // txtRecord
DNSServiceRegisterReplyCallback,
NULL // context
);
if ( err != kDNSServiceErr_NoError ) {
printf( "DNSServiceRegister error\n" );
} else {
// block until we get a response, process it, and run the callback
err = DNSServiceProcessResult( serviceRef );
if ( err != kDNSServiceErr_NoError ) {
printf( "DNSServiceProcessResult error\n" );
}
}
return localServer;
}
static int publish_main_service(struct userdata *u) {
DNSServiceErrorType err;
TXTRecordRef txt;
pa_assert(u);
if (u->main_service) {
DNSServiceRefDeallocate(u->main_service);
u->main_service = NULL;
}
TXTRecordCreate(&txt, 0, NULL);
txt_record_server_data(u->core, &txt);
err = DNSServiceRegister(&u->main_service,
0, /* flags */
kDNSServiceInterfaceIndexAny,
u->service_name,
SERVICE_TYPE_SERVER,
NULL, /* domain */
NULL, /* host */
compute_port(u),
TXTRecordGetLength(&txt),
TXTRecordGetBytesPtr(&txt),
NULL, NULL);
if (err != kDNSServiceErr_NoError) {
pa_log("%s(): DNSServiceRegister() returned err %d", __func__, err);
return err;
}
TXTRecordDeallocate(&txt);
return 0;
}
void doregistration(const char *name, unsigned long port)
{
DNSServiceRegister(&service_ref, 0, 0, name, "_ftp._tcp.", NULL, NULL,
port, 0, NULL,
reg_reply,
NULL);
}
static DNSServiceErrorType RegisterService(DNSServiceRef *sdref,
const char *nam, const char *typ, const char *dom, const char *host, const char *port, AutoDiscoveryServerImpl *context)
{
DNSServiceFlags flags = 0;
uint16_t PortAsNumber = atoi(port);
Opaque16 registerPort =
{
{ PortAsNumber >> 8, PortAsNumber & 0xFF }
};
unsigned char txt[2048] = "";
unsigned char *ptr = txt;
if (nam[0] == '.' && nam[1] == 0)
nam = ""; // We allow '.' on the command line as a synonym for empty string
if (dom[0] == '.' && dom[1] == 0)
dom = ""; // We allow '.' on the command line as a synonym for empty string
OSG_INFO << "AutoDiscoveryImpl :: Registering Service " << (nam[0] ? nam : "<<Default>>") << " " << typ << " " << (dom[0] ? "." : "", dom) << std::endl;
if (host && *host)
{
OSG_INFO << "AutoDiscoveryImpl :: host " << host << " port " << port << std::endl;
}
// printf("\n");
// flags |= kDNSServiceFlagsAllowRemoteQuery;
// flags |= kDNSServiceFlagsNoAutoRename;
return(DNSServiceRegister(sdref, flags, kDNSServiceInterfaceIndexAny, nam, typ, dom, host, registerPort.NotAnInteger, (uint16_t) (ptr - txt), txt, reg_reply, context));
}
bool announce( const unsigned short port, const std::string& instance )
{
#ifdef LUNCHBOX_USE_DNSSD
if( service_ )
return false;
TXTRecordRef record;
createTXTRecord_( record );
const DNSServiceErrorType error =
DNSServiceRegister( &service_, 0 /* flags */,
0 /* all interfaces */,
instance.empty() ? 0 : instance.c_str(),
name_.c_str(), 0 /* default domains */,
0 /* hostname */, htons( port ),
TXTRecordGetLength( &record ),
TXTRecordGetBytesPtr( &record ),
(DNSServiceRegisterReply)registerCBS_,
this );
TXTRecordDeallocate( &record );
if( error == kDNSServiceErr_NoError )
{
handleEvents_( service_ );
return service_ != 0;
}
LBWARN << "DNSServiceRegister returned: " << error << std::endl;
#endif
return false;
}
void registration(Thread *thread) {
// release calling thread semaphore
thread->thread_ready();
DNSServiceErrorType error;
DNSServiceRef service;
error = DNSServiceRegister(&service,
0, // no flags
0, // all network interfaces
master_->name_.c_str(), // name
master_->service_type_.c_str(), // service type
"", // register in default domain(s)
NULL, // use default host name
htons(master_->port_),// port number
0, // length of TXT record
NULL, // no TXT record
Implementation::register_callback, // callback function
(void*)master_); // context
if (error == kDNSServiceErr_NoError) {
pthread_cleanup_push(registration_cleanup, &service);
register_service(service);
pthread_cleanup_pop(0); // 0 = do not execute on pop
} else {
fprintf(stderr,"Could not register service %s.%s on port %u (error %d)\n", master_->name_.c_str(), master_->service_type_.c_str(), master_->port_, error);//, strerror(errno));
}
DNSServiceRefDeallocate(service);
}
JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleRegistration_BeginRegister( JNIEnv *pEnv, jobject pThis,
jint ifIndex, jint flags, jstring serviceName, jstring regType,
jstring domain, jstring host, jint port, jbyteArray txtRecord)
{
//syslog(LOG_ERR, "BR");
jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
OpContext *pContext = NULL;
DNSServiceErrorType err = kDNSServiceErr_NoError;
jbyte *pBytes;
jsize numBytes;
//syslog(LOG_ERR, "BR: contextField %d", contextField);
if ( contextField != 0)
pContext = NewContext( pEnv, pThis, "serviceRegistered",
"(Lcom/apple/dnssd/DNSSDRegistration;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
else
err = kDNSServiceErr_BadParam;
if ( pContext != NULL)
{
const char *servStr = SafeGetUTFChars( pEnv, serviceName);
const char *regStr = SafeGetUTFChars( pEnv, regType);
const char *domainStr = SafeGetUTFChars( pEnv, domain);
const char *hostStr = SafeGetUTFChars( pEnv, host);
//syslog(LOG_ERR, "BR: regStr %s", regStr);
// Since Java ints are defined to be big-endian, we de-canonicalize 'port' from a
// big-endian number into a 16-bit pattern here.
uint16_t portBits = port;
portBits = ( ((unsigned char*) &portBits)[0] << 8) | ((unsigned char*) &portBits)[1];
pBytes = txtRecord ? (*pEnv)->GetByteArrayElements( pEnv, txtRecord, NULL) : NULL;
numBytes = txtRecord ? (*pEnv)->GetArrayLength( pEnv, txtRecord) : 0;
err = DNSServiceRegister( &pContext->ServiceRef, flags, ifIndex, servStr, regStr,
domainStr, hostStr, portBits,
numBytes, pBytes, ServiceRegisterReply, pContext);
if ( err == kDNSServiceErr_NoError)
{
(*pEnv)->SetLongField(pEnv, pThis, contextField, (long) pContext);
}
if ( pBytes != NULL)
(*pEnv)->ReleaseByteArrayElements( pEnv, txtRecord, pBytes, 0);
SafeReleaseUTFChars( pEnv, serviceName, servStr);
SafeReleaseUTFChars( pEnv, regType, regStr);
SafeReleaseUTFChars( pEnv, domain, domainStr);
SafeReleaseUTFChars( pEnv, host, hostStr);
}
else
err = kDNSServiceErr_NoMemory;
return err;
}
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
DNSServiceRef ref1, ref2, ref3, ref4 = NULL;
DNSServiceRegister(&ref1, 0, 0, "simple", "_simple._tcp", NULL, NULL, 4711, 0, NULL, NULL, NULL);
DNSServiceRegister(&ref2, 0, 0, "subtype #1", "_simple._tcp,_subtype1", NULL, NULL, 4711, 0, NULL, NULL, NULL);
DNSServiceRegister(&ref3, 0, 0, "subtype #2", "_simple._tcp,_subtype1,_subtype2", NULL, NULL, 4711, 0, NULL, NULL, NULL);
DNSServiceRegister(&ref4, 0, 0, "subtype #3", "_simple._tcp,,", NULL, NULL, 4711, 0, NULL, NULL, NULL);
assert(!ref4);
DNSServiceRegister(&ref4, 0, 0, "subtype #3", "", NULL, NULL, 4711, 0, NULL, NULL, NULL);
assert(!ref4);
DNSServiceRegister(&ref4, 0, 0, "subtype #3", ",", NULL, NULL, 4711, 0, NULL, NULL, NULL);
assert(!ref4);
DNSServiceRegister(&ref4, 0, 0, "subtype #3", ",,", NULL, NULL, 4711, 0, NULL, NULL, NULL);
assert(!ref4);
DNSServiceBrowse(&ref4, 0, 0, "_simple._tcp,_gurke", NULL, reply, NULL);
sleep(20);
DNSServiceRefDeallocate(ref1);
DNSServiceRefDeallocate(ref2);
DNSServiceRefDeallocate(ref3);
DNSServiceRefDeallocate(ref4);
return 0;
}
DNSServiceErrorType
RegisterWorkstationService(MyDNSServiceState *ref, CFStringRef serviceName)
{
char name[64];
DNSServiceErrorType error = kDNSServiceErr_BadParam;
if (CFStringGetCString(serviceName, name, sizeof(name), kCFStringEncodingUTF8)) {
uuid_t compUUID;
CFDataRef cfTXTRecord = NULL;
struct timespec waitTime = { 0 };
if ( gethostuuid(compUUID, &waitTime) == 0 )
{
CFMutableDictionaryRef txtRecordDict = CFDictionaryCreateMutable( kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks );
uuid_string_t uuidstr;
uuid_unparse_upper( compUUID, uuidstr );
CFStringRef cfUUID = CFStringCreateWithCString( kCFAllocatorDefault, uuidstr, kCFStringEncodingUTF8 );
CFDictionarySetValue( txtRecordDict, CFSTR("uuid"), cfUUID );
DbgLog( kLogInfo, "Workstation service - uuid = %s", uuidstr );
DSCFRelease( cfUUID );
cfTXTRecord = CFNetServiceCreateTXTDataWithDictionary( kCFAllocatorDefault, txtRecordDict );
DSCFRelease( txtRecordDict );
}
else
{
DbgLog( kLogError, "Failed to get host UUID from gethostuuid()" );
}
error = DNSServiceRegister(&ref->service,
kDNSServiceFlagsNoAutoRename,
kDNSServiceInterfaceIndexAny,
name,
kWorkstationType,
NULL,
NULL,
htons(kWorkstationPort),
(cfTXTRecord ? CFDataGetLength(cfTXTRecord) : 0),
(cfTXTRecord ? CFDataGetBytePtr(cfTXTRecord) : NULL),
RegisterWorkstationCallBack,
(void *)ref);
DSCFRelease( cfTXTRecord );
}
if (kDNSServiceErr_NoError == error) {
DbgLog( kLogNotice, "Registered Workstation service - %s.%s", name, kWorkstationType );
MyDNSServiceAddToRunLoop(ref);
}
return error;
}
int
mdns_register(char *name, char *regtype, int port, char **txt)
{
struct mdns_service *s;
DNSServiceErrorType err;
int i;
char *eq;
DPRINTF(E_DBG, L_MDNS, "Adding mDNS service '%s.%s'\n", name, regtype);
s = calloc(1, sizeof(*s));
if (!s)
{
DPRINTF(E_LOG, L_MDNS, "Out of memory registering service.\n");
return -1;
}
TXTRecordCreate(&(s->txtRecord), 0, NULL);
for (i = 0; txt && txt[i]; i++)
{
if ((eq = strchr(txt[i], '=')))
{
*eq = '\0';
eq++;
err = TXTRecordSetValue(&(s->txtRecord), txt[i], strlen(eq) * sizeof(char), eq);
*(--eq) = '=';
if (err != kDNSServiceErr_NoError)
{
DPRINTF(E_LOG, L_MDNS, "Could not set TXT record value\n");
return mdns_service_free(s);
}
}
}
s->sdref = mdns_sdref_main;
err = DNSServiceRegister(&(s->sdref), kDNSServiceFlagsShareConnection, 0,
name, regtype, NULL, NULL, htons(port),
TXTRecordGetLength(&(s->txtRecord)),
TXTRecordGetBytesPtr(&(s->txtRecord)),
mdns_register_callback, NULL);
if (err != kDNSServiceErr_NoError)
{
DPRINTF(E_LOG, L_MDNS, "Error registering service '%s.%s'\n",
name, regtype);
s->sdref = NULL;
return mdns_service_free(s);
}
s->next = mdns_services;
mdns_services = s;
return 0;
}
//methods to implement for concrete implementations
bool CZeroconfWIN::doPublishService(const std::string& fcr_identifier,
const std::string& fcr_type,
const std::string& fcr_name,
unsigned int f_port,
std::map<std::string, std::string> txt)
{
DNSServiceRef netService = NULL;
TXTRecordRef txtRecord;
TXTRecordCreate(&txtRecord, 0, NULL);
CLog::Log(LOGDEBUG, "CZeroconfWIN::doPublishService identifier: %s type: %s name:%s port:%i", fcr_identifier.c_str(), fcr_type.c_str(), fcr_name.c_str(), f_port);
//add txt records
if(!txt.empty())
{
for(std::map<std::string, std::string>::const_iterator it = txt.begin(); it != txt.end(); ++it)
{
CLog::Log(LOGDEBUG, "CZeroconfWIN: key:%s, value:%s",it->first.c_str(),it->second.c_str());
uint8_t txtLen = (uint8_t)strlen(it->second.c_str());
TXTRecordSetValue(&txtRecord, it->first.c_str(), txtLen, it->second.c_str());
}
}
DNSServiceErrorType err = DNSServiceRegister(&netService, 0, 0, fcr_name.c_str(), fcr_type.c_str(), NULL, NULL, htons(f_port), TXTRecordGetLength(&txtRecord), TXTRecordGetBytesPtr(&txtRecord), registerCallback, NULL);
if(err != kDNSServiceErr_ServiceNotRunning)
DNSServiceProcessResult(netService);
if (err != kDNSServiceErr_NoError)
{
// Something went wrong so lets clean up.
if (netService)
DNSServiceRefDeallocate(netService);
CLog::Log(LOGERROR, "CZeroconfWIN::doPublishService CFNetServiceRegister returned (error = %ld)\n", (int) err);
if(err == kDNSServiceErr_ServiceNotRunning)
{
CLog::Log(LOGERROR, "CZeroconfWIN: Zeroconf can't be started probably because Apple's Bonjour Service isn't installed. You can get it by either installing Itunes or Apple's Bonjour Print Service for Windows (http://support.apple.com/kb/DL999)");
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, "Failed to start zeroconf", "Is Apple's Bonjour Service installed? See log for more info.", 10000, true);
}
}
else
{
CSingleLock lock(m_data_guard);
m_services.insert(make_pair(fcr_identifier, netService));
}
TXTRecordDeallocate(&txtRecord);
return err == kDNSServiceErr_NoError;
}
static int mdns_dns_sd_register(char *apname, int port) {
char *recordwithoutmetadata[] = {MDNS_RECORD_WITHOUT_METADATA, NULL};
#ifdef CONFIG_METADATA
char *recordwithmetadata[] = {MDNS_RECORD_WITH_METADATA, NULL};
#endif
char **record;
#ifdef CONFIG_METADATA
if (config.metadata_enabled)
record = recordwithmetadata;
else
#endif
record = recordwithoutmetadata;
uint16_t length = 0;
char **field;
// Concatenate string contained i record into buf.
for (field = record; *field; field++) {
length += strlen(*field) + 1; // One byte for length each time
}
char *buf = malloc(length * sizeof(char));
if (buf == NULL) {
warn("dns_sd: buffer record allocation failed");
return -1;
}
char *p = buf;
for (field = record; *field; field++) {
char *newp = stpcpy(p + 1, *field);
*p = newp - p - 1;
p = newp;
}
DNSServiceErrorType error;
error = DNSServiceRegister(&service, 0, kDNSServiceInterfaceIndexAny, apname, config.regtype, "",
NULL, htons((uint16_t)port), length, buf, NULL, NULL);
free(buf);
if (error == kDNSServiceErr_NoError)
return 0;
else {
warn("dns-sd: DNSServiceRegister error %d", error);
return -1;
}
}
//methods to implement for concrete implementations
bool CZeroconfWIN::doPublishService(const std::string& fcr_identifier,
const std::string& fcr_type,
const std::string& fcr_name,
unsigned int f_port,
std::map<std::string, std::string> txt)
{
DNSServiceRef netService = NULL;
TXTRecordRef txtRecord;
TXTRecordCreate(&txtRecord, 0, NULL);
CLog::Log(LOGDEBUG, __FUNCTION__ " identifier: %s type: %s name:%s port:%i", fcr_identifier.c_str(), fcr_type.c_str(), fcr_name.c_str(), f_port);
//add txt records
if(!txt.empty())
{
for(std::map<std::string, std::string>::const_iterator it = txt.begin(); it != txt.end(); ++it)
{
CLog::Log(LOGDEBUG, "ZeroconfWIN: key:%s, value:%s",it->first.c_str(),it->second.c_str());
uint8_t txtLen = (uint8_t)strlen(it->second.c_str());
TXTRecordSetValue(&txtRecord, it->first.c_str(), txtLen, it->second.c_str());
}
}
DNSServiceErrorType err = DNSServiceRegister(&netService, 0, 0, fcr_name.c_str(), fcr_type.c_str(), NULL, NULL, htons(f_port), TXTRecordGetLength(&txtRecord), TXTRecordGetBytesPtr(&txtRecord), registerCallback, NULL);
if (err != kDNSServiceErr_NoError)
{
// Something went wrong so lets clean up.
if (netService)
DNSServiceRefDeallocate(netService);
CLog::Log(LOGERROR, __FUNCTION__ " DNSServiceRegister returned (error = %ld)", (int) err);
}
else
{
err = DNSServiceProcessResult(netService);
if (err != kDNSServiceErr_NoError)
CLog::Log(LOGERROR, __FUNCTION__ " DNSServiceProcessResult returned (error = %ld)", (int) err);
CSingleLock lock(m_data_guard);
m_services.insert(make_pair(fcr_identifier, netService));
}
TXTRecordDeallocate(&txtRecord);
return err == kDNSServiceErr_NoError;
}
static VALUE
dnssd_service_register(VALUE self, VALUE _flags, VALUE _interface, VALUE _name,
VALUE _type, VALUE _domain, VALUE _host, VALUE _port, VALUE _text_record) {
const char *name, *type, *host = NULL, *domain = NULL;
uint16_t port;
uint16_t txt_len = 0;
char *txt_rec = NULL;
DNSServiceFlags flags = 0;
uint32_t interface = 0;
DNSServiceRegisterReply callback = NULL;
DNSServiceErrorType e;
DNSServiceRef *client;
dnssd_utf8_cstr(_name, name);
dnssd_utf8_cstr(_type, type);
if (!NIL_P(_host))
dnssd_utf8_cstr(_host, host);
if (!NIL_P(_domain))
dnssd_utf8_cstr(_domain, domain);
port = htons((uint16_t)NUM2UINT(_port));
if (!NIL_P(_text_record)) {
txt_rec = RSTRING_PTR(_text_record);
txt_len = RSTRING_LEN(_text_record);
}
if (!NIL_P(_flags))
flags = (DNSServiceFlags)NUM2ULONG(_flags);
if (!NIL_P(_interface))
interface = (uint32_t)NUM2ULONG(_interface);
if (rb_block_given_p())
callback = dnssd_service_register_reply;
get(cDNSSDService, self, DNSServiceRef, client);
e = DNSServiceRegister(client, flags, interface, name, type,
domain, host, port, txt_len, txt_rec, callback, (void*)self);
dnssd_check_error_code(e);
return self;
}
FskErr KprZeroconfPlatformAdvertisementStart(KprZeroconfAdvertisement self)
{
FskErr err = kFskErrNone;
char* txt = NULL;
UInt32 size = 0, offset = 0, length;
KprZeroconfPlatformAdvertisement advertisement = self->platform;
if (!advertisement->service) {
DNSServiceErrorType error;
DNSServiceRef serviceRef;
FskAssociativeArrayIterator iterator = FskAssociativeArrayIteratorNew(self->txt);
FskInstrumentedItemPrintfDebug(advertisement, "DNSServiceRegister %s %s %d\n", self->serviceName, self->serviceType, self->port);
while (iterator) {
UInt32 nameLength = FskStrLen(iterator->name);
UInt32 valueLength = FskStrLen(iterator->value);
length = nameLength + 1 + valueLength;
if (length <= 255) {
size += length + 1;
err = txt ? FskMemPtrRealloc(size + 1, &txt) : FskMemPtrNew(size + 1, &txt);
if (err)
size -= length + 1;
else {
txt[offset++] = (char)length;
FskStrCopy(txt + offset, iterator->name); offset += nameLength;
txt[offset++] = '=';
FskStrCopy(txt + offset, iterator->value); offset += valueLength;
txt[offset] = 0;
}
}
iterator = FskAssociativeArrayIteratorNext(iterator);
}
FskAssociativeArrayIteratorDispose(iterator);
error = DNSServiceRegister(&serviceRef, 0, 0, self->serviceName, self->serviceType, "", NULL, // use default host name
htons(self->port), txt ? FskStrLen(txt) : 0, txt, KprZeroconfPlatformAdvertisementProcess, self);
if (error != kDNSServiceErr_NoError) {
FskInstrumentedItemPrintfDebug(advertisement, "DNSServiceRegister error %d\n", error);
bailIfError(kFskErrNetworkErr);
}
bailIfError(KprZeroconfPlatformServiceNew(&advertisement->service, NULL, serviceRef, NULL, 0));
}
bail:
FskMemPtrDispose(txt);
return err;
}
static DNSServiceErrorType RegisterService(RegisteredService *rs, mDNSOpaque16 OpaquePort,
const char name[], const char type[], const char domain[], const char txtinfo[])
{
DNSServiceErrorType err;
unsigned char txtbuffer[257];
strncpy((char*)txtbuffer+1, txtinfo, 255);
txtbuffer[256] = 0;
txtbuffer[0] = (unsigned char)strlen((char*)txtbuffer);
rs->gotresult = 0;
rs->errorCode = kDNSServiceErr_NoError;
err = DNSServiceRegister(&rs->sdRef, /* kDNSServiceFlagsAutoRename*/ 0, 0,
name, type, domain, NULL, OpaquePort.NotAnInteger, (unsigned short)(1+txtbuffer[0]), txtbuffer, RegCallback, rs);
if (err)
printf("RegisterService(%s %s %s) failed %d\n", name, type, domain, err);
else
{ *nextservice = rs; nextservice = &rs->next; }
return(err);
}
void Manager::registerService()
{
if( m_publishRef )
deregisterService();
m_server.connect();
std::string txtRecord;
txtRecord += (char)9; // length of mandatory txtvers=1
txtRecord += "txtvers=1"; // this is here because it SHOULD be the first entry
StringMap::const_iterator it = m_txtData.begin();
for( ; it != m_txtData.end(); ++it )
{
txtRecord += (char)( (*it).first.length() + (*it).second.length() + 1 );
txtRecord += (*it).first;
txtRecord += '=';
txtRecord += (*it).second;
}
std::string service = m_user + "@";
if( m_host.empty() )
{
char host[65];
gethostname( host, 65 );
service += host;
}
else
service += m_host;
/*DNSServiceErrorType e =*/ DNSServiceRegister( &m_publishRef,
0, // flags
m_interface, // interface, 0 = any, -1 = local only
service.c_str(), // service name, 0 = local computer name
LINKLOCAL_SERVICE_TYPE.c_str(), // service type
m_domain.c_str(), // domain, 0 = default domain(s)
m_host.c_str(), // host, 0 = default host name(s)
htons( m_port ), // port
(short unsigned int)txtRecord.length(), // TXT record length
(const void*)txtRecord.c_str(), // TXT record
0, // callback
0 ); // context
}
static void wd_server_register_dnssd(void) {
DNSServiceRef service;
DNSServiceErrorType err;
err = DNSServiceRegister(&service,
0,
kDNSServiceInterfaceIndexAny,
wi_string_cstring(wd_settings.name),
WD_DNSSD_NAME,
NULL,
NULL,
htons(wd_settings.port),
0,
NULL,
wd_server_register_dnssd_reply,
NULL);
if(err != kDNSServiceErr_NoError)
wi_log_warn(WI_STR("Could not register for DNS service discovery: %d"), err);
}
int Trick::Zeroconf::init() {
#ifdef HAVE_ZEROCONF
#if __linux
int error;
int ret ;
char r[128] ;
if (!(simple_poll = avahi_simple_poll_new())) {
fprintf(stderr, "Failed to create simple poll object.\n");
return -1 ;
}
client = avahi_client_new(avahi_simple_poll_get(simple_poll), (AvahiClientFlags)0, NULL, NULL, &error);
if ( client != NULL ) {
group = avahi_entry_group_new(client, entry_group_callback, (void *)name.c_str()) ;
if (avahi_entry_group_is_empty(group)) {
ret = avahi_entry_group_add_service(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, (AvahiPublishFlags)0,
name.c_str(), type.c_str(), NULL, NULL, var_server_get_port(), NULL, r, NULL) ;
ret = avahi_entry_group_commit(group) ;
}
}
#endif
#if __APPLE__
DNSServiceErrorType error ;
error = DNSServiceRegister(&dns_service_ref,
0, 0,
name.c_str(), type.c_str(),
NULL, NULL,
htons(var_server_get_port()),
0, NULL, // txt record stuff
NULL, NULL); // callback stuff
#endif
#endif
return 0 ;
}
void PublicService::publishAsync()
{
K_D;
if (d->isRunning()) stop();
TXTRecordRef txt;
TXTRecordCreate(&txt,0,0);
QMap<QString,QByteArray>::ConstIterator itEnd = d->m_textData.end();
for (QMap<QString,QByteArray>::ConstIterator it = d->m_textData.begin(); it!=itEnd ; ++it) {
if (TXTRecordSetValue(&txt,it.key().toUtf8(),it.value().length(),it.value())!=kDNSServiceErr_NoError) {
TXTRecordDeallocate(&txt);
emit published(false);
return;
}
}
DNSServiceRef ref;
QString fullType=d->m_type;
Q_FOREACH(const QString &subtype, d->m_subtypes) fullType+=','+subtype;
if (DNSServiceRegister(&ref,0,0,d->m_serviceName.toUtf8(),fullType.toAscii().constData(),domainToDNS(d->m_domain),NULL,
htons(d->m_port),TXTRecordGetLength(&txt),TXTRecordGetBytesPtr(&txt),publish_callback,
reinterpret_cast<void*>(d)) == kDNSServiceErr_NoError) d->setRef(ref);
TXTRecordDeallocate(&txt);
if (!d->isRunning()) emit published(false);
}
static void *dcc_xci_zeroconf_main(void *param) {
context *ctx = param;
const char *service;
DNSServiceErrorType rv;
service = dcc_xci_zeroconf_service_name();
if ((rv = DNSServiceRegister(&ctx->zc, 0, 0, NULL, service,
NULL, NULL, htons(arg_port), 0, NULL,
dcc_xci_zeroconf_reply, ctx)) !=
kDNSServiceErr_NoError) {
rs_log_error("DNSServiceRegister() failed: error %d", rv);
return NULL;
}
while ((rv = DNSServiceProcessResult(ctx->zc) == kDNSServiceErr_NoError)) {
}
rs_log_error("DNSServiceProcessResult() failed: error %d", rv);
ctx->thread_live = 0;
return NULL;
}
bool YMmDNSServiceStart( YMmDNSServiceRef s_ )
{
__ym_mdns_service_t *s = (__ym_mdns_service_t *)s_;
DNSServiceRef *serviceRef = (DNSServiceRef *)calloc( 1, sizeof(DNSServiceRef) );
uint16_t netPort = htons(s->port);
bool txtExists = (s->txtRecord != NULL);
uint16_t txtLength = txtExists ? TXTRecordGetLength((TXTRecordRef *)s->txtRecord) : 0;
const void *txt = txtExists ? TXTRecordGetBytesPtr((TXTRecordRef *)s->txtRecord) : NULL;
DNSServiceErrorType result = DNSServiceRegister(serviceRef,
0, // DNSServiceFlags
0, // interfaceIndex (0=all)
YMSTR(s->name),
YMSTR(s->type),
NULL, // domain
NULL, // host
netPort,
txtLength,
txt,
__ymmdns_register_callback, // DNSServiceRegisterReply
s); // context
if( result != kDNSServiceErr_NoError ) {
// on error "the callback is never invoked and the DNSServiceRef is not initialized"
// leading me to think we free instead of DNSServiceRefDeallocate
free(serviceRef);
ymlog("mdns: DNSServiceRegister failed: %s/%s:%u: %d",YMSTR(s->type),YMSTR(s->name),(unsigned)s->port,result);
return false;
}
s->dnsService = serviceRef;
s->advertising = true;
ymlog("mdns: published %s/%s:%u",YMSTR(s->type),YMSTR(s->name),(unsigned)s->port);
return true;
}
bool BonjourRegister::Register(uint16_t port, const QByteArray &type,
const QByteArray &name, const QByteArray &txt)
{
if (m_dnssref)
{
LOG(VB_GENERAL, LOG_WARNING, LOC + "Service already registered.");
return true;
}
m_lock = new QMutexLocker(&g_lock);
m_data = txt;
uint16_t qport = qToBigEndian(port);
DNSServiceErrorType res =
DNSServiceRegister(&m_dnssref, 0, 0, name.data(), type.data(),
nullptr, nullptr, qport, txt.size(), (void*)txt.data(),
BonjourCallback, this);
if (kDNSServiceErr_NoError != res)
{
LOG(VB_GENERAL, LOG_ERR, LOC + QString("Error: %1").arg(res));
}
else
{
int fd = DNSServiceRefSockFD(m_dnssref);
if (fd != -1)
{
m_socket = new QSocketNotifier(fd, QSocketNotifier::Read, this);
m_socket->setEnabled(true);
connect(m_socket, SIGNAL(activated(int)),
this, SLOT(socketReadyRead()));
delete m_lock; // would already have been deleted, but just in case
m_lock = nullptr;
return true;
}
}
