static void DNSSD_API browse_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
const char *replyName, const char *replyType, const char *replyDomain, void *context)
{
if (errorCode)
{
OSG_WARN << "AutoDiscoveryImpl :: Error code " << errorCode << std::endl;
return;
}
AutoDiscoveryClientImpl *impl = static_cast<AutoDiscoveryClientImpl*>(context);
if (!impl)
return;
if (!(flags & kDNSServiceFlagsAdd))
{
impl->serviceRemoved(replyName, replyType, replyDomain);
return;
}
ContextDNSServiceRefPair *ref_pair = new ContextDNSServiceRefPair();
ref_pair->context = static_cast<AutoDiscoveryClientImpl*>(context);
DNSServiceErrorType err = DNSServiceResolve(&ref_pair->ref, 0, ifIndex, replyName, replyType, replyDomain, zonedata_resolve, ref_pair);
if (!ref_pair->ref || err != kDNSServiceErr_NoError)
{
OSG_WARN << "AutoDiscoveryImpl :: DNSServiceResolve call failed " << (long int)err << std::endl;
}
else
impl->addRef(ref_pair->ref);
}
static VALUE
dnssd_service_resolve(VALUE self, VALUE _flags, VALUE _interface, VALUE _name,
VALUE _type, VALUE _domain) {
const char *name, *type, *domain;
DNSServiceFlags flags = 0;
uint32_t interface = 0;
DNSServiceErrorType e;
DNSServiceRef *client;
dnssd_utf8_cstr(_name, name);
dnssd_utf8_cstr(_type, type);
dnssd_utf8_cstr(_domain, domain);
if (!NIL_P(_flags))
flags = (uint32_t)NUM2ULONG(_flags);
if (!NIL_P(_interface))
interface = (uint32_t)NUM2ULONG(_interface);
get(cDNSSDService, self, DNSServiceRef, client);
e = DNSServiceResolve(client, flags, interface, name, type, domain,
dnssd_service_resolve_reply, (void *)self);
dnssd_check_error_code(e);
return self;
}
// When a new named instance of a service is found, FoundInstance() is called.
// In this sample code we turn around and immediately to a DNSServiceResolve() to resolve that service name
// to find its target host, port, and txtinfo, but a normal browing application would just display the name.
// Resolving every single thing you find can be quite hard on the network, so you shouldn't do this
// in a real application. Defer resolving until the client has picked which instance from the
// long list of services is the one they want to use, and then resolve only that one.
static void FoundInstance(DNSServiceRef client, DNSServiceFlags flags, uint32_t interface, DNSServiceErrorType errorCode,
const char *replyName, const char *replyType, const char *replyDomain, void *context)
{
#pragma unused(client, interface, errorCode)
SearcherServices *services = (SearcherServices *)context;
linkedServiceInfo *info;
if (!services) { DebugStr("\pFoundInstance: services is NULL"); return; }
info = (linkedServiceInfo *)OTAllocMem(sizeof(linkedServiceInfo));
if (!info) { services->lostRecords = true; return; }
info->services = services;
strcpy(info->name, replyName);
strcpy(info->type, replyType);
strcpy(info->domn, replyDomain);
info->text[0] = 0;
info->add = (flags & kDNSServiceFlagsAdd) ? true : false;
info->dom = false;
if (!info->add) // If TTL == 0 we're deleting a service,
OTLIFOEnqueue(&services->serviceinfolist, &info->link);
else // else we're adding a new service
DNSServiceResolve(&info->sdRef, 0, 0, info->name, info->type, info->domn, FoundInstanceInfo, info);
}
vvBonjour::ErrorType vvBonjourResolver::resolveBonjourEntry(const vvBonjourEntry& entry)
{
#ifdef HAVE_BONJOUR
vvDebugMsg::msg(3, "vvBonjourResolver::resolveBonjourEntry()");
DNSServiceErrorType error;
DNSServiceRef serviceRef;
error = DNSServiceResolve(&serviceRef,
0, // no flags
0, // all network interfaces
entry.getServiceName().c_str(), //name
entry.getRegisteredType().c_str(), // service type
entry.getReplyDomain().c_str(), //domain
ResolveCallBack,
this); // no context
if (error == kDNSServiceErr_NoError)
{
_eventLoop = new vvBonjourEventLoop(serviceRef);
_eventLoop->run();
return vvBonjour::VV_OK;
}
else
{
vvDebugMsg::msg(2, "vvBonjourResolver::resolveBonjourEntry(): DNSServiceResolve failed with error code ", error);
return vvBonjour::VV_ERROR;
}
#else
(void)entry;
return vvBonjour::VV_ERROR;
#endif
}
/*!
* Attempts to resolve the service in order to determine the host and port necessary to establish a connection.
*
* If forceMulticast is set to true, QxtDiscoverableService will use a multicast request to resolve the service,
* even if the host name appears to be a unicast address (that is, outside the local network).
*
* \sa resolved
* \sa resolveError
*/
void QxtDiscoverableService::resolve(bool forceMulticast)
{
if(state() != Unknown && state() != Found) {
qWarning() << "QxtDiscoverableService: Cannot resolve service while not in Unknown or Found state";
emit resolveError(0);
return;
}
DNSServiceErrorType err;
err = DNSServiceResolve(&(qxt_d().service),
(forceMulticast ? kDNSServiceFlagsForceMulticast : 0),
qxt_d().iface,
serviceName().toUtf8().constData(),
fullServiceType().constData(),
domain().toUtf8().constData(),
QxtDiscoverableServicePrivate::resolveServiceCallback,
&qxt_d());
if(err != kDNSServiceErr_NoError) {
qxt_d().state = Unknown;
emit resolveError(err);
} else {
qxt_d().state = Resolving;
qxt_d().notifier = new QSocketNotifier(DNSServiceRefSockFD(qxt_d().service), QSocketNotifier::Read, this);
QObject::connect(qxt_d().notifier, SIGNAL(activated(int)), &qxt_d(), SLOT(socketData()));
}
}
/* Sent back from Bounjour -- arbitrarily use it to set the Ref for Deallocation */
static void BrowseBack(DNSServiceRef s, DNSServiceFlags f, uint32_t i, DNSServiceErrorType e, const char *name, const char *type, const char *domain, void *context)
{
struct BrowseStruct *browse_struct;
(void) context;
LEVEL_DETAIL("ref=%ld flags=%d index=%d, error=%d name=%s type=%s domain=%s", (long int) s, f, i, e, name, type, domain);
if (e != kDNSServiceErr_NoError) {
return ;
}
browse_struct = Browse_Struct_Create( name, type, domain ) ;
if (f & kDNSServiceFlagsAdd) { // Add
DNSServiceRef sr;
if (DNSServiceResolve(&sr, 0, 0, name, type, domain, ResolveBack, (void *)browse_struct) == kDNSServiceErr_NoError) {
ResolveWait(sr) ;
DNSServiceRefDeallocate(sr);
} else {
Browse_Struct_Destroy(browse_struct) ;
}
} else { // Remove
Browse_Struct_Destroy(browse_struct) ;
ZeroDel( name, type, domain ) ;
}
}
bool CZeroconfBrowserWIN::doResolveService(CZeroconfBrowser::ZeroconfService& fr_service, double f_timeout)
{
DNSServiceErrorType err;
DNSServiceRef sdRef = NULL;
err = DNSServiceResolve(&sdRef, 0, kDNSServiceInterfaceIndexAny, fr_service.GetName(), fr_service.GetType(), fr_service.GetDomain(), ResolveCallback, &fr_service);
if( err != kDNSServiceErr_NoError )
{
if (sdRef)
DNSServiceRefDeallocate(sdRef);
CLog::Log(LOGERROR, "ZeroconfBrowserWIN: DNSServiceResolve returned (error = %ld)", (int) err);
return false;
}
err = DNSServiceProcessResult(sdRef);
if (err != kDNSServiceErr_NoError)
CLog::Log(LOGERROR, "ZeroconfBrowserWIN::doResolveService DNSServiceProcessResult returned (error = %ld)", (int) err);
if (sdRef)
DNSServiceRefDeallocate(sdRef);
return true;
}
static void
_ptpip_enumerate (
DNSServiceRef sdRef, DNSServiceFlags flags,
uint32_t interfaceIndex, DNSServiceErrorType errorCode,
const char *serviceName, const char *regtype, const char *replyDomain,
void *context
) {
struct mdnsinfo mdnsi;
DNSServiceRef sd;
if (errorCode != kDNSServiceErr_NoError) {
gp_log (GP_LOG_ERROR, "ptpip", "Error on _ptp._tcp query.");
return;
}
gp_log (GP_LOG_DEBUG, "ptpip", "found %s, %s, %s", serviceName, regtype, replyDomain);
mdnsi.list = context;
mdnsi.name = serviceName;
DNSServiceResolve (&sd,
0,
interfaceIndex,
serviceName,
regtype,
replyDomain,
_ptpip_resolved,
&mdnsi
);
DNSServiceProcessResult (sd);
DNSServiceRefDeallocate (sd);
}
void browseCB_( DNSServiceFlags flags, uint32_t interfaceIdx,
DNSServiceErrorType error, const char* name,
const char* type, const char* domain )
{
if( error != kDNSServiceErr_NoError)
{
LBWARN << "Browse callback error: " << error << std::endl;
return;
}
if( !( flags & kDNSServiceFlagsAdd ))
return;
browsedName_ = name;
DNSServiceRef service = 0;
const DNSServiceErrorType resolve =
DNSServiceResolve( &service, 0, interfaceIdx, name, type, domain,
(DNSServiceResolveReply)resolveCBS_, this );
if( resolve != kDNSServiceErr_NoError)
LBWARN << "DNSServiceResolve error: " << resolve << std::endl;
if( service )
{
handleEvents_( service, 500 );
DNSServiceRefDeallocate( service );
}
}
void BonjourServiceResolver::resolveBonjourRecord( const BonjourRecord& record )
{
if( isResolving() )
{
qWarning("resolve in process, aborting");
return;
}
const DNSServiceErrorType err = DNSServiceResolve( &d->dnssref, 0, 0, record.serviceName.toUtf8().constData(), record.registeredType.toUtf8().constData(),
record.replyDomain.toUtf8().constData(), Private::bonjourResolveReply, d );
if( err != kDNSServiceErr_NoError )
{
error( err );
}
else
{
const int sockfd = DNSServiceRefSockFD( d->dnssref );
if( sockfd == -1 )
{
error( kDNSServiceErr_Invalid );
}
else
{
Q_ASSERT( d->bonjourSocket == 0 );
d->bonjourSocket = new QSocketNotifier( sockfd, QSocketNotifier::Read, this );
connect( d->bonjourSocket, SIGNAL( activated( int ) ), this, SLOT( bonjourSocketReadyRead() ) );
}
}
}
void MDnsSdListener::Handler::resolveService(SocketClient *cli, int requestId,
const char *interfaceName, const char *serviceName, const char *regType,
const char *domain) {
if (VDBG) {
ALOGD("resolveService(%d, %s, %s, %s, %s)", requestId, interfaceName,
serviceName, regType, domain);
}
Context *context = new Context(requestId, mListener);
DNSServiceRef *ref = mMonitor->allocateServiceRef(requestId, context);
if (ref == NULL) {
ALOGE("request Id %d already in use during resolve call", requestId);
cli->sendMsg(ResponseCode::CommandParameterError,
"RequestId already in use during resolve call", false);
return;
}
DNSServiceFlags nativeFlags = 0;
int interfaceInt = ifaceNameToI(interfaceName);
DNSServiceErrorType result = DNSServiceResolve(ref, nativeFlags, interfaceInt, serviceName,
regType, domain, &MDnsSdListenerResolveCallback, context);
if (result != kDNSServiceErr_NoError) {
ALOGE("service resolve request %d got an error from DNSServiceResolve %d", requestId,
result);
mMonitor->freeServiceRef(requestId);
cli->sendMsg(ResponseCode::CommandParameterError,
"resolveService got an error from DNSServiceResolve", false);
return;
}
mMonitor->startMonitoring(requestId);
if (VDBG) ALOGD("resolveService successful");
cli->sendMsg(ResponseCode::CommandOkay, "resolveService started", false);
return;
}
STDMETHODIMP CDNSSD::Resolve(DNSSDFlags flags, ULONG ifIndex, BSTR serviceName, BSTR regType, BSTR domain, IResolveListener* listener, IDNSSDService** service)
{
CComObject<CDNSSDService> * object = NULL;
std::string serviceNameUTF8;
std::string regTypeUTF8;
std::string domainUTF8;
DNSServiceRef sref = NULL;
DNSServiceErrorType err = 0;
HRESULT hr = 0;
BOOL ok;
// Initialize
*service = NULL;
// Convert BSTR params to utf8
ok = BSTRToUTF8( serviceName, serviceNameUTF8 );
require_action( ok, exit, err = kDNSServiceErr_BadParam );
ok = BSTRToUTF8( regType, regTypeUTF8 );
require_action( ok, exit, err = kDNSServiceErr_BadParam );
ok = BSTRToUTF8( domain, domainUTF8 );
require_action( ok, exit, err = kDNSServiceErr_BadParam );
try
{
object = new CComObject<CDNSSDService>();
}
catch ( ... )
{
object = NULL;
}
require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
hr = object->FinalConstruct();
require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
object->AddRef();
err = DNSServiceResolve( &sref, flags, ifIndex, serviceNameUTF8.c_str(), regTypeUTF8.c_str(), domainUTF8.c_str(), ( DNSServiceResolveReply ) &ResolveReply, object );
require_noerr( err, exit );
object->SetServiceRef( sref );
object->SetListener( listener );
err = object->Run();
require_noerr( err, exit );
*service = object;
exit:
if ( err && object )
{
object->Release();
}
return err;
}
static void do_smb_resolve(struct mdns_smbsrv_result *browsesrv)
{
DNSServiceRef mdns_conn_sdref = NULL;
int mdnsfd;
int fdsetsz;
int ret;
fd_set *fdset = NULL;
struct timeval tv;
DNSServiceErrorType err;
TALLOC_CTX * ctx = talloc_tos();
err = DNSServiceResolve(&mdns_conn_sdref, 0 /* flags */,
browsesrv->ifIndex,
browsesrv->serviceName, browsesrv->regType, browsesrv->domain,
do_smb_resolve_reply, NULL);
if (err != kDNSServiceErr_NoError) {
return;
}
mdnsfd = DNSServiceRefSockFD(mdns_conn_sdref);
for (;;) {
if (fdset != NULL) {
TALLOC_FREE(fdset);
}
if (mdnsfd < 0 || mdnsfd >= FD_SETSIZE) {
errno = EBADF;
break;
}
fdsetsz = howmany(mdnsfd + 1, NFDBITS) * sizeof(fd_mask);
fdset = TALLOC_ZERO(ctx, fdsetsz);
FD_SET(mdnsfd, fdset);
tv.tv_sec = 1;
tv.tv_usec = 0;
/* Wait until response received from mDNS daemon */
ret = sys_select(mdnsfd + 1, fdset, NULL, NULL, &tv);
if (ret <= 0 && errno != EINTR) {
break;
}
if (FD_ISSET(mdnsfd, fdset)) {
/* Invoke callback function */
DNSServiceProcessResult(mdns_conn_sdref);
break;
}
}
TALLOC_FREE(fdset);
DNSServiceRefDeallocate(mdns_conn_sdref);
}
static void
browse_reply (DNSServiceRef client,
DNSServiceFlags flags,
uint32_t ifIndex,
DNSServiceErrorType errorCode,
const char *replyName,
const char *replyType,
const char *replyDomain,
void *context)
{
DNSServiceErrorType err;
GMDNSServer *server;
GMDNSUserData *ud = context;
GMDNSUserData *ud2;
gboolean remove = (flags & kDNSServiceFlagsAdd) ? FALSE : TRUE;
if (!remove) {
server = g_new0 (GMDNSServer, 1);
server->mdnsname = g_strdup (replyName);
ud2 = g_new0 (GMDNSUserData, 1);
err = DNSServiceResolve (&ud2->client, 0, kDNSServiceInterfaceIndexAny,
server->mdnsname,
"_daap._tcp", "local",
resolve_reply, ud2);
if (err != kDNSServiceErr_NoError) {
g_warning ("Couldn't do ServiceResolv");
g_free (server->mdnsname);
g_free (server);
return;
}
ud2->server = server;
g_mdns_poll_add (ud->mdns, ud2, ud2->client);
} else {
GSList *n, *nxt;
g_mutex_lock (ud->mdns->mutex);
for (n = ud->mdns->service_list; n; n = nxt) {
nxt = g_slist_next (n);
GMDNSServer *server = n->data;
if (strcmp (server->mdnsname, replyName) == 0) {
n = ud->mdns->service_list = g_slist_remove (ud->mdns->service_list, server);
g_mutex_unlock (ud->mdns->mutex);
if (ud->mdns->callback)
ud->mdns->callback (ud->mdns, G_MDNS_SERVER_REMOVE, server, ud->mdns->user_data);
g_mdns_server_destroy (server);
g_mutex_lock (ud->mdns->mutex);
}
}
g_mutex_unlock (ud->mdns->mutex);
}
}
void RemoteService::resolveAsync()
{
K_D;
if (d->isRunning()) return;
d->m_resolved = false;
kDebug() << this << ":Starting resolve of : " << d->m_serviceName << " " << d->m_type << " " << d->m_domain << "\n";
DNSServiceRef ref;
if (DNSServiceResolve(&ref,0,0,d->m_serviceName.toUtf8(), d->m_type.toAscii().constData(),
domainToDNS(d->m_domain),(DNSServiceResolveReply)resolve_callback,reinterpret_cast<void*>(d))
== kDNSServiceErr_NoError) d->setRef(ref);
if (!d->isRunning()) emit resolved(false);
}
/*
* Handle newly-discovered services
*/
static void
browser_callback(
__unused DNSServiceRef sdRef,
DNSServiceFlags servFlags,
uint32_t interfaceIndex,
DNSServiceErrorType errorCode,
const char *serviceName,
const char *regType,
const char *replyDomain,
__unused void *context)
{
DNSServiceErrorType err;
CFSocketContext ctx = { 0, NULL, NULL, NULL, NULL };
struct cbinfo *info;
if (errorCode != kDNSServiceErr_NoError) {
printf("DNS service discovery error: %d\n", errorCode);
return;
}
#ifdef DEBUG
printf("browse: %s: %s, %s, %s\n",
(servFlags & kDNSServiceFlagsAdd) ? "new" : "gone",
serviceName, regType, replyDomain);
#endif
if (!(servFlags & kDNSServiceFlagsAdd))
return;
info = malloc(sizeof(*info));
if (!info) {
printf("browse: out of memeory\n");
return;
}
err = DNSServiceResolve(&info->sdref, servFlags, interfaceIndex, serviceName, regType, replyDomain, resolve_callback, info);
if (err != kDNSServiceErr_NoError) {
printf("DNSServiceResolve failed: %d\n", err);
free(info);
return;
}
ctx.info = (void*)info;
info->sockref = CFSocketCreateWithNative(kCFAllocatorDefault, DNSServiceRefSockFD(info->sdref),
kCFSocketReadCallBack, socket_callback, &ctx);
if (!info->sockref) {
printf("CFSocketCreateWithNative failed\n");
DNSServiceRefDeallocate(info->sdref);
free(info);
return;
}
info->rls = CFSocketCreateRunLoopSource(kCFAllocatorDefault, info->sockref, 1);
CFRunLoopAddSource(CFRunLoopGetCurrent(), info->rls, kCFRunLoopDefaultMode);
}
/*! @brief Starts the resolving service. Effectively, onResolveResults is called sometime later when the resolve is completed.
This is done using a QSocketNotifer to monitor activity on the socket used by the DNSServiceResolve.
When activity is observe DNSServiceProcessResult is called, which in turn calls the onResolveResults
@param iface
@param name
@param type
@param domain
*/
void BonjourServiceResolver::startServiceResolve(uint32_t iface, const char* name, const char* type, const char* domain)
{
DNSServiceErrorType err = DNSServiceResolve(&m_ref, 0, iface, name, type, domain, onResolveResults, this);
if (err != kDNSServiceErr_NoError)
debug << "BonjourServiceResolver::startServiceResolve. DNSServiceResolve failed for " << name << " " << type << endl;
else
{
m_sockfd = DNSServiceRefSockFD(m_ref);
if (m_sockfd != -1)
{ // setup a notifier to call onResolveSocketRead every time the socket is read
m_notifier = new QSocketNotifier(m_sockfd, QSocketNotifier::Read, this);
connect(m_notifier, SIGNAL(activated(int)), this, SLOT(onSocketRead()));
}
}
void QZeroConfPrivate::resolve(void)
{
DNSServiceErrorType err;
err = DNSServiceResolve(&resolver, kDNSServiceFlagsTimeout, newService->interface, newService->name.toUtf8(), newService->type.toUtf8(), newService->domain.toUtf8(), (DNSServiceResolveReply) resolverCallback, this);
if (err == kDNSServiceErr_NoError) {
int sockfd = DNSServiceRefSockFD(resolver);
if (sockfd == -1) {
cleanUp(resolver);
}
else {
resolverSocket = new QSocketNotifier(sockfd, QSocketNotifier::Read, this);
connect(resolverSocket, SIGNAL(activated(int)), this, SLOT(resolverRead()));
}
}
DNSServiceErrorType DNSSDPluginAPI::resolve_init(DNSServiceRef* sdref,
uint32_t ifnum,
const std::string& name,
const std::string& regtype,
const std::string& domain,
void* context) {
return DNSServiceResolve(sdref,
0,
ifnum,
name.c_str(),
regtype.c_str(),
domain.c_str(),
DNSSDPluginAPI::resolve_callback,
context);
}
OSStatus
CSecondPage::StartResolve( Service * service )
{
CPrinterSetupWizardSheet * psheet;
OSStatus err = kNoErr;
psheet = reinterpret_cast<CPrinterSetupWizardSheet*>(GetParent());
require_quiet( psheet, exit );
check( service->serviceRef == NULL );
//
// clean out any queues that were collected during a previous
// resolve
//
service->EmptyQueues();
//
// now start the new resolve
//
err = DNSServiceResolve( &service->serviceRef, 0, 0, service->printer->name.c_str(), service->type.c_str(), service->domain.c_str(), (DNSServiceResolveReply) OnResolve, service );
require_noerr( err, exit );
err = StartOperation( service->serviceRef );
require_noerr( err, exit );
//
// If we're not currently resolving, then disable the next button
// and set the cursor to hourglass
//
if ( !service->printer->resolving )
{
psheet->SetWizardButtons( PSWIZB_BACK );
psheet->m_active = psheet->m_wait;
SetCursor(psheet->m_active);
}
service->printer->resolving++;
exit:
return err;
}
bool Client::resolve( const std::string& service, const std::string& type,
const std::string& domain )
{
m_to = service;
m_rRef = 0;
DNSServiceErrorType e = DNSServiceResolve( &m_rRef, 0, m_interface, service.c_str(), type.c_str(),
domain.c_str(), &handleResolveReply, this );
if( e != kDNSServiceErr_NoError )
{
DNSServiceRefDeallocate( m_rRef );
m_rRef = 0;
return false;
}
m_currentRef = m_rRef;
return true;
}
/**
* \brief main resolve function
*/
ServiceObject BonjourResolver::do_resolve() {
debug(LOG_DEBUG, DEBUG_LOG, 0, "start resolving");
DNSServiceRef sdRef = NULL;
DNSServiceResolve(&sdRef, 0, kDNSServiceInterfaceIndexAny,
_key.name().c_str(), _key.type().c_str(),
_key.domain().c_str(),
discover::resolvereply_callback, this);
int error;
do {
error = DNSServiceProcessResult(sdRef);
} while (error == kDNSServiceErr_NoError);
if (sdRef) {
close(DNSServiceRefSockFD(sdRef));
DNSServiceRefDeallocate(sdRef);
sdRef = NULL;
}
debug(LOG_DEBUG, DEBUG_LOG, 0, "resolution complete");
return _object;
}
void BonjourServiceResolver::resolveBonjourRecord(const BonjourRecord &record) {
ResolveRecord *rr = new ResolveRecord(record, this);
DNSServiceErrorType err = DNSServiceResolve(& rr->dnssref, 0, 0,
record.serviceName.toUtf8().constData(),
record.registeredType.toUtf8().constData(),
record.replyDomain.toUtf8().constData(),
(DNSServiceResolveReply)bonjourResolveReply, rr);
if (err == kDNSServiceErr_NoError) {
int sockfd = DNSServiceRefSockFD(rr->dnssref);
if (sockfd == -1) {
err = kDNSServiceErr_Invalid;
} else {
rr->bonjourSocket = new QSocketNotifier(sockfd, QSocketNotifier::Read, this);
connect(rr->bonjourSocket, SIGNAL(activated(int)), this, SLOT(bonjourSocketReadyRead(int)), Qt::QueuedConnection);
qmResolvers.insert(sockfd, rr);
return;
}
}
static void do_smb_resolve(struct mdns_smbsrv_result *browsesrv)
{
DNSServiceRef mdns_conn_sdref = NULL;
int mdnsfd;
int fdsetsz;
int ret;
struct timeval tv;
DNSServiceErrorType err;
TALLOC_CTX * ctx = talloc_tos();
err = DNSServiceResolve(&mdns_conn_sdref, 0 /* flags */,
browsesrv->ifIndex,
browsesrv->serviceName, browsesrv->regType, browsesrv->domain,
do_smb_resolve_reply, NULL);
if (err != kDNSServiceErr_NoError) {
return;
}
mdnsfd = DNSServiceRefSockFD(mdns_conn_sdref);
for (;;) {
int revents;
ret = poll_one_fd(mdnsfd, POLLIN|POLLHUP, 1000, &revents);
if (ret <= 0 && errno != EINTR) {
break;
}
if (revents & (POLLIN|POLLHUP|POLLERR)) {
/* Invoke callback function */
DNSServiceProcessResult(mdns_conn_sdref);
break;
}
}
TALLOC_FREE(fdset);
DNSServiceRefDeallocate(mdns_conn_sdref);
}
nsresult
ResolveOperator::Start()
{
nsresult rv;
if (NS_WARN_IF(NS_FAILED(rv = MDNSResponderOperator::Start()))) {
return rv;
}
nsAutoCString name;
mServiceInfo->GetServiceName(name);
nsAutoCString type;
mServiceInfo->GetServiceType(type);
nsAutoCString domain;
mServiceInfo->GetDomainName(domain);
LOG_I("Resolve: (%s), (%s), (%s)", name.get(), type.get(), domain.get());
DNSServiceRef service = nullptr;
DNSServiceErrorType err =
DNSServiceResolve(&service,
0,
kDNSServiceInterfaceIndexAny,
name.get(),
type.get(),
domain.get(),
(DNSServiceResolveReply)&ResolveReplyRunnable::Reply,
this);
if (NS_WARN_IF(kDNSServiceErr_NoError != err)) {
if (mListener) {
mListener->OnResolveFailed(mServiceInfo, err);
}
return NS_ERROR_FAILURE;
}
mDeleteProtector = this;
return ResetService(service);
}
OSStatus ExplorerBarWindow::StartResolve( ServiceInfo *inService )
{
OSStatus err;
check( inService );
// Stop any current resolve that may be in progress.
StopResolve();
// Resolve the service.
err = DNSServiceResolve( &mResolveServiceRef, 0, 0,
inService->name, inService->type, inService->domain, (DNSServiceResolveReply) ResolveCallBack, inService->handler );
require_noerr( err, exit );
err = WSAAsyncSelect((SOCKET) DNSServiceRefSockFD(mResolveServiceRef), m_hWnd, WM_PRIVATE_SERVICE_EVENT, FD_READ|FD_CLOSE);
require_noerr( err, exit );
m_serviceRefs.push_back(mResolveServiceRef);
exit:
return( err );
}
bool CZeroconfBrowserMDNS::doResolveService(CZeroconfBrowser::ZeroconfService& fr_service, double f_timeout)
{
DNSServiceErrorType err;
DNSServiceRef sdRef = NULL;
//start resolving
m_resolving_service = fr_service;
m_resolved_event.Reset();
err = DNSServiceResolve(&sdRef, 0, kDNSServiceInterfaceIndexAny, fr_service.GetName(), fr_service.GetType(), fr_service.GetDomain(), ResolveCallback, this);
if( err != kDNSServiceErr_NoError )
{
if (sdRef)
DNSServiceRefDeallocate(sdRef);
CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: DNSServiceResolve returned (error = %ld)", (int) err);
return false;
}
err = DNSServiceProcessResult(sdRef);
if (err != kDNSServiceErr_NoError)
CLog::Log(LOGERROR, "ZeroconfBrowserMDNS::doResolveService DNSServiceProcessResult returned (error = %ld)", (int) err);
if (sdRef)
DNSServiceRefDeallocate(sdRef);
#if defined(HAS_MDNS_EMBEDDED)
// when using the embedded mdns service the call to DNSServiceProcessResult
// above will not block until the resolving was finished - instead we have to
// wait for resolve to return or timeout
m_resolved_event.WaitMSec(f_timeout * 1000);
#endif //HAS_MDNS_EMBEDDED
fr_service = m_resolving_service;
return (!fr_service.GetIP().empty());
}
static void DNSSD_API KprZeroconfPlatformBrowseCallback(DNSServiceRef serviceRef, DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char* name, const char* type, const char* domain, void* context)
{
FskErr err = kFskErrNone;
KprZeroconfBrowser self = context;
KprZeroconfPlatformBrowser browser = self->platform;
char* serviceType = self->serviceType;
KprZeroconfPlatformService service = NULL;
if (!serviceType) {
service = KprZeroconfPlatformServiceFind(browser->types, serviceRef);
if (service)
serviceType = service->name;
}
if (!serviceType || (errorCode != kDNSServiceErr_NoError)) {
FskInstrumentedItemPrintfDebug(browser, "KprZeroconfPlatformBrowseCallback returned %d\n", errorCode);
}
else if (flags & kDNSServiceFlagsAdd) {
DNSServiceErrorType error;
DNSServiceRef resolveRef;
KprZeroconfPlatformService resolver = NULL;
FskInstrumentedItemPrintfDebug(browser, "ADD: %d %s %s %s", interfaceIndex, name, type, domain);
error = DNSServiceResolve(&resolveRef, kDNSServiceFlagsForceMulticast, interfaceIndex, name, type, domain, KprZeroconfPlatformResolveCallBack, self);
if (error != kDNSServiceErr_NoError) {
bailIfError(kFskErrNetworkErr);
}
bailIfError(KprZeroconfPlatformServiceNew(&resolver, service, resolveRef, name, 0));
FskListAppend(&browser->services, resolver);
}
else {
KprZeroconfServiceInfo serviceInfo = NULL;
KprZeroconfServiceInfoNew(&serviceInfo, type, name, NULL, NULL, 0, NULL);
KprZeroconfBrowserServiceDown(self, serviceInfo);
FskInstrumentedItemPrintfDebug(browser, "REMOVE: %d %s %s %s", interfaceIndex, name, type, domain);
}
bail:
return;
}
JNIEXPORT jint JNICALL Java_com_apple_dnssd_AppleResolver_CreateResolver( JNIEnv *pEnv, jobject pThis,
jint flags, jint ifIndex, jstring serviceName, jstring regType, jstring domain)
{
jclass cls = (*pEnv)->GetObjectClass( pEnv, pThis);
jfieldID contextField = (*pEnv)->GetFieldID( pEnv, cls, "fNativeContext", "J");
OpContext *pContext = NULL;
DNSServiceErrorType err = kDNSServiceErr_NoError;
if ( contextField != 0)
pContext = NewContext( pEnv, pThis, "serviceResolved",
"(Lcom/apple/dnssd/DNSSDService;IILjava/lang/String;Ljava/lang/String;ILcom/apple/dnssd/TXTRecord;)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);
err = DNSServiceResolve( &pContext->ServiceRef, flags, ifIndex,
servStr, regStr, domainStr, ServiceResolveReply, pContext);
if ( err == kDNSServiceErr_NoError)
{
(*pEnv)->SetLongField(pEnv, pThis, contextField, (long) pContext);
}
SafeReleaseUTFChars( pEnv, serviceName, servStr);
SafeReleaseUTFChars( pEnv, regType, regStr);
SafeReleaseUTFChars( pEnv, domain, domainStr);
}
else
err = kDNSServiceErr_NoMemory;
return err;
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
const char *opt, /* Current option character */
*name = NULL, /* Service name */
*type = "_ipp._tcp", /* Service type */
*domain = "local."; /* Service domain */
#ifdef HAVE_DNSSD
DNSServiceRef ref; /* Browsing service reference */
#endif /* HAVE_DNSSD */
#ifdef HAVE_AVAHI
AvahiClient *client; /* Client information */
int error; /* Error code, if any */
#endif /* HAVE_AVAHI */
for (i = 1; i < argc; i ++)
if (!strcmp(argv[i], "snmp"))
snmponly = 1;
else if (!strcmp(argv[i], "ipp"))
ipponly = 1;
else
{
puts("Usage: ./ipp-printers [{ipp | snmp}]");
return (1);
}
/*
* Create an array to track devices...
*/
devices = cupsArrayNew((cups_array_func_t)compare_devices, NULL);
/*
* Browse for different kinds of printers...
*/
if (DNSServiceCreateConnection(&main_ref) != kDNSServiceErr_NoError)
{
perror("ERROR: Unable to create service connection");
return (1);
}
fd = DNSServiceRefSockFD(main_ref);
ipp_ref = main_ref;
DNSServiceBrowse(&ipp_ref, kDNSServiceFlagsShareConnection, 0,
"_ipp._tcp", NULL, browse_callback, devices);
/*
* Loop until we are killed...
*/
progress();
for (;;)
{
FD_ZERO(&input);
FD_SET(fd, &input);
timeout.tv_sec = 2;
timeout.tv_usec = 500000;
if (select(fd + 1, &input, NULL, NULL, &timeout) <= 0)
{
time_t curtime = time(NULL);
for (device = (cups_device_t *)cupsArrayFirst(devices);
device;
device = (cups_device_t *)cupsArrayNext(devices))
if (!device->got_resolve)
{
if (!device->ref)
break;
if ((curtime - device->resolve_time) > 10)
{
device->got_resolve = -1;
fprintf(stderr, "\rUnable to resolve \"%s\": timeout\n",
device->name);
progress();
}
else
break;
}
if (!device)
break;
}
if (FD_ISSET(fd, &input))
{
/*
* Process results of our browsing...
*/
progress();
DNSServiceProcessResult(main_ref);
}
else
{
/*
* Query any devices we've found...
*/
DNSServiceErrorType status; /* DNS query status */
int count; /* Number of queries */
for (device = (cups_device_t *)cupsArrayFirst(devices), count = 0;
device;
device = (cups_device_t *)cupsArrayNext(devices))
{
if (!device->ref && !device->sent)
{
/*
* Found the device, now get the TXT record(s) for it...
*/
if (count < 50)
{
device->resolve_time = time(NULL);
device->ref = main_ref;
status = DNSServiceResolve(&(device->ref),
kDNSServiceFlagsShareConnection,
0, device->name, device->regtype,
device->domain, resolve_callback,
device);
if (status != kDNSServiceErr_NoError)
{
fprintf(stderr, "\rUnable to resolve \"%s\": %d\n",
device->name, status);
progress();
}
else
count ++;
}
}
else if (!device->sent && device->got_resolve)
{
/*
* Got the TXT records, now report the device...
*/
DNSServiceRefDeallocate(device->ref);
device->ref = 0;
device->sent = 1;
}
}
}
}
#ifndef DEBUG
fprintf(stderr, "\rFound %d printers. Now querying for capabilities...\n",
cupsArrayCount(devices));
#endif /* !DEBUG */
puts("#!/bin/sh -x");
puts("test -d results && rm -rf results");
puts("mkdir results");
puts("CUPS_DEBUG_LEVEL=6; export CUPS_DEBUG_LEVEL");
puts("CUPS_DEBUG_FILTER='^(ipp|http|_ipp|_http|cupsGetResponse|cupsSend|"
"cupsWrite|cupsDo).*'; export CUPS_DEBUG_FILTER");
for (device = (cups_device_t *)cupsArrayFirst(devices);
device;
device = (cups_device_t *)cupsArrayNext(devices))
{
if (device->got_resolve <= 0 || device->cups_shared)
continue;
#ifdef DEBUG
fprintf(stderr, "Checking \"%s\" (got_resolve=%d, cups_shared=%d, uri=%s)\n",
device->name, device->got_resolve, device->cups_shared, device->uri);
#else
fprintf(stderr, "Checking \"%s\"...\n", device->name);
#endif /* DEBUG */
if ((http = httpConnect(device->host, device->port)) == NULL)
{
fprintf(stderr, "Failed to connect to \"%s\": %s\n", device->name,
cupsLastErrorString());
continue;
}
request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
device->uri);
response = cupsDoRequest(http, request, device->rp);
if (cupsLastError() > IPP_OK_SUBST)
fprintf(stderr, "Failed to query \"%s\": %s\n", device->name,
cupsLastErrorString());
else
{
if ((attr = ippFindAttribute(response, "ipp-versions-supported",
IPP_TAG_KEYWORD)) != NULL)
{
version = attr->values[0].string.text;
for (i = 1; i < attr->num_values; i ++)
if (strcmp(attr->values[i].string.text, version) > 0)
version = attr->values[i].string.text;
}
else
version = "1.0";
testfile = NULL;
if ((attr = ippFindAttribute(response, "document-format-supported",
IPP_TAG_MIMETYPE)) != NULL)
{
/*
* Figure out the test file for printing, preferring PDF and PostScript
* over JPEG and plain text...
*/
for (i = 0; i < attr->num_values; i ++)
{
if (!strcasecmp(attr->values[i].string.text, "application/pdf"))
{
testfile = "testfile.pdf";
break;
}
else if (!strcasecmp(attr->values[i].string.text,
"application/postscript"))
testfile = "testfile.ps";
else if (!strcasecmp(attr->values[i].string.text, "image/jpeg") &&
!testfile)
testfile = "testfile.jpg";
else if (!strcasecmp(attr->values[i].string.text, "text/plain") &&
!testfile)
testfile = "testfile.txt";
else if (!strcasecmp(attr->values[i].string.text,
"application/vnd.hp-PCL") && !testfile)
testfile = "testfile.pcl";
}
if (!testfile)
{
fprintf(stderr,
"Printer \"%s\" reports the following IPP file formats:\n",
device->name);
for (i = 0; i < attr->num_values; i ++)
fprintf(stderr, " \"%s\"\n", attr->values[i].string.text);
}
}
if (!testfile && device->pdl)
{
char *pdl, /* Copy of pdl string */
*start, *end; /* Pointers into pdl string */
pdl = strdup(device->pdl);
for (start = device->pdl; start && *start; start = end)
{
if ((end = strchr(start, ',')) != NULL)
*end++ = '\0';
if (!strcasecmp(start, "application/pdf"))
{
testfile = "testfile.pdf";
break;
}
else if (!strcasecmp(start, "application/postscript"))
testfile = "testfile.ps";
else if (!strcasecmp(start, "image/jpeg") && !testfile)
testfile = "testfile.jpg";
else if (!strcasecmp(start, "text/plain") && !testfile)
testfile = "testfile.txt";
else if (!strcasecmp(start, "application/vnd.hp-PCL") && !testfile)
testfile = "testfile.pcl";
}
free(pdl);
if (testfile)
{
fprintf(stderr,
"Using \"%s\" for printer \"%s\" based on TXT record pdl "
"info.\n", testfile, device->name);
}
else
{
fprintf(stderr,
"Printer \"%s\" reports the following TXT file formats:\n",
device->name);
fprintf(stderr, " \"%s\"\n", device->pdl);
}
}
if (!device->ty &&
(attr = ippFindAttribute(response, "printer-make-and-model",
IPP_TAG_TEXT)) != NULL)
device->ty = strdup(attr->values[0].string.text);
if (strcmp(version, "1.0") && testfile && device->ty)
{
char filename[1024], /* Filename */
*fileptr; /* Pointer into filename */
const char *typtr; /* Pointer into ty */
if (!strncasecmp(device->ty, "DeskJet", 7) ||
!strncasecmp(device->ty, "DesignJet", 9) ||
!strncasecmp(device->ty, "OfficeJet", 9) ||
!strncasecmp(device->ty, "Photosmart", 10))
strlcpy(filename, "HP_", sizeof(filename));
else
filename[0] = '\0';
fileptr = filename + strlen(filename);
if (!strncasecmp(device->ty, "Lexmark International Lexmark", 29))
typtr = device->ty + 22;
else
typtr = device->ty;
while (*typtr && fileptr < (filename + sizeof(filename) - 1))
{
if (isalnum(*typtr & 255) || *typtr == '-')
*fileptr++ = *typtr++;
else
{
*fileptr++ = '_';
typtr++;
}
}
*fileptr = '\0';
printf("# %s\n", device->name);
printf("echo \"Testing %s...\"\n", device->name);
if (!ipponly)
{
printf("echo \"snmpwalk -c public -v 1 -Cc %s 1.3.6.1.2.1.25 "
"1.3.6.1.2.1.43 1.3.6.1.4.1.2699.1\" > results/%s.snmpwalk\n",
device->host, filename);
printf("snmpwalk -c public -v 1 -Cc %s 1.3.6.1.2.1.25 "
"1.3.6.1.2.1.43 1.3.6.1.4.1.2699.1 | "
"tee -a results/%s.snmpwalk\n",
device->host, filename);
}
if (!snmponly)
{
printf("echo \"./ipptool-static -tIf %s -T 30 -d NOPRINT=1 -V %s %s "
"ipp-%s.test\" > results/%s.log\n", testfile, version,
device->uri, version, filename);
printf("CUPS_DEBUG_LOG=results/%s.debug_log "
"./ipptool-static -tIf %s -T 30 -d NOPRINT=1 -V %s %s "
"ipp-%s.test | tee -a results/%s.log\n", filename,
testfile, version, device->uri,
version, filename);
}
puts("");
}
else if (!device->ty)
fprintf(stderr,
"Ignoring \"%s\" since it doesn't provide a make and model.\n",
device->name);
else if (!testfile)
fprintf(stderr,
"Ignoring \"%s\" since it does not support a common format.\n",
device->name);
else
fprintf(stderr, "Ignoring \"%s\" since it only supports IPP/1.0.\n",
device->name);
}
ippDelete(response);
httpClose(http);
}
return (0);
}
