NMBoolean EndpointHander::ScheduleDelete() { // add endpoint to cleanup list OTLIFOEnqueue(gDeadEndpoints, &mLink); return true; }
// 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); }
static void FoundDomain(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) { #pragma unused (m) #pragma unused (question) SearcherServices *services = (SearcherServices *)question->QuestionContext; linkedServiceInfo *info; debugf("FoundDomain %##s PTR %##s", answer->name->c, answer->rdata->u.name.c); if (answer->rrtype != kDNSType_PTR) return; if (!services) { debugf("FoundDomain: services is NULL"); return; } info = (linkedServiceInfo *)OTAllocMem(sizeof(linkedServiceInfo)); if (!info) { services->lostRecords = true; return; } info->i.name = answer->rdata->u.name; info->i.InterfaceID = answer->InterfaceID; info->i.ip.type = mDNSAddrType_IPv4; info->i.ip.ip.v4 = zerov4Addr; info->i.port = zeroIPPort; info->add = AddRecord; info->dom = mDNStrue; OTLIFOEnqueue(&services->serviceinfolist, &info->link); }
// When a new named instance of a service is found, FoundInstance() is called. // In this sample code we turn around and immediately issue a query to resolve that service name to // find its address, port, and txtinfo, but a normal browing application would just display the name. static void FoundInstance(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) { #pragma unused (question) SearcherServices *services = (SearcherServices *)question->QuestionContext; linkedServiceInfo *info; debugf("FoundInstance %##s PTR %##s", answer->name->c, answer->rdata->u.name.c); if (answer->rrtype != kDNSType_PTR) return; if (!services) { debugf("FoundInstance: services is NULL"); return; } info = (linkedServiceInfo *)OTAllocMem(sizeof(linkedServiceInfo)); if (!info) { services->lostRecords = true; return; } info->i.name = answer->rdata->u.name; info->i.InterfaceID = answer->InterfaceID; info->i.ip.type = mDNSAddrType_IPv4; info->i.ip.ip.v4 = zerov4Addr; info->i.port = zeroIPPort; info->add = AddRecord; info->dom = mDNSfalse; if (!AddRecord) // If TTL == 0 we're deleting a service, OTLIFOEnqueue(&services->serviceinfolist, &info->link); else // else we're adding a new service { ServiceInfoQuery *q = (ServiceInfoQuery *)OTAllocMem(sizeof(ServiceInfoQuery)); if (!q) { OTFreeMem(info); services->lostRecords = true; return; } mDNS_StartResolveService(m, q, &info->i, FoundInstanceInfo, services); } }
// When the name, address, port, and txtinfo for a service is found, FoundInstanceInfo() // enqueues a record for PrintServiceInfo() to print. // Note, a browsing application would *not* normally need to get all this information -- // all it needs is the name, to display to the user. // Finding out the address, port, and txtinfo should be deferred to the time that the user // actually needs to contact the service to use it. static void FoundInstanceInfo(mDNS *const m, ServiceInfoQuery *query) { SearcherServices *services = (SearcherServices *)query->ServiceInfoQueryContext; linkedServiceInfo *info = (linkedServiceInfo *)(query->info); if (query->info->ip.type == mDNSAddrType_IPv4) { mDNS_StopResolveService(m, query); // For this test code, one answer is sufficient OTLIFOEnqueue(&services->serviceinfolist, &info->link); OTFreeMem(query); } }
//ECF - added this to be able to keep a nice, full reserve as time goes on. - just call periodically at system-time NMErr UpkeepOTMemoryReserve(void) { NMErr err = noErr; Boolean done = false; OTLink * thisChunk; if (gReserveInited == false) return paramErr; //if its full, return happy if (gReserveChunksAllocated >= gMaxReserveChunks) return 0; do { // Only try allocating this chunk if doing so will not // break the minimum free space requirement. thisChunk = nil; if ( FreeMem() >= (gFreeHeapSpaceRequired + gReserveChunkSize) ) { //thisChunk = OTAllocMemInContext(chunkSize, clientContext); #if (OP_PLATFORM_MAC_CARBON_FLAG) thisChunk = (OTLink*)OTAllocMemInContext(gReserveChunkSize,gOTClientContext); #else thisChunk = (OTLink*)OTAllocMem(gReserveChunkSize); #endif } if (thisChunk == nil) { // Either the next block is going to push us below the free // space requirement, or we tried to get the block and failed. if (gReserveChunksAllocated < gMinReserveChunks) { // Because weÕre still trying to get our minimum chunks, // this is a fatal error. err = memFullErr; } else { // The block was optional so we donÕt need to error. // We set done and leave the loop. done = true; } } else { // We got the block. Put it into the reserve. If we have // all of our chunks, set done so that we leave the loop. OTLIFOEnqueue(&gMemoryReserve, (OTLink *) thisChunk); gReserveChunksAllocated += 1; if (gReserveChunksAllocated == gMaxReserveChunks) { done = true; } } } while (err == noErr && !done); return err; }
static void FoundInstanceAddress(DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char *fullname, uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata, uint32_t ttl, void *context) { linkedServiceInfo *info = (linkedServiceInfo *)context; SearcherServices *services = info->services; (void)sdRef; // Unused (void)interfaceIndex; // Unused (void)fullname; // Unused (void)ttl; // Unused if (errorCode == kDNSServiceErr_NoError) if (flags & kDNSServiceFlagsAdd) if (rrclass == ns_c_in && rrtype == ns_t_a && rdlen == sizeof(info->address)) { memcpy(&info->address, rdata, sizeof(info->address)); DNSServiceRefDeallocate(info->sdRef); OTLIFOEnqueue(&services->serviceinfolist, &info->link); } }