自学教程：C++ DNSServiceRefDeallocate函数代码示例

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;}

void CZeroconfMDNS::doStop(){  {    CSingleLock lock(m_data_guard);    CLog::Log(LOGDEBUG, "ZeroconfMDNS: Shutdown services");    for(tServiceMap::iterator it = m_services.begin(); it != m_services.end(); ++it)    {      DNSServiceRefDeallocate(it->second.serviceRef);      TXTRecordDeallocate(&it->second.txtRecordRef);      CLog::Log(LOGDEBUG, "ZeroconfMDNS: Removed service %s", it->first.c_str());    }    m_services.clear();  }  {    CSingleLock lock(m_data_guard);#if defined(TARGET_WINDOWS_STORE)    CLog::Log(LOGERROR, "ZeroconfMDNS: WSAAsyncSelect not yet supported for TARGET_WINDOWS_STORE");#else    WSAAsyncSelect( (SOCKET) DNSServiceRefSockFD( m_service ), g_hWnd, BONJOUR_EVENT, 0 );#endif //TARGET_WINDOWS    if (m_service)      DNSServiceRefDeallocate(m_service);    m_service = NULL;  }}

void FreeOutAll(void){	struct connection_out *next = Outbound_Control.head;	struct connection_out *now;	Outbound_Control.head = NULL;	Outbound_Control.active = 0;	while (next) {		now = next;		next = now->next;		LEVEL_DEBUG("Freeing outbound %s #%d",now->zero.name,now->index);		SAFEFREE(now->zero.name) ;		SAFEFREE(now->zero.type) ;		SAFEFREE(now->zero.domain) ;		SAFEFREE(now->name) ;		SAFEFREE(now->host) ;		SAFEFREE(now->service) ;		if (now->ai) {			freeaddrinfo(now->ai);			now->ai = NULL;		}#if OW_ZERO		if (libdnssd != NULL) {			if (now->sref0) {				DNSServiceRefDeallocate(now->sref0);			}			if (now->sref1) {				DNSServiceRefDeallocate(now->sref1);			}		}#endif		owfree(now);	}}

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;}

voidplayer_sd_fini(player_sd_t* sd){  int i;  player_sd_mdns_t* mdns = (player_sd_mdns_t*)(sd->sdRef);  if(mdns->browseRef_valid)  {    DNSServiceRefDeallocate(mdns->browseRef);    mdns->browseRef_valid = 0;  }  for(i=0;i<mdns->mdnsDevs_len;i++)  {    if(mdns->mdnsDevs[i].valid)    {      DNSServiceRefDeallocate(mdns->mdnsDevs[i].regRef);      mdns->mdnsDevs[i].valid = 0;    }  }    pthread_mutex_destroy(&(mdns->mutex));  if(mdns->mdnsDevs)    free(mdns->mdnsDevs);  free(mdns);  free(sd);}

OSStatusCConfigPropertySheet::TearDownBrowsing(){	OSStatus err = kNoErr;	if ( m_browseDomainsRef )	{		err = WSAAsyncSelect( DNSServiceRefSockFD( m_browseDomainsRef ), m_hWnd, 0, 0 );		check_noerr( err );		DNSServiceRefDeallocate( m_browseDomainsRef );			m_browseDomainsRef = NULL;	}	if ( m_regDomainsRef )	{		err = WSAAsyncSelect( DNSServiceRefSockFD( m_regDomainsRef ), m_hWnd, 0, 0 );		check_noerr( err );		DNSServiceRefDeallocate( m_regDomainsRef );			m_regDomainsRef = NULL;	}	return err;}

void TerminateGameService() {	if ( localServer ) {		localServer = false;	}	DNSServiceRefDeallocate( serviceRef );	memset( serviceInterfaces, 0, sizeof( serviceInterfaces ) );}

static intmdns_main_free(void){  struct mdns_service *s;  struct mdns_browser *mb;  struct mdns_record *r;  for(s = mdns_services; mdns_services; s = mdns_services)    {      mdns_services = s->next;      mdns_service_free(s);    }  for (mb = mdns_browsers; mdns_browsers; mb = mdns_browsers)    {      mdns_browsers = mb->next;      mdns_browser_free(mb);    }  for (r = mdns_records; mdns_records; r = mdns_records)    {      mdns_records = r->next;      mdns_record_free(r);    }  if(mdns_ev_main)    event_free(mdns_ev_main);  mdns_ev_main = NULL;  if(mdns_sdref_main)    DNSServiceRefDeallocate(mdns_sdref_main);  mdns_sdref_main = NULL;  return -1;}

static intmdns_resolver_free(struct mdns_resolver *rs) {  struct mdns_addr_lookup *lu;  if (! rs)    return -1;  /* free/cancel all lookups */  for(lu = rs->lookups; lu; lu = rs->lookups)    {      rs->lookups = lu->next;      mdns_addr_lookup_free(lu);    }  if(rs->timer)    event_free(rs->timer);  if(rs->sdref)    DNSServiceRefDeallocate(rs->sdref);  free(rs->service);  free(rs->regtype);  free(rs->domain);  free(rs);  return -1;}

// Called in a threadstatic void * OW_Browse_Bonjour(void * v){	struct connection_in * in = v ;	DNSServiceErrorType dnserr;	DETACH_THREAD;	MONITOR_RLOCK ;	dnserr = DNSServiceBrowse(&in->master.browse.bonjour_browse, 0, 0, "_owserver._tcp", NULL, BrowseBack, NULL);	if (dnserr != kDNSServiceErr_NoError) {		LEVEL_CONNECT("DNSServiceBrowse error = %d", dnserr);		MONITOR_RUNLOCK ;		return VOID_RETURN ;	}	// Blocks, which is why this is in it's own thread	while (DNSServiceProcessResult(in->master.browse.bonjour_browse) == kDNSServiceErr_NoError) {		//printf("DNSServiceProcessResult ref %ld/n",(long int)rs->sref) ;		continue;	}	DNSServiceRefDeallocate(in->master.browse.bonjour_browse);	in->master.browse.bonjour_browse = 0 ;	MONITOR_RUNLOCK ;	return VOID_RETURN;}

  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);  }

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;}

/* * CFRunloop callback that calls DNSServiceProcessResult() when * there's new data on the socket. */static voidsocket_callback(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, const void *data, void *context){	struct cbinfo *info = context;	DNSServiceErrorType err;	if (callbackType == kCFSocketNoCallBack) {		printf("socket_callback: kCFSocketNoCallBack?/n");		return;	}	if ((err = DNSServiceProcessResult(info->sdref)) != kDNSServiceErr_NoError) {		printf("DNSServiceProcessResult() returned an error! %d/n", err);		if (err == kDNSServiceErr_BadReference) {			printf("bad reference?: %p, %d, %p, %p %p/n", s, (int)callbackType, address, data, context);			return;		}		if ((context == &nfsinfo) || (context == &mountdinfo)) {			/* bail if there's a problem with the main browse connection */			exit(1);		}		/* dump the troublesome service connection */		CFRunLoopRemoveSource(CFRunLoopGetCurrent(), info->rls, kCFRunLoopDefaultMode);		CFRelease(info->rls);		CFSocketInvalidate(info->sockref);		CFRelease(info->sockref);		DNSServiceRefDeallocate(info->sdref);		free(info);	}}

static voiddnssd_service_free_client(DNSServiceRef *client) {  if (*client) {    DNSServiceRefDeallocate(*client);    *client = NULL;  }}

voidCBFDNSSDService::Cleanup(){	m_stopped = PR_TRUE;	if ( m_job )	{		PR_CancelJob( m_job );		m_job = NULL;	}		if ( m_threadPool != NULL )	{		PR_ShutdownThreadPool( m_threadPool );		m_threadPool = NULL;	}		if ( m_fileDesc != NULL )	{		PR_Close( m_fileDesc );		m_fileDesc = NULL;	}		if ( m_sdRef )	{		DNSServiceRefDeallocate( m_sdRef );		m_sdRef = NULL;	}}

