Lines Matching refs:Request
93 typedef void (*req_termination_fn)(request_state *request);
100 request_state *request;
112 request_state *request;
141 // for each new request. This is because, until we've read the ipc_msg_hdr to find out what the
161 registered_record_entry *reg_recs; // list of registrations for a connection-oriented request
345 // We also set req->terminate to a bogus value so we know if abort_request() gets called again for this request
358 mDNSlocal reply_state *create_reply(const reply_op_t op, const size_t datalen, request_state *const request)
379 reply->mhdr->client_context = request->hdr.client_context;
385 // Append a reply to the list in a request object
386 // If our request is sharing a connection, then we append our reply_state onto the primary's list
400 request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
428 *rep = create_reply(op, len, request);
446 request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
471 *rep = create_reply(op, len, request);
486 mDNSlocal AuthRecord *read_rr_from_ipc_msg(request_state *request, int GetTTL, int validate_flags)
488 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
489 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
491 int str_err = get_string(&request->msgptr, request->msgend, name, sizeof(name));
492 mDNSu16 type = get_uint16(&request->msgptr, request->msgend);
493 mDNSu16 class = get_uint16(&request->msgptr, request->msgend);
494 mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
495 const char *rdata = get_rdata (&request->msgptr, request->msgend, rdlen);
496 mDNSu32 ttl = GetTTL ? get_uint32(&request->msgptr, request->msgend) : 0;
502 request->flags = flags;
506 if (!request->msgptr) { LogMsg("Error reading Resource Record from client"); return NULL; }
574 mDNSlocal mDNSBool AuthorizedDomain(const request_state * const request, const domainname * const d, const DNameListElem * const doms)
581 if (SystemUID(request->uid)) return mDNStrue;
593 allow = (allow || (delem->uid == request->uid));
614 if (mDNSIPPortIsZero(instance->request->u.servicereg.port))
630 for ( i = 0; i < instance->request->u.servicereg.num_subtypes; i++)
652 for ( i = 0; i < instance->request->u.servicereg.num_subtypes; i++)
691 if (srv->request)
693 service_instance **p = &srv->request->u.servicereg.instances;
749 if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, 0, mStatus_NoError) != mStatus_NoError)
750 LogMsg("%3d: SendServiceRemovalNotification: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
751 else { append_reply(instance->request, rep); instance->clientnotified = mDNSfalse; }
770 if (instance->request &&
771 instance->request->u.servicereg.default_domain &&
783 if (instance->request) mDNS_snprintf(prefix, sizeof(prefix), "%3d:", instance->request->sd);
788 if (!instance->request && result != mStatus_MemFree) { LogMsg("regservice_callback: instance->request is NULL %d", result); return; }
792 if (instance->request->u.servicereg.allowremotequery)
802 if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
803 LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
804 else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
806 if (instance->request->u.servicereg.InterfaceID == mDNSInterface_P2P || (!instance->request->u.servicereg.InterfaceID && SameDomainName(&instance->domain, &localdomain) && (instance->request->flags & kDNSServiceFlagsIncludeP2P)))
811 if (instance->request->u.servicereg.autoname && CountPeerRegistrations(m, srs) == 0)
816 if (instance->request && instance->renameonmemfree)
820 err = mDNS_RenameAndReregisterService(m, srs, &instance->request->u.servicereg.name);
829 if (instance->request->u.servicereg.autorename)
832 if (instance->request->u.servicereg.autoname && CountPeerRegistrations(m, srs) == 0)
848 if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
849 LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
850 else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
859 if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
860 LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
861 else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
888 request_state *request = re->request;
896 LogOperation(fmt, request->sd, re->key, RRDisplayString(m, &rr->resrec), result);
902 reply_state *reply = create_reply(reg_record_reply_op, len, request);
907 append_reply(request, reply);
913 registered_record_entry **ptr = &request->u.reg_recs;
924 if (re->origInterfaceID == mDNSInterface_P2P || (!re->origInterfaceID && IsLocalDomain(&rr->namestorage) && (request->flags & kDNSServiceFlagsIncludeP2P)))
934 mDNSlocal void connection_termination(request_state *request)
940 LogOperation("%3d: DNSServiceCreateConnection STOP", request->sd);
944 if ((*req)->primary == request)
946 // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
958 while (request->u.reg_recs)
960 registered_record_entry *ptr = request->u.reg_recs;
961 LogOperation("%3d: DNSServiceRegisterRecord(%u %s) STOP", request->sd, ptr->key, RRDisplayString(&mDNSStorage, &ptr->rr->resrec));
962 request->u.reg_recs = request->u.reg_recs->next;
974 mDNSlocal void handle_cancel_request(request_state *request)
977 LogOperation("%3d: Cancel %08X %08X", request->sd, request->hdr.client_context.u32[1], request->hdr.client_context.u32[0]);
980 if ((*req)->primary == request &&
981 (*req)->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
982 (*req)->hdr.client_context.u32[1] == request->hdr.client_context.u32[1])
984 // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
995 mDNSlocal mStatus handle_regrecord_request(request_state *request)
998 AuthRecord *rr = read_rr_from_ipc_msg(request, 1, 1);
1014 re->key = request->hdr.reg_index;
1016 re->regrec_client_context = request->hdr.client_context;
1017 re->request = request;
1025 if (!AuthorizedDomain(request, rr->resrec.name, AutoRegistrationDomains)) return (mStatus_NoError);
1030 LogOperation("%3d: DNSServiceRegisterRecord(%u %s) START", request->sd, re->key, RRDisplayString(&mDNSStorage, &rr->resrec));
1034 LogOperation("%3d: DNSServiceRegisterRecord(%u %s) ERROR (%d)", request->sd, re->key, RRDisplayString(&mDNSStorage, &rr->resrec), err);
1040 re->next = request->u.reg_recs;
1041 request->u.reg_recs = re;
1049 mDNSlocal void regservice_termination_callback(request_state *request)
1051 if (!request) { LogMsg("regservice_termination_callback context is NULL"); return; }
1052 while (request->u.servicereg.instances)
1054 service_instance *p = request->u.servicereg.instances;
1055 request->u.servicereg.instances = request->u.servicereg.instances->next;
1058 request->sd, p->srs.RR_SRV.resrec.name->c, mDNSVal16(p->srs.RR_SRV.resrec.rdata->u.srv.port));
1064 // request->u.servicereg.instances as we work our way through the list, implicitly cutting one element at a time
1065 // We can't clear p->request *after* the calling mDNS_DeregisterService/unlink_and_free_service_instance
1067 p->request = NULL;
1071 if (request->u.servicereg.txtdata)
1072 { freeL("service_info txtdata", request->u.servicereg.txtdata); request->u.servicereg.txtdata = NULL; }
1073 if (request->u.servicereg.autoname)
1076 request->u.servicereg.autoname = mDNSfalse;
1081 mDNSlocal request_state *LocateSubordinateRequest(request_state *request)
1085 if (req->primary == request &&
1086 req->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
1087 req->hdr.client_context.u32[1] == request->hdr.client_context.u32[1]) return(req);
1088 return(request);
1091 mDNSlocal mStatus add_record_to_service(request_state *request, service_instance *instance, mDNSu16 rrtype, mDNSu16 rdlen, const char *rdata, mDNSu32 ttl)
1106 (request->flags & kDNSServiceFlagsIncludeP2P) ? 1: 0);
1109 extra->ClientID = request->hdr.reg_index;
1110 if (instance->external_advertise && (instance->request->u.servicereg.InterfaceID == mDNSInterface_P2P || (!instance->request->u.servicereg.InterfaceID && SameDomainName(&instance->domain, &localdomain) && (instance->request->flags & kDNSServiceFlagsIncludeP2P))))
1118 mDNSlocal mStatus handle_add_request(request_state *request)
1122 DNSServiceFlags flags = get_flags (&request->msgptr, request->msgend);
1123 mDNSu16 rrtype = get_uint16(&request->msgptr, request->msgend);
1124 mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
1125 const char *rdata = get_rdata (&request->msgptr, request->msgend, rdlen);
1126 mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
1130 if (!request->msgptr) { LogMsg("%3d: DNSServiceAddRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
1133 if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
1135 if (request->terminate != regservice_termination_callback)
1136 { LogMsg("%3d: DNSServiceAddRecord(not a registered service ref)", request->sd); return(mStatus_BadParamErr); }
1140 if (mDNSIPPortIsZero(request->u.servicereg.port))
1141 { LogMsg("%3d: DNSServiceAddRecord: adding record to a service registered with zero port", request->sd); return(mStatus_BadParamErr); }
1143 LogOperation("%3d: DNSServiceAddRecord(%X, %##s, %s, %d)", request->sd, flags,
1144 (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL, DNSTypeName(rrtype), rdlen);
1146 for (i = request->u.servicereg.instances; i; i = i->next)
1148 result = add_record_to_service(request, i, rrtype, rdlen, rdata, ttl);
1204 mDNSlocal mStatus handle_update_request(request_state *request)
1206 const ipc_msg_hdr *const hdr = &request->hdr;
1212 DNSServiceFlags flags = get_flags (&request->msgptr, request->msgend); // flags unused
1213 mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
1214 const char *rdata = get_rdata (&request->msgptr, request->msgend, rdlen);
1215 mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
1218 if (!request->msgptr) { LogMsg("%3d: DNSServiceUpdateRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
1221 if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
1223 if (request->terminate == connection_termination)
1227 for (reptr = request->u.reg_recs; reptr; reptr = reptr->next)
1233 request->sd, reptr->rr->resrec.name->c, reptr->rr ? DNSTypeName(reptr->rr->resrec.rrtype) : "<NONE>");
1241 if (request->terminate != regservice_termination_callback)
1242 { LogMsg("%3d: DNSServiceUpdateRecord(not a registered service ref)", request->sd); return(mStatus_BadParamErr); }
1245 if (mDNSIPPortIsZero(request->u.servicereg.port))
1246 request->sd); return(mStatus_BadParamErr); }
1251 if (request->u.servicereg.txtdata)
1252 { freeL("service_info txtdata", request->u.servicereg.txtdata); request->u.servicereg.txtdata = NULL; }
1255 request->u.servicereg.txtdata = mallocL("service_info txtdata", rdlen);
1256 if (!request->u.servicereg.txtdata) FatalError("ERROR: handle_update_request - malloc");
1257 mDNSPlatformMemCopy(request->u.servicereg.txtdata, rdata, rdlen);
1259 request->u.servicereg.txtlen = rdlen;
1263 for (i = request->u.servicereg.instances; i; i = i->next)
1280 if (request->terminate == regservice_termination_callback)
1281 LogOperation("%3d: DNSServiceUpdateRecord(%##s, %s)", request->sd,
1282 (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
1289 mDNSlocal mStatus remove_record(request_state *request)
1292 registered_record_entry *e, **ptr = &request->u.reg_recs;
1294 while (*ptr && (*ptr)->key != request->hdr.reg_index) ptr = &(*ptr)->next;
1295 if (!*ptr) { LogMsg("%3d: DNSServiceRemoveRecord(%u) not found", request->sd, request->hdr.reg_index); return mStatus_BadReferenceErr; }
1299 LogOperation("%3d: DNSServiceRemoveRecord(%u %s)", request->sd, e->key, RRDisplayString(&mDNSStorage, &e->rr->resrec));
1317 mDNSlocal mStatus remove_extra(const request_state *const request, service_instance *const serv, mDNSu16 *const rrtype)
1324 if (ptr->ClientID == request->hdr.reg_index) // found match
1335 mDNSlocal mStatus handle_removerecord_request(request_state *request)
1338 get_flags(&request->msgptr, request->msgend); // flags unused
1340 if (!request->msgptr) { LogMsg("%3d: DNSServiceRemoveRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
1343 if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
1345 if (request->terminate == connection_termination)
1346 err = remove_record(request); // remove individually registered record
1347 else if (request->terminate != regservice_termination_callback)
1348 { LogMsg("%3d: DNSServiceRemoveRecord(not a registered service ref)", request->sd); return(mStatus_BadParamErr); }
1353 LogOperation("%3d: DNSServiceRemoveRecord(%##s, %s)", request->sd,
1354 (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
1356 for (i = request->u.servicereg.instances; i; i = i->next)
1358 err = remove_extra(request, i, &rrtype);
1438 mDNSlocal mStatus register_service_instance(request_state *request, const domainname *domain)
1441 const int extra_size = (request->u.servicereg.txtlen > sizeof(RDataBody)) ? (request->u.servicereg.txtlen - sizeof(RDataBody)) : 0;
1444 mDNSInterfaceID interfaceID = request->u.servicereg.InterfaceID;
1452 else if (request->flags & kDNSServiceFlagsIncludeP2P)
1456 if (request->flags & kDNSServiceFlagsForce)
1464 if (request->u.servicereg.default_domain && !DomainIsLocal) interfaceID = mDNSInterface_Any;
1466 for (ptr = &request->u.servicereg.instances; *ptr; ptr = &(*ptr)->next)
1471 domain->c, &request->u.servicereg.name, &request->u.servicereg.type);
1481 if (SameDomainName(&request->u.servicereg.type, (const domainname *) "\x4" "_smb" "\x4" "_tcp"))
1492 instance->request = request;
1493 instance->subtypes = AllocateSubTypes(request->u.servicereg.num_subtypes, request->u.servicereg.type_as_string);
1496 instance->default_local = (request->u.servicereg.default_domain && DomainIsLocal);
1500 if (request->u.servicereg.num_subtypes && !instance->subtypes)
1504 &request->u.servicereg.name, &request->u.servicereg.type, domain,
1505 request->u.servicereg.host.c[0] ? &request->u.servicereg.host : NULL,
1506 request->u.servicereg.port,
1507 request->u.servicereg.txtdata, request->u.servicereg.txtlen,
1508 instance->subtypes, request->u.servicereg.num_subtypes,
1513 *ptr = instance; // Append this to the end of our request->u.servicereg.instances list
1515 instance->request->sd, instance->srs.RR_SRV.resrec.name->c, mDNSVal16(request->u.servicereg.port));
1520 &request->u.servicereg.name, &request->u.servicereg.type, domain->c, result);
1529 request_state *request;
1536 for (request = all_requests; request; request = request->next)
1538 if (request->terminate != regservice_termination_callback) continue;
1539 if (!request->u.servicereg.default_domain) continue;
1540 if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
1542 service_instance **ptr = &request->u.servicereg.instances;
1547 if (!*ptr) register_service_instance(request, &d->name);
1557 &d->name, request->u.servicereg.name.c, request->u.servicereg.type_as_string);
1562 if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
1570 if (si->clientnotified) SendServiceRemovalNotification(&si->srs); // Do this *before* clearing si->request backpointer
1571 // Now that we've cut this service_instance from the list, we MUST clear the si->request backpointer.
1579 // a service_instance with a stale si->request backpointer pointing to memory that's already been freed.
1580 si->request = NULL;
1590 mDNSlocal mStatus handle_regservice_request(request_state *request)
1598 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
1599 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
1604 if (get_string(&request->msgptr, request->msgend, name, sizeof(name)) < 0 ||
1605 get_string(&request->msgptr, request->msgend, type_as_string, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
1606 get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
1607 get_string(&request->msgptr, request->msgend, host, MAX_ESCAPED_DOMAIN_NAME) < 0)
1610 request->flags = flags;
1611 request->u.servicereg.InterfaceID = InterfaceID;
1612 request->u.servicereg.instances = NULL;
1613 request->u.servicereg.txtlen = 0;
1614 request->u.servicereg.txtdata = NULL;
1615 mDNSPlatformStrCopy(request->u.servicereg.type_as_string, type_as_string);
1617 if (request->msgptr + 2 > request->msgend) request->msgptr = NULL;
1620 request->u.servicereg.port.b[0] = *request->msgptr++;
1621 request->u.servicereg.port.b[1] = *request->msgptr++;
1624 request->u.servicereg.txtlen = get_uint16(&request->msgptr, request->msgend);
1625 if (request->u.servicereg.txtlen)
1627 request->u.servicereg.txtdata = mallocL("service_info txtdata", request->u.servicereg.txtlen);
1628 if (!request->u.servicereg.txtdata) FatalError("ERROR: handle_regservice_request - malloc");
1629 mDNSPlatformMemCopy(request->u.servicereg.txtdata, get_rdata(&request->msgptr, request->msgend, request->u.servicereg.txtlen), request->u.servicereg.txtlen);
1632 if (!request->msgptr) { LogMsg("%3d: DNSServiceRegister(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
1635 request->u.servicereg.num_subtypes = ChopSubTypes(request->u.servicereg.type_as_string); // Note: Modifies regtype string to remove trailing subtypes
1636 if (request->u.servicereg.num_subtypes < 0)
1637 { LogMsg("ERROR: handle_regservice_request - ChopSubTypes failed %s", request
1640 if (!*request->u.servicereg.type_as_string || !MakeDomainNameFromDNSNameString(&request->u.servicereg.type, request->u.servicereg.type_as_string))
1641 { LogMsg("ERROR: handle_regservice_request - type_as_string bad %s", request->u.servicereg.type_as_string); return(mStatus_BadParamErr); }
1645 request->u.servicereg.name = mDNSStorage.nicelabel;
1646 request->u.servicereg.autoname = mDNStrue;
1656 if (!MakeDomainLabelFromLiteralString(&request->u.servicereg.name, name))
1658 request->u.servicereg.autoname = mDNSfalse;
1663 request->u.servicereg.default_domain = mDNSfalse;
1669 request->u.servicereg.default_domain = mDNStrue;
1673 if (!ConstructServiceName(&srv, &request->u.servicereg.name, &request->u.servicereg.type, &d))
1676 request->u.servicereg.name.c, request->u.servicereg.type.c, d.c); return(mStatus_BadParamErr);
1679 if (!MakeDomainNameFromDNSNameString(&request->u.servicereg.host, host))
1681 request->u.servicereg.autorename = (flags & kDNSServiceFlagsNoAutoRename ) == 0;
1682 request->u.servicereg.allowremotequery = (flags & kDNSServiceFlagsAllowRemoteQuery) != 0;
1687 if (!mDNSIPPortIsZero(request->u.servicereg.port))
1689 int count = CountExistingRegistrations(&srv, request->u.servicereg.port);
1692 count+1, srv.c, mDNSVal16(request->u.servicereg.port));
1696 request->sd, flags, interfaceIndex, name, request->u.servicereg.type_as_string, domain, host, mDNSVal16(request->u.servicereg.port));
1698 // We need to unconditionally set request->terminate, because even if we didn't successfully
1701 // We also need to set request->terminate first, before adding additional service instances,
1702 // because the uds_validatelists uses the request->terminate function pointer to determine
1703 // what kind of request this is, and therefore what kind of list validation is required.
1704 request->terminate = regservice_termination_callback;
1706 err = register_service_instance(request, &d);
1709 err = AuthorizedDomain(request, &d, AutoRegistrationDomains) ? register_service_instance(request, &d) : mStatus_NoError;
1713 if (request->u.servicereg.autoname) UpdateDeviceInfoRecord(&mDNSStorage);
1720 if (!ptr->uid || SystemUID(request->uid) || request->uid == ptr->uid)
1721 register_service_instance(request, &ptr->name);
1828 request_state *request;
1835 for (request = all_requests; request; request = request->next)
1837 if (request->terminate != browse_termination_callback) continue; // Not a browse operation
1838 if (!request->u.browser.default_domain) continue; // Not an auto-browse operation
1839 if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
1841 browser_t **ptr = &request->u.browser.browsers;
1846 if (!*ptr) add_domain_to_browser(request, &d->name);
1856 if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
2120 mDNSlocal mStatus handle_sethost_request(request_state *request)
2122 get_flags(&request->msgptr, request->msgend);
2125 if (get_string(&request->msgptr, request->msgend, hostName,
2128 request->sd, request->flags);
2131 // request->terminate = sethost_termination_callback;
2143 mDNSlocal mStatus handle_browse_request(request_state *request)
2150 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
2151 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
2155 if (get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
2156 get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0) return(mStatus_BadParamErr);
2158 if (!request->msgptr) { LogMsg("%3d: DNSServiceBrowse(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
2162 request->flags = flags;
2175 request->u.browser.ForceMCast = (flags & kDNSServiceFlagsForceMulticast) != 0;
2176 request->u.browser.interface_id = InterfaceID;
2177 AssignDomainName(&request->u.browser.regtype, &typedn);
2178 request->u.browser.default_domain = !domain[0];
2179 request->u.browser.browsers = NULL;
2182 request->sd, request->flags, interfaceIndex, request->u.browser.regtype.c, domain);
2184 // We need to unconditionally set request->terminate, because even if we didn't successfully
2187 request->terminate = browse_termination_callback;
2192 err = add_domain_to_browser(request, &d);
2194 err = AuthorizedDomain(request, &d, AutoBrowseDomains) ? add_domain_to_browser(request, &d) : mStatus_NoError;
2201 if (!sdom->uid || SystemUID(request->uid) || request->uid == sdom->uid)
2203 err = add_domain_to_browser(request, &sdom->name);
2276 mDNSlocal void resolve_termination_callback(request_state *request)
2278 LogOperation("%3d: DNSServiceResolve(%##s) STOP", request->sd, request->u.resolve.qtxt.qname.c);
2279 mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qtxt);
2280 mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
2281 if (request->u.resolve.external_advertise) external_stop_resolving_service(&request->u.resolve.qsrv.qname);
2284 mDNSlocal mStatus handle_resolve_request(request_state *request)
2291 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
2292 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
2297 request->flags = flags;
2304 if (get_string(&request->msgptr, request->msgend, name, 256) < 0 ||
2305 get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
2306 get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0)
2309 if (!request->msgptr) { LogMsg("%3d: DNSServiceResolve(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
2314 mDNSPlatformMemZero(&request->u.resolve, sizeof(request->u.resolve));
2317 request->u.resolve.qsrv.InterfaceID = InterfaceID;
2318 request->u.resolve.qsrv.Target = zeroAddr;
2319 AssignDomainName(&request->u.resolve.qsrv.qname, &fqdn);
2320 request->u.resolve.qsrv.qtype = kDNSType_SRV;
2321 request->u.resolve.qsrv.qclass = kDNSClass_IN;
2322 request->u.resolve.qsrv.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
2323 request->u.resolve.qsrv.ExpectUnique = mDNStrue;
2324 request->u.resolve.qsrv.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
2325 request->u.resolve.qsrv.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
2326 request->u.resolve.qsrv.SuppressUnusable = mDNSfalse;
2327 request->u.resolve.qsrv.SearchListIndex = 0;
2328 request->u.resolve.qsrv.AppendSearchDomains = 0;
2329 request->u.resolve.qsrv.RetryWithSearchDomains = mDNSfalse;
2330 request->u.resolve.qsrv.TimeoutQuestion = 0;
2331 request->u.resolve.qsrv.WakeOnResolve = (flags & kDNSServiceFlagsWakeOnResolve) != 0;
2332 request->u.resolve.qsrv.qnameOrig = mDNSNULL;
2333 request->u.resolve.qsrv.QuestionCallback = resolve_result_callback;
2334 request->u.resolve.qsrv.QuestionContext = request;
2336 request->u.resolve.qtxt.InterfaceID = InterfaceID;
2337 request->u.resolve.qtxt.Target = zeroAddr;
2338 AssignDomainName(&request->u.resolve.qtxt.qname, &fqdn);
2339 request->u.resolve.qtxt.qtype = kDNSType_TXT;
2340 request->u.resolve.qtxt.qclass = kDNSClass_IN;
2341 request->u.resolve.qtxt.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
2342 request->u.resolve.qtxt.ExpectUnique = mDNStrue;
2343 request->u.resolve.qtxt.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
2344 request->u.resolve.qtxt.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
2345 request->u.resolve.qtxt.SuppressUnusable = mDNSfalse;
2346 request->u.resolve.qtxt.SearchListIndex = 0;
2347 request->u.resolve.qtxt.AppendSearchDomains = 0;
2348 request->u.resolve.qtxt.RetryWithSearchDomains = mDNSfalse;
2349 request->u.resolve.qtxt.TimeoutQuestion = 0;
2350 request->u.resolve.qtxt.WakeOnResolve = 0;
2351 request->u.resolve.qtxt.qnameOrig = mDNSNULL;
2352 request->u.resolve.qtxt.QuestionCallback = resolve_result_callback;
2353 request->u.resolve.qtxt.QuestionContext = request;
2355 request->u.resolve.ReportTime = NonZeroTime(mDNS_TimeNow(&mDNSStorage) + 130 * mDNSPlatformOneSecond);
2357 request->u.resolve.external_advertise = mDNSfalse;
2360 if (!AuthorizedDomain(request, &fqdn, AutoBrowseDomains)) return(mStatus_NoError);
2364 LogOperation("%3d: DNSServiceResolve(%##s) START", request->sd, request->u.resolve.qsrv.qname.c);
2365 err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qsrv);
2368 err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qtxt);
2369 if (err) mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
2372 request->terminate = resolve_termination_callback;
2374 if (wasP2P || (!InterfaceID && IsLocalDomain(&fqdn) && (request->flags & kDNSServiceFlagsIncludeP2P)))
2376 request->u.resolve.external_advertise = mDNStrue;
2392 // mDNS operation functions. Each operation has 3 associated functions - a request handler that parses
2393 // the client's request and makes the appropriate mDNSCore call, a result handler (passed as a callback
2484 mDNSlocal mStatus SendAdditionalQuery(DNSQuestion *q, request_state *request, mStatus err)
2492 if (request->hdr.op == query_request)
2493 question2 = &request->u.queryrecord.q2;
2494 else if (request->hdr.op == addrinfo_request)
2497 question2 = &request->u.addrinfo.q42;
2499 question2 = &request->u.addrinfo.q62;
2572 LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) unicast", request->sd, q2->qname.c, DNSTypeName(q2->qtype));
2574 if (err) LogMsg("%3d: ERROR: DNSServiceQueryRecord %##s %s mDNS_StartQuery: %d", request->sd, q2->qname.c, DNSTypeName(q2->qtype), (int)err);
2914 mDNSlocal void queryrecord_termination_callback(request_state *request)
2917 request->sd, request->u.queryrecord.q.qname.c, DNSTypeName(request->u.queryrecord.q.qtype));
2918 if (request->u.queryrecord.q.QuestionContext)
2920 mDNS_StopQuery(&mDNSStorage, &request->u.queryrecord.q); // no need to error check
2921 request->u.queryrecord.q.QuestionContext = mDNSNULL;
2925 DNSQuestion *question = &request->u.queryrecord.q;
2929 if (request->u.queryrecord.q.qnameOrig)
2931 freeL("QueryTermination", request->u.queryrecord.q.qnameOrig);
2932 request->u.queryrecord.q.qnameOrig = mDNSNULL;
2934 if (request->u.queryrecord.q.InterfaceID == mDNSInterface_P2P || (!request->u.queryrecord.q.InterfaceID && SameDomainName((const domainname *)LastLabel(&request->u.queryrecord.q.qname), &localdomain) && (request->flags & kDNSServiceFlagsIncludeP2P)))
2937 external_stop_browsing_for_service(&mDNSStorage, &request->u.queryrecord.q.qname, request->u.queryrecord.q.qtype);
2939 if (request->u.queryrecord.q2)
2941 if (request->u.queryrecord.q2->QuestionContext)
2943 LogInfo("queryrecord_termination_callback: Stopping q2 %##s", request->u.queryrecord.q2->qname.c);
2944 mDNS_StopQuery(&mDNSStorage, request->u.queryrecord.q2);
2948 DNSQuestion *question = request->u.queryrecord.q2;
2951 if (request->u.queryrecord.q2->qnameOrig)
2953 LogInfo("queryrecord_termination_callback: freeing q2 qnameOrig %##s", request->u.queryrecord.q2->qnameOrig->c);
2954 freeL("QueryTermination q2", request->u.queryrecord.q2->qnameOrig);
2955 request->u.queryrecord.q2->qnameOrig = mDNSNULL;
2957 freeL("queryrecord Q2", request->u.queryrecord.q2);
2958 request->u.queryrecord.q2 = mDNSNULL;
2962 mDNSlocal mStatus handle_queryrecord_request(request_state *request)
2964 DNSQuestion *const q = &request->u.queryrecord.q;
2969 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
2970 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
2974 if (get_string(&request->msgptr, request->msgend, name, 256) < 0) return(mStatus_BadParamErr);
2975 rrtype = get_uint16(&request->msgptr, request->msgend);
2976 rrclass = get_uint16(&request->msgptr, request->msgend);
2978 if (!request->msgptr)
2979 { LogMsg("%3d: DNSServiceQueryRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
2981 request->flags = flags;
2982 mDNSPlatformMemZero(&request->u.queryrecord, sizeof(request->u.queryrecord));
2988 if (!AuthorizedDomain(request, &q->qname, AutoBrowseDomains)) return (mStatus_NoError);
3000 q->QuestionContext = request;
3031 LogOperation("%3d: DNSServiceQueryRecord(%X, %d, %##s, %s) START", request->sd, flags, interfaceIndex, q->qname.c, DNSTypeName(q->qtype));
3033 if (err) LogMsg("%3d: ERROR: DNSServiceQueryRecord %##s %s mDNS_StartQuery: %d", request->sd, q->qname.c, DNSTypeName(q->qtype), (int)err);
3036 request->terminate = queryrecord_termination_callback;
3045 err = SendAdditionalQuery(q, request, err);
3057 mDNSlocal reply_state *format_enumeration_reply(request_state *request,
3069 reply = create_reply(enumeration_reply_op, len, request);
3078 mDNSlocal void enum_termination_callback(request_state *request)
3080 mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
3081 mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_default);
3088 request_state *request = question->QuestionContext;
3096 if (!AuthorizedDomain(request, &answer->rdata->u.name, request->u.enumeration.flags ? AutoRegistrationDomains : AutoBrowseDomains)) return;
3101 if (question == &request->u.enumeration.q_default && !AddRecord) return;
3106 if (question == &request->u.enumeration.q_default) flags |= kDNSServiceFlagsDefault;
3113 reply = format_enumeration_reply(request, domain, flags, kDNSServiceInterfaceIndexAny, kDNSServiceErr_NoError);
3116 request->sd, question->qname.c, AddRecord ? "Add" : "Rmv", domain);
3118 append_reply(request, reply);
3121 mDNSlocal mStatus handle_enum_request(request_state *request)
3124 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
3128 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
3132 if (!request->msgptr)
3133 { LogMsg("%3d: DNSServiceEnumerateDomains(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
3140 request->u.enumeration.flags = reg;
3145 request->u.enumeration.q_all .QuestionContext = request;
3146 request->u.enumeration.q_default.QuestionContext = request;
3152 LogOperation("%3d: DNSServiceEnumerateDomains(%X=%s)", request->sd, flags,
3155 err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_all, t_all, NULL, InterfaceID, enum_result_callback, request);
3158 err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_default, t_default, NULL, InterfaceID, enum_result_callback, request);
3159 if (err) mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
3160 else request->terminate = enum_termination_callback;
3172 mDNSlocal mStatus handle_reconfirm_request(request_state *request)
3175 AuthRecord *rr = read_rr_from_ipc_msg(request, 0, 0);
3183 request->sd, RRDisplayString(&mDNSStorage, &rr->resrec),
3190 mDNSlocal mStatus handle_setdomain_request(request_state *request)
3194 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
3196 if (get_string(&request->msgptr, request->msgend, domainstr, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
3198 { LogMsg("%3d: DNSServiceSetDefaultDomainForUser(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
3200 LogOperation("%3d: DNSServiceSetDefaultDomainForUser(%##s)", request->sd, domain.c);
3211 mDNSlocal void handle_getproperty_request(request_state *request)
3215 if (get_string(&request->msgptr, request->msgend, prop, sizeof(prop)) >= 0)
3217 LogOperation("%3d: DNSServiceGetProperty(%s)", request->sd, prop);
3221 send_all(request->sd, (const char *)&x, sizeof(x));
3227 send_all(request->sd, (const char *)&BadParamErr, sizeof(BadParamErr));
3238 mDNSlocal void port_mapping_termination_callback(request_state *request)
3240 LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) STOP", request->sd,
3241 DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
3242 mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease);
3243 mDNS_StopNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
3246 // Called via function pointer when we get a NAT-PMP address request or port mapping response
3249 request_state *request = (request_state *)n->clientContext;
3254 if (!request) { LogMsg("port_mapping_create_request_callback called with unknown request_state object"); return; }
3263 rep = create_reply(port_mapping_reply_op, replyLen, request);
3271 *data++ = request->u.pm.NATinfo.ExternalAddress.b[0];
3272 *data++ = request->u.pm.NATinfo.ExternalAddress.b[1];
3273 *data++ = request->u.pm.NATinfo.ExternalAddress.b[2];
3274 *data++ = request->u.pm.NATinfo.ExternalAddress.b[3];
3275 *data++ = DNSServiceProtocol(request->u.pm.NATinfo.Protocol);
3276 *data++ = request->u.pm.NATinfo.IntPort.b[0];
3277 *data++ = request->u.pm.NATinfo.IntPort.b[1];
3278 *data++ = request->u.pm.NATinfo.ExternalPort.b[0];
3279 *data++ = request->u.pm.NATinfo.ExternalPort.b[1];
3280 put_uint32(request->u.pm.NATinfo.Lifetime, &data);
3282 LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) RESULT %.4a:%u TTL %u", request->sd,
3283 DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
3284 mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease,
3285 &request->u.pm.NATinfo.ExternalAddress, mDNSVal16(request->u.pm.NATinfo.ExternalPort), request->u.pm.NATinfo.Lifetime);
3287 append_reply(request, rep);
3290 mDNSlocal mStatus handle_port_mapping_request(request_state *request)
3295 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
3296 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
3298 mDNSu8 protocol = (mDNSu8)get_uint32(&request->msgptr, request->msgend);
3301 if (request->msgptr + 8 > request->msgend) request->msgptr = NULL;
3304 request->u.pm.NATinfo.IntPort.b[0] = *request->msgptr++;
3305 request->u.pm.NATinfo.IntPort.b[1] = *request->msgptr++;
3306 request->u.pm.ReqExt.b[0] = *request->msgptr++;
3307 request->u.pm.ReqExt.b[1] = *request->msgptr++;
3308 ttl = get_uint32(&request->msgptr, request->msgend);
3311 if (!request->msgptr)
3312 { LogMsg("%3d: DNSServiceNATPortMappingCreate(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
3314 if (protocol == 0) // If protocol == 0 (i.e. just request public address) then IntPort, ExtPort, ttl must be zero too
3316 if (!mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort) || !mDNSIPPortIsZero(request->u.pm.ReqExt) || ttl) return(mStatus_BadParamErr);
3320 if (mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort)) return(mStatus_BadParamErr);
3324 request->u.pm.NATinfo.Protocol = !protocol ? NATOp_AddrRequest : (protocol == kDNSServiceProtocol_UDP) ? NATOp_MapUDP : NATOp_MapTCP;
3326 request->u.pm.NATinfo.RequestedPort = request->u.pm.ReqExt;
3327 request->u.pm.NATinfo.NATLease = ttl;
3328 request->u.pm.NATinfo.clientCallback = port_mapping_create_request_callback;
3329 request->u.pm.NATinfo.clientContext = request;
3331 LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) START", request->sd,
3332 protocol, mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease);
3333 err = mDNS_StartNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
3335 else request->terminate = port_mapping_termination_callback;
3346 mDNSlocal void addrinfo_termination_callback(request_state *request)
3348 LogOperation("%3d: DNSServiceGetAddrInfo(%##s) STOP", request->sd, request->u.addrinfo.q4.qname.c);
3350 if (request->u.addrinfo.q4.QuestionContext)
3352 mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q4);
3353 request->u.addrinfo.q4.QuestionContext = mDNSNULL;
3355 if (request->u.addrinfo.q4.qnameOrig)
3357 freeL("QueryTermination", request->u.addrinfo.q4.qnameOrig);
3358 request->u.addrinfo.q4.qnameOrig = mDNSNULL;
3360 if (request->u.addrinfo.q42)
3362 if (request->u.addrinfo.q42->QuestionContext)
3364 LogInfo("addrinfo_termination_callback: Stopping q42 %##s", request->u.addrinfo.q42->qname.c);
3365 mDNS_StopQuery(&mDNSStorage, request->u.addrinfo.q42);
3367 if (request->u.addrinfo.q42->qnameOrig)
3369 LogInfo("addrinfo_termination_callback: freeing q42 qnameOrig %##s", request->u.addrinfo.q42->qnameOrig->c);
3370 freeL("QueryTermination q42", request->u.addrinfo.q42->qnameOrig);
3371 request->u.addrinfo.q42->qnameOrig = mDNSNULL;
3373 freeL("addrinfo Q42", request->u.addrinfo.q42);
3374 request->u.addrinfo.q42 = mDNSNULL;
3377 if (request->u.addrinfo.q6.QuestionContext)
3379 mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q6);
3380 request->u.addrinfo.q6.QuestionContext = mDNSNULL;
3382 if (request->u.addrinfo.q6.qnameOrig)
3384 freeL("QueryTermination", request->u.addrinfo.q6.qnameOrig);
3385 request->u.addrinfo.q6.qnameOrig = mDNSNULL;
3387 if (request->u.addrinfo.q62)
3389 if (request->u.addrinfo.q62->QuestionContext)
3391 LogInfo("addrinfo_termination_callback: Stopping q62 %##s", request->u.addrinfo.q62->qname.c);
3392 mDNS_StopQuery(&mDNSStorage, request->u.addrinfo.q62);
3394 if (request->u.addrinfo.q62->qnameOrig)
3396 LogInfo("addrinfo_termination_callback: freeing q62 qnameOrig %##s", request->u.addrinfo.q62->qnameOrig->c);
3397 freeL("QueryTermination q62", request->u.addrinfo.q62->qnameOrig);
3398 request->u.addrinfo.q62->qnameOrig = mDNSNULL;
3400 freeL("addrinfo Q62", request->u.addrinfo.q62);
3401 request->u.addrinfo.q62 = mDNSNULL;
3405 mDNSlocal mStatus handle_addrinfo_request(request_state *request)
3411 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
3412 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
3414 mDNSPlatformMemZero(&request->u.addrinfo, sizeof(request->u.addrinfo));
3415 request->u.addrinfo.interface_id = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
3416 request->u.addrinfo.flags = flags;
3417 request->u.addrinfo.protocol = get_uint32(&request->msgptr, request->msgend);
3419 if (interfaceIndex && !request->u.addrinfo.interface_id) return(mStatus_BadParamErr);
3420 if (request->u.addrinfo.protocol > (kDNSServiceProtocol_IPv4|kDNSServiceProtocol_IPv6)) return(mStatus_BadParamErr);
3422 if (get_string(&request->msgptr, request->msgend, hostname, 256) < 0) return(mStatus_BadParamErr);
3424 if (!request->msgptr) { LogMsg("%3d: DNSServiceGetAddrInfo(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
3430 if (!AuthorizedDomain(request, &d, AutoBrowseDomains)) return (mStatus_NoError);
3433 if (!request->u.addrinfo.protocol)
3436 request->u.addrinfo.protocol = (kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6);
3439 request->u.addrinfo.q4.InterfaceID = request->u.addrinfo.q6.InterfaceID = request->u.addrinfo.interface_id;
3440 request->u.addrinfo.q4.Target = request->u.addrinfo.q6.Target = zeroAddr;
3441 request->u.addrinfo.q4.qname = request->u.addrinfo.q6.qname = d;
3442 request->u.addrinfo.q4.qclass = request->u.addrinfo.q6.qclass = kDNSServiceClass_IN;
3443 request->u.addrinfo.q4.LongLived = request->u.addrinfo.q6.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
3444 request->u.addrinfo.q4.ExpectUnique = request->u.addrinfo.q6.ExpectUnique = mDNSfalse;
3445 request->u.addrinfo.q4.ForceMCast = request->u.addrinfo.q6.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
3446 request->u.addrinfo.q4.ReturnIntermed = request->u.addrinfo.q6.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
3447 request->u.addrinfo.q4.SuppressUnusable = request->u.addrinfo.q6.SuppressUnusable = (flags & kDNSServiceFlagsSuppressUnusable ) != 0;
3448 request->u.addrinfo.q4.TimeoutQuestion = request->u.addrinfo.q6.TimeoutQuestion = (flags & kDNSServiceFlagsTimeout ) != 0;
3449 request->u.addrinfo.q4.WakeOnResolve = request->u.addrinfo.q6.WakeOnResolve = 0;
3450 request->u.addrinfo.q4.qnameOrig = request->u.addrinfo.q6.qnameOrig = mDNSNULL;
3452 if (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv4)
3454 request->u.addrinfo.q4.qtype = kDNSServiceType_A;
3455 request->u.addrinfo.q4.SearchListIndex = 0;
3462 request->u.addrinfo.q4.AppendSearchDomains = 1;
3463 request->u.addrinfo.q4.AppendLocalSearchDomains = 1;
3467 request->u.addrinfo.q4.AppendSearchDomains = 0;
3468 request->u.addrinfo.q4.AppendLocalSearchDomains = 0;
3470 request->u.addrinfo.q4.RetryWithSearchDomains = (ApplySearchDomainsFirst(&request->u.addrinfo.q4) ? 1 : 0);
3471 request->u.addrinfo.q4.QuestionCallback = queryrecord_result_callback;
3472 request->u.addrinfo.q4.QuestionContext = request;
3473 err = mDNS_StartQuery(&mDNSStorage, &request->u.addrinfo.q4);
3477 request->u.addrinfo.q4.QuestionContext = mDNSNULL;
3480 err = SendAdditionalQuery(&request->u.addrinfo.q4, request, err);
3484 if (!err && (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv6))
3486 request->u.addrinfo.q6.qtype = kDNSServiceType_AAAA;
3487 request->u.addrinfo.q6.SearchListIndex = 0;
3490 request->u.addrinfo.q6.AppendSearchDomains = 1;
3491 request->u.addrinfo.q6.AppendLocalSearchDomains = 1;
3495 request->u.addrinfo.q6.AppendSearchDomains = 0;
3496 request->u.addrinfo.q6.AppendLocalSearchDomains = 0;
3498 request->u.addrinfo.q6.RetryWithSearchDomains = (ApplySearchDomainsFirst(&request->u.addrinfo.q6) ? 1 : 0);
3499 request->u.addrinfo.q6.QuestionCallback = queryrecord_result_callback;
3500 request->u.addrinfo.q6.QuestionContext = request;
3501 err = mDNS_StartQuery(&mDNSStorage, &request->u.addrinfo.q6);
3505 request->u.addrinfo.q6.QuestionContext = mDNSNULL;
3506 if (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv4)
3509 mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q4);
3510 request->u.addrinfo.q4.QuestionContext = mDNSNULL;
3514 err = SendAdditionalQuery(&request->u.addrinfo.q6, request, err);
3519 request->sd, flags, interfaceIndex, request->u.addrinfo.protocol, d.c);
3521 if (!err) request->terminate = addrinfo_termination_callback;
3529 #pragma mark - Main Request Handler etc.
3555 LogMsg("%3d: ERROR: read data from a completed request", req->sd);
3580 // Largest conceivable single request is a DNSServiceRegisterRecord() or DNSServiceAddRecord()
3849 // There's no return data for a cancel request (DNSServiceRefDeallocate returns no result)
3913 request_state *request = NewRequest();
3914 request->ts = t_morecoming;
3915 request->sd = sd;
3916 request->errsd = sd;
3920 if (getsockopt(sd, 0, LOCAL_PEERCRED, &x, &xucredlen) >= 0 && x.cr_version == XUCRED_VERSION) request->uid = x.cr_uid;
3924 LogOperation("%3d: Adding FD for uid %u", request->sd, request->uid);
3925 udsSupportAddFDToEventLoop(sd, request_callback, request, &request->platform_data);
4419 LogMsgNoIdent("%3d: Orhpan operation %p; parent %p not found in request list", req->sd);
4442 LogMsgNoIdent("%p Address Request Retry %5d Interval %5d", nat,
4570 LogMemCorruption("UDS request list: %p is garbage (%d)", req, req->sd);
4573 LogMemCorruption("UDS request list: req->primary should not point to self %p/%d", req, req->sd);
4576 LogMemCorruption("UDS request list: Subordinate request %p/%d/%p should not have replies (%p)",
4581 LogMemCorruption("UDS request list: req %p primary %p is misaligned (%d)", req, p, req->sd);
4583 LogMemCorruption("UDS request list: req %p primary %p is garbage (%d)", req, p, p->sd);
4727 if (!dnssd_SocketValid(r->sd)) // If this request is finished, unlink it from the list and free the memory
4729 // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