/* 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 ) ;	}}

DNSServiceErrorType DNSSD_API DNSServiceQueryRecord    (    DNSServiceRef              *sdRef,    DNSServiceFlags             flags,    uint32_t                    interfaceIndex,    const char                 *name,    uint16_t                    rrtype,    uint16_t                    rrclass,    DNSServiceQueryRecordReply  callBack,    void                       *context    )    {    char *msg = NULL, *ptr;    size_t len;    ipc_msg_hdr *hdr;    DNSServiceRef sdr;    DNSServiceErrorType err;    if (!sdRef) return kDNSServiceErr_BadParam;    *sdRef = NULL;    if (!name) name = "/0";    // calculate total message length    len = sizeof(flags);    len += sizeof(uint32_t);  //interfaceIndex    len += strlen(name) + 1;    len += 2 * sizeof(uint16_t);  // rrtype, rrclass    hdr = create_hdr(query_request, &len, &ptr, 1);    if (!hdr) goto error;    msg = (void *)hdr;    put_flags(flags, &ptr);    put_long(interfaceIndex, &ptr);    put_string(name, &ptr);    put_short(rrtype, &ptr);    put_short(rrclass, &ptr);    sdr = connect_to_server();    if (!sdr) goto error;    err = deliver_request(msg, sdr, 1);    if (err)        {        DNSServiceRefDeallocate(sdr);        return err;        }    sdr->op = query_request;    sdr->process_reply = handle_query_response;    sdr->app_callback = callBack;    sdr->app_context = context;    *sdRef = sdr;    return err;error:    if (msg) free(msg);    if (*sdRef) { free(*sdRef);  *sdRef = NULL; }    return kDNSServiceErr_Unknown;    }

static voiddnssdDeregisterInstance(    cupsd_srv_t     *srv,		/* I - Service */    int             from_callback)	/* I - Called from callback? */{  if (!srv || !*srv)    return;#  ifdef HAVE_DNSSD  (void)from_callback;  DNSServiceRefDeallocate(*srv);#  else /* HAVE_AVAHI */  if (!from_callback)    avahi_threaded_poll_lock(DNSSDMaster);  avahi_entry_group_free(*srv);  if (!from_callback)    avahi_threaded_poll_unlock(DNSSDMaster);#  endif /* HAVE_DNSSD */  *srv = NULL;}

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);}

int player_sd_unregister(player_sd_t* sd,                      const char* name){  player_sd_mdns_t* mdns = (player_sd_mdns_t*)(sd->sdRef);  player_sd_mdns_dev_t* dev = NULL;  int i;  for(i=0;i<mdns->mdnsDevs_len;i++)  {    if(mdns->mdnsDevs[i].valid && !strcmp(name,mdns->mdnsDevs[i].sdDev.name))    {      dev = mdns->mdnsDevs + i;      break;    }  }  if(dev)  {    DNSServiceRefDeallocate(dev->regRef);    dev->valid = 0;    PLAYER_MSG1(2,"Unregistration of %s successful", name);    return(0);  }  else  {    PLAYER_ERROR1("Failed to find and unregister device %s", name);    return(-1);  }}

    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 );        }    }

bool CZeroconfBrowserMDNS::doRemoveServiceType(const CStdString& fcr_service_type){  //search for this browser and remove it from the map  DNSServiceRef browser = 0;  {    CSingleLock lock(m_data_guard);    tBrowserMap::iterator it = m_service_browsers.find(fcr_service_type);    if(it == m_service_browsers.end())    {      return false;    }    browser = it->second;    m_service_browsers.erase(it);  }  //remove the services of this browser  {    CSingleLock lock(m_data_guard);    tDiscoveredServicesMap::iterator it = m_discovered_services.find(browser);    if(it != m_discovered_services.end())      m_discovered_services.erase(it);  }  if (browser)    DNSServiceRefDeallocate(browser);  return true;}

////////////////////////////////////////////////////// cleanup any leftover registration////////////////////////////////////////////////////static int bonjour_register_cleanup(   ClientData clientData) {   Tcl_HashTable *registerRegistrations =       (Tcl_HashTable *)clientData;   Tcl_HashEntry *hashEntry = NULL;   Tcl_HashSearch searchToken;   active_registration *activeRegister = NULL;   // run through the remaining entries in the hash table   for(hashEntry = Tcl_FirstHashEntry(registerRegistrations,                                      &searchToken);       hashEntry != NULL;       hashEntry = Tcl_NextHashEntry(&searchToken)) {      activeRegister = (active_registration *)Tcl_GetHashValue(hashEntry);      // deallocate the service reference      DNSServiceRefDeallocate(activeRegister->sdRef);      // clean up the memory used by activeRegister      ckfree(activeRegister->regtype);      ckfree((void *)activeRegister);      // deallocate the hash entry      Tcl_DeleteHashEntry(hashEntry);   }   Tcl_DeleteHashTable(registerRegistrations);   return(TCL_OK);}

void CZeroconfWIN::doStop(){  CSingleLock lock(m_data_guard);  for(tServiceMap::iterator it = m_services.begin(); it != m_services.end(); ++it)    DNSServiceRefDeallocate(it->second);  m_services.clear();}

void Manager::deregisterService(){    if( m_publishRef )    {        DNSServiceRefDeallocate( m_publishRef );        m_publishRef = 0;    }}

//===========================================================================================================================//	Stop//===========================================================================================================================void ExplorerBarWindow::Stop( DNSServiceRef ref ){	m_serviceRefs.remove( ref );	WSAAsyncSelect(DNSServiceRefSockFD( ref ), m_hWnd, WM_PRIVATE_SERVICE_EVENT, 0);	DNSServiceRefDeallocate( ref );}

/* * DnsServiceRegistrar::remove * * Un-registers a DNS service and removes it from the list. * * Parameters: *	- ref: reference of the service returned by DnsServiceRegistrar::add * * Return value: none */void DnsServiceRegistrar::remove(DNSServiceRef ref){    if(m_serviceList.contains(ref)) {        DNSServiceRefDeallocate(ref);        m_serviceList.removeAll(ref);        Model::logger().addEntry(Logger::Info, "DNS Service un-registered");    }}

void QxtServiceBrowser::stopBrowsing(){    if(qxt_d().notifier) {        DNSServiceRefDeallocate(qxt_d().service);        qxt_d().notifier->deleteLater();    }    qxt_d().notifier = 0;}

int main()	{	OSStatus err;	void *tempmem;	DNSServiceRef sdRef;	DNSServiceErrorType dse;	SIOUXSettings.asktosaveonclose = false;	SIOUXSettings.userwindowtitle  = "/pMulticast DNS Searcher";	SIOUXSettings.rows             = 40;	SIOUXSettings.columns          = 160;	printf("DNS-SD Search Client/n/n");	printf("This software reports errors using MacsBug breaks,/n");	printf("so if you don't have MacsBug installed your Mac may crash./n/n");	printf("******************************************************************************/n/n");	if (DNSServiceBrowse == (void*)kUnresolvedCFragSymbolAddress)		{		printf("Before you can use mDNS/DNS-SD clients, you need to place the /n");		printf("/"Multicast DNS & DNS-SD/" Extension in the Extensions Folder and restart/n");		return(-1);		}	err = InitOpenTransport();	if (err) { printf("InitOpenTransport failed %d", err); return(err); }	// Make sure OT has a large enough memory pool for us to draw from at OTNotifier (interrupt) time	tempmem = OTAllocMem(0x10000);	if (tempmem) OTFreeMem(tempmem);	else printf("**** Warning: OTAllocMem couldn't pre-allocate 64K for us./n");	services.serviceinfolist.fHead = NULL;	services.headerPrinted         = false;	services.lostRecords           = false;	printf("Sending mDNS service lookup queries and waiting for responses.../n/n");    dse = DNSServiceBrowse(&sdRef, 0, 0, "_http._tcp", "", FoundInstance, &services);	if (dse == kDNSServiceErr_NoError)		{		while (!YieldSomeTime(35))			{			if (services.serviceinfolist.fHead)				PrintServiceInfo(&services);			if (services.lostRecords)				{				services.lostRecords = false;				printf("**** Warning: Out of memory: Records have been missed./n");				}			}		}	DNSServiceRefDeallocate(sdRef);	CloseOpenTransport();	return(0);	}