Lines Matching refs:REQUEST
114 mDNSlocal void set_peer_pid(request_state *request);
115 mDNSlocal mDNSu32 request_state_get_duration(const request_state *request);
116 mDNSlocal mDNSBool requestShouldLogName(request_state *request);
117 mDNSlocal mDNSBool requestShouldLogFullRequestInfo(request_state *request);
163 // MARK: - Log macro for request state logging.
165 #define UDS_LOG_CLIENT_REQUEST_WITH_DURATION(CATEGORY, LEVEL, REQUEST, LOG_DURATION, FORMAT, ...) \
171 ##__VA_ARGS__, request_state_get_duration(REQUEST)); \
180 #define UDS_LOG_CLIENT_REQUEST_WITH_NAME_HASH_DURATION(CATEGORY, LEVEL, NAME_FOR_NAME_HASH, REQUEST, \
186 UDS_LOG_CLIENT_REQUEST_WITH_DURATION(CATEGORY, LEVEL, (REQUEST), LOG_DURATION, \
191 UDS_LOG_CLIENT_REQUEST_WITH_DURATION(CATEGORY, LEVEL, (REQUEST), LOG_DURATION, \
197 #define UDS_LOG_CLIENT_REQUEST(CATEGORY, LEVEL, OPERATION_STR, NAME_FOR_NAME_HASH, REQUEST, LOG_DURATION, \
201 if (requestShouldLogFullRequestInfo(REQUEST)) \
204 CATEGORY, LEVEL, (NAME_FOR_NAME_HASH), (REQUEST), (LOG_DURATION), \
207 (REQUEST)->request_id, ##__VA_ARGS__, (REQUEST)->flags, (REQUEST)->interfaceIndex, \
208 (REQUEST)->process_id, (REQUEST)->pid_name); \
213 CATEGORY, LEVEL, (NAME_FOR_NAME_HASH), (REQUEST), (LOG_DURATION), \
214 "[R%u] " OPERATION_STR " -- ", (REQUEST)->request_id); \
219 #define UDS_LOG_CLIENT_REQUEST_WITH_DNSSEC_INFO(CATEGORY, LEVEL, OPERATION_STR, NAME_FOR_NAME_HASH, REQUEST, \
225 UDS_LOG_CLIENT_REQUEST(CATEGORY, LEVEL, OPERATION_STR, NAME_FOR_NAME_HASH, REQUEST, LOG_DURATION, \
230 UDS_LOG_CLIENT_REQUEST(CATEGORY, LEVEL, OPERATION_STR, NAME_FOR_NAME_HASH, REQUEST, LOG_DURATION, \
448 LogMcastNoIdent("%3d: Orphan operation; parent not found in request list", req->sd);
531 // We also set req->terminate to a bogus value so we know if abort_request() gets called again for this request
566 mDNSlocal mDNSBool _prepare_trusts_for_request(request_state * const request)
568 if (request->trusts == NULL)
570 request->trusts = CFArrayCreateMutable(kCFAllocatorDefault, 0, &mdns_cfarray_callbacks);
571 if (!request->trusts)
649 mDNSlocal reply_state *create_reply(const reply_op_t op, const size_t datalen, request_state *const request)
670 reply->mhdr->client_context = request->hdr.client_context;
676 // Append a reply to the list in a request object
677 // If our request is sharing a connection, then we append our reply_state onto the primary's list
678 // If the request does not want asynchronous replies, then the reply is freed instead of being appended to any list.
698 mDNSlocal const uint8_t * _get_signed_data_tlvs(request_state *const request, size_t *const out_length)
701 if (request->msgptr && (request->hdr.ipc_flags & IPC_FLAGS_TRAILING_TLVS))
703 const mDNSu8 *const start = (const mDNSu8 *)request->msgptr;
704 const mDNSu8 *const end = (const mDNSu8 *)request->msgend;
708 request->sign_result = mDNStrue;
720 mDNSlocal mStatus get_signed_result_flags_tlvs(request_state *const request)
723 (void)_get_signed_data_tlvs(request, NULL);
727 mDNSlocal mStatus get_signed_browse_tlvs(request_state *const request)
730 const mDNSu8 * const data = _get_signed_data_tlvs(request, &len);
731 if (request->sign_result)
748 request->signed_obj = mdns_signed_result_upcast(signed_obj);
753 mDNSlocal mStatus get_signed_resolve_tlvs(request_state *const request)
756 const mDNSu8 * const data = _get_signed_data_tlvs(request, &len);
757 if (request->sign_result)
774 request->signed_obj = mdns_signed_result_upcast(signed_obj);
788 mDNSlocal void get_tracker_info_tlvs(request_state *const request)
790 if (request->msgptr && (request->hdr.ipc_flags & IPC_FLAGS_TRAILING_TLVS))
792 const mDNSu8 *const start = (const mDNSu8 *)request->msgptr;
793 const mDNSu8 *const end = (const mDNSu8 *)request->msgend;
795 request->addTrackerInfo = (result != 0) ? mDNStrue : mDNSfalse;
811 request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
852 if (request->sign_result && servicename)
876 *rep = create_reply(op, len, request);
899 request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
932 *rep = create_reply(op, len, request);
946 mDNSlocal mDNSBool get_service_attr_tsr_params(const request_state *const request, mDNSu32 *const outTimestamp,
949 if (request->msgptr && (request->hdr.ipc_flags & IPC_FLAGS_TRAILING_TLVS) &&
953 const mDNSu8 *const start = (const mDNSu8 *)request->msgptr;
954 const mDNSu8 *const end = (const mDNSu8 *)request->msgend;
972 mDNSlocal AuthRecord *read_rr_from_ipc_msg(request_state *request, int GetTTL, int validate_flags)
974 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
975 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
977 int str_err = get_string(&request->msgptr, request->msgend, name, sizeof(name));
978 mDNSu16 type = get_uint16(&request->msgptr, request->msgend);
979 mDNSu16 class = get_uint16(&request->msgptr, request->msgend);
980 mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
981 const mDNSu8 *const rdata = get_rdata(&request->msgptr, request->msgend, rdlen);
982 mDNSu32 ttl = GetTTL ? get_uint32(&request->msgptr, request->msgend) : 0;
989 request->flags = flags;
990 request->interfaceIndex = interfaceIndex;
993 if (!request->msgptr) { LogMsg("Error reading Resource Record from client"); return NULL; }
1057 request->request_id, DM_NAME_PARAM(rr->resrec.name), DNSTypeName(type));
1093 request, const domainname * const d, const DNameListElem * const doms)
1100 if (SystemUID(request->uid)) return mDNStrue;
1112 allow = (allow || (delem->uid == request->uid));
1130 const pid_t requestPID = instance->request->process_id;
1132 const request_servicereg *const servicereg = instance->request->servicereg;
1142 external_start_advertising_service(&st[i].resrec, instance->request->flags, requestPID);
1144 external_start_advertising_service(&instance->srs.RR_PTR.resrec, instance->request->flags, requestPID);
1145 external_start_advertising_service(&instance->srs.RR_SRV.resrec, instance->request->flags, requestPID);
1146 external_start_advertising_service(&instance->srs.RR_TXT.resrec, instance->request->flags, requestPID);
1149 external_start_advertising_service(&e->r.resrec, instance->request->flags, requestPID);
1164 if (instance->request)
1166 const pid_t requestPID = instance->request->process_id;
1167 for (i = 0; i < instance->request->servicereg->num_subtypes; i++)
1169 external_stop_advertising_service(&st[i].resrec, instance->request->flags, requestPID);
1172 external_stop_advertising_service(&instance->srs.RR_PTR.resrec, instance->request->flags, requestPID);
1173 external_stop_advertising_service(&instance->srs.RR_SRV.resrec, instance->request->flags, requestPID);
1174 external_stop_advertising_service(&instance->srs.RR_TXT.resrec, instance->request->flags, requestPID);
1178 external_stop_advertising_service(&e->r.resrec, instance->request->flags, requestPID);
1212 if (srv->request)
1214 service_instance **p = &srv->request->servicereg->instances;
1274 if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, 0, mStatus_NoError) != mStatus_NoError)
1275 LogMsg("%3d: SendServiceRemovalNotification: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
1276 else { append_reply(instance->request, rep); instance->clientnotified = mDNSfalse; }
1302 if (instance->request &&
1303 instance->request->servicereg->default_domain &&
1311 mDNSu32 request_id = instance->request ? instance->request->request_id : 0;
1337 if (!instance->request && result != mStatus_MemFree)
1339 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "regservice_callback: instance->request is NULL %d", result);
1344 const request_servicereg *const servicereg = instance->request->servicereg;
1355 if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
1356 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] regservice_callback: " PRI_DM_NAME " is not valid DNS-SD SRV name", instance->request->request_id, DM_NAME_PARAM(srs->RR_SRV.resrec.name));
1357 else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
1360 if (callExternalHelpers(servicereg->InterfaceID, &instance->domain, instance->request->flags))
1362 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] regservice_callback: calling external_start_advertising_helper()", instance->request->request_id);
1371 if (instance->request && instance->renameonmemfree)
1377 err = mDNS_RenameAndReregisterService(m, srs, &instance->request->servicereg->name);
1379 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] ERROR: regservice_callback - RenameAndReregisterService returned %d", instance->request->request_id, err);
1387 const request_servicereg *const servicereg = instance->request->servicereg;
1409 if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
1410 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] regservice_callback: " PRI_DM_NAME " is not valid DNS-SD SRV name", instance->request->request_id, DM_NAME_PARAM(srs->RR_SRV.resrec.name));
1411 else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
1420 if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
1421 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] regservice_callback: " PRI_DM_NAME " is not valid DNS-SD SRV name", instance->request->request_id, DM_NAME_PARAM(srs->RR_SRV.resrec.name));
1422 else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
1452 request_state *request = re->request;
1475 request->request_id, re->key, RRDisplayString(m, &rr->resrec), result_description);
1481 reply_state *reply = create_reply(reg_record_reply_op, len, request);
1486 append_reply(request, reply);
1495 "[R%u] regrecord_callback: Callback with error code mStatus_BadStateErr - not freeing the record.", request->request_id);
1500 registered_record_entry **ptr = &request->reg_recs;
1505 "[R%u] regrecord_callback - record not in list!", request->request_id);
1518 "[R%u] regrecord_callback: external_advertise already set!", request->request_id);
1522 if (callExternalHelpers(re->origInterfaceID, &rr->namestorage, request->flags))
1525 "[R%u] regrecord_callback: calling external_start_advertising_service", request->request_id);
1526 external_start_advertising_service(&rr->resrec, request->flags, request->process_id);
1534 // set_peer_pid() is called after mem is allocated for each new request in NewRequest()
1536 mDNSlocal void set_peer_pid(request_state *request)
1538 request->pid_name[0] = '\0';
1539 request->process_id = -1;
1543 if (request->sd < 0)
1546 if (getsockopt(request->sd, SOL_LOCAL, LOCAL_PEEREPID, &p, &len) != 0)
1549 request->process_id = p;
1552 if (request->sd < 0)
1557 mDNSlocal mDNSu32 request_state_get_duration(const request_state *const request)
1559 return (mDNSu32)(mDNSPlatformContinuousTimeSeconds() - request->request_start_time_secs);
1564 mDNSlocal mDNSBool requestShouldLogName(request_state *const request)
1566 const mDNSs32 lastFullLogTimeSecs = request->last_full_log_time_secs;
1572 request->last_full_log_time_secs = nowTimeSecs;
1579 mDNSlocal mDNSBool requestShouldLogFullRequestInfo(request_state *const request)
1581 const mDNSs32 lastFullQInfoTimeSecs = request->request_start_time_secs;
1586 request->request_start_time_secs = mDNSPlatformContinuousTimeSeconds();
1595 request->last_full_log_time_secs = nowTimeSecs;
1600 mDNSlocal void connection_termination(request_state *request)
1608 request->request_id, request->process_id, request->pid_name);
1612 if ((*req)->primary == request)
1614 // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
1626 while (request->reg_recs)
1628 registered_record_entry *ptr = request->reg_recs;
1631 request->request_id, request->flags, request->interfaceIndex, RRDisplayString(&mDNSStorage, &ptr->rr->resrec), request->process_id,
1632 request->pid_name, request_state_get_duration(request));
1633 request->reg_recs = request->reg_recs->next;
1639 external_stop_advertising_service(&ptr->rr->resrec, request->flags, request->process_id);
1642 LogMcastS(ptr->rr, request, reg_stop);
1646 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
1647 mdns_powerlog_register_record_stop(request->pid_name, ptr->powerlog_start_time, usesAWDL);
1655 mDNSlocal void handle_cancel_request(request_state *request)
1659 request->request_id, request->hdr.client_context.u32[1], request->hdr.client_context.u32[0]);
1662 if ((*req)->primary == request &&
1663 (*req)->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
1664 (*req)->hdr.client_context.u32[1] == request->hdr.client_context.u32[1])
1666 // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
1677 mDNSlocal mStatus _handle_regrecord_request_start(request_state *request, AuthRecord * rr)
1693 re->key = request->hdr.reg_index;
1695 re->regrec_client_context = request->hdr.client_context;
1696 re->request = request;
1700 rr->ForceMCast = ((request->flags & kDNSServiceFlagsForceMulticast) != 0);
1706 if (!AuthorizedDomain(request, rr->resrec.name, AutoRegistrationDomains)) return (mStatus_NoError);
1714 record->name, request, mDNSfalse, "name: " PRI_DM_NAME ", type: " PUB_DNS_TYPE,
1722 request->request_id, request->flags, request->interfaceIndex, RRDisplayString(&mDNSStorage, &rr->resrec), err);
1731 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
1732 re->powerlog_start_time = mdns_powerlog_register_record_start(request->pid_name, usesAWDL);
1735 LogMcastS(rr, request, reg_start);
1736 re->next = request->reg_recs;
1737 request->reg_recs = re;
1744 mDNSlocal void _return_regrecord_request_error(request_state *request, mStatus error)
1747 if (GenerateNTDResponse(NULL, 0, request, &rep, reg_record_reply_op, 0, error) != mStatus_NoError)
1749 LogRedact(MDNS_LOG_CATEGORY_MDNS, MDNS_LOG_ERROR, "[R%u] DNSServiceRegisterRecord _return_regrecord_request_error: error(%d)", request->request_id, error);
1753 append_reply(request, rep);
1757 mDNSlocal mStatus _handle_regrecord_request_with_trust(request_state *request, AuthRecord * rr)
1760 if (!request->peer_token)
1762 LogRedact(MDNS_LOG_CATEGORY_MDNS, MDNS_LOG_WARNING, "[R%u] _handle_regrecord_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
1763 err = _handle_regrecord_request_start(request, rr);
1778 const audit_token_t *const token = mdns_audit_token_get_token(request->peer_token);
1786 if (!_prepare_trusts_for_request(request))
1817 error = _handle_regrecord_request_start(request, _rr);
1818 // No context means the request was canceled before we got here
1822 _return_regrecord_request_error(request, error);
1828 CFArrayAppendValue(request->trusts, trust);
1840 err = _handle_regrecord_request_start(request, rr);
1853 mDNSlocal mStatus regRecordAddTSRRecord(request_state *const request, AuthRecord *const rr, const mDNSs32 tsrTimestamp,
1877 ar->ForceMCast = ((request->flags & kDNSServiceFlagsForceMulticast) != 0);
1879 request->request_id, request->flags, request->interfaceIndex, RRDisplayString(&mDNSStorage, &ar->resrec),
1880 request->process_id, request->pid_name);
1886 request->request_id, request->flags, request->interfaceIndex, RRDisplayString(&mDNSStorage, &ar->resrec), err);
1891 LogMcastS(ar, request, reg_start);
1892 ar->RRSet = (uintptr_t)request->sd;
1897 mDNSlocal mStatus updateTSRRecord(const request_state *const request, AuthRecord *const tsr, const mDNSs32 tsrTimestamp,
1916 err = update_record(tsr, sizeof(rdataOpt), rdataOpt, kHostNameTTL, mDNSNULL, request->request_id);
1978 mDNSlocal mStatus handle_regrecord_request(request_state *request)
1983 if (request->terminate != connection_termination)
1984 { LogMsg("%3d: DNSServiceRegisterRecord(not a shared connection ref)", request->sd); return(err); }
1986 rr = read_rr_from_ipc_msg(request, 1, 1);
1988 const mDNSBool foundTSRParams = get_service_attr_tsr_params(request, &tsrTimestamp, &tsrHostkeyHash);
2000 rr->RRSet = (uintptr_t)request->sd;
2022 err = _handle_regrecord_request_with_trust(request, rr);
2026 err = _handle_regrecord_request_start(request, rr);
2029 err = _handle_regrecord_request_start(request, rr);
2036 err = updateTSRRecord(request, currentTSR, timestampContinuous, tsrHostkeyHash);
2040 err = regRecordAddTSRRecord(request, rr, timestampContinuous, tsrHostkeyHash);
2054 registered_record_entry **ptr = &request->reg_recs;
2059 "[R%u] handle_regrecord_request - record not in list!", request->request_id);
2065 request->request_id, ARDisplayString(&mDNSStorage, rr), rr, rr->resrec.InterfaceID);
2078 mDNSlocal void regservice_termination_callback(request_state *const request)
2080 if (!request)
2085 request_servicereg *const servicereg = request->servicereg;
2092 request->request_id, DM_NAME_PARAM(p->srs.RR_SRV.resrec.name),
2094 mDNSVal16(p->srs.RR_SRV.resrec.rdata->u.srv.port), request->process_id, request->pid_name,
2095 request_state_get_duration(request));
2099 SkipLeadingLabels(srv_rr->name, 1), request, mDNStrue, "SRV name: " PRI_DM_NAME " (%x), port: %u",
2110 // We can't clear p->request *after* the calling mDNS_DeregisterService/unlink_and_free_service_instance
2112 p->request = NULL;
2113 LogMcastS(&p->srs.RR_SRV, request, reg_stop);
2120 if (request->powerlog_start_time != 0)
2122 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
2123 mdns_powerlog_service_register_stop(request->pid_name, request->powerlog_start_time, usesAWDL);
2124 request->powerlog_start_time = 0;
2141 mDNSlocal request_state *LocateSubordinateRequest(request_state *request)
2145 if (req->primary == request &&
2146 req->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
2147 req->hdr.client_context.u32[1] == request->hdr.client_context.u32[1]) return(req);
2148 return(request);
2151 mDNSlocal mStatus add_record_to_service(request_state *const request, service_instance *const instance, const mDNSu16 rrtype,
2164 const request_servicereg *const servicereg = request->servicereg;
2169 request->request_id, DM_NAME_PARAM(servicereg->instances ?
2178 result = mDNS_AddRecordToService(&mDNSStorage, srs, extra, &extra->r.rdatastorage, ttl, request->flags);
2184 LogMcastS(&srs->RR_PTR, request, reg_start);
2186 extra->ClientID = request->hdr.reg_index;
2189 && callExternalHelpers(servicereg->InterfaceID, &instance->domain, request->flags))
2192 external_start_advertising_service(&extra->r.resrec, request->flags, request->process_id);
2198 mDNSlocal mStatus handle_add_request(request_state *request)
2202 DNSServiceFlags flags = get_flags (&request->msgptr, request->msgend);
2203 mDNSu16 rrtype = get_uint16(&request->msgptr, request->msgend);
2204 mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
2205 const mDNSu8 *const rdata = (const mDNSu8 *)get_rdata(&request->msgptr, request->msgend, rdlen);
2206 mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
2210 if (!request->msgptr)
2213 "[R%d] DNSServiceAddRecord(unreadable parameters)", request->request_id);
2218 if (requestrequest = LocateSubordinateRequest(request);
2220 if (request->terminate != regservice_termination_callback)
2223 "[R%d] DNSServiceAddRecord(not a registered service ref)", request->request_id);
2229 const request_servicereg *const servicereg = request->servicereg;
2233 "[R%d] DNSServiceAddRecord: adding record to a service registered with zero port", request->request_id);
2238 request->request_id, flags,
2240 DNSTypeName(rrtype), rdlen, request->process_id, request->pid_name);
2244 result = add_record_to_service(request, i, rrtype, rdlen, rdata, ttl);
2321 mDNSlocal mStatus handle_tsr_update_request(const request_state *const request, const AuthRecord *const rr,
2336 result = updateTSRRecord(request, currentTSR, timestampContinuous, tsrHostkeyHash);
2349 mDNSlocal mStatus handle_update_request(request_state *request)
2351 const ipc_msg_hdr *const hdr = &request->hdr;
2357 DNSServiceFlags flags = get_flags (&request->msgptr, request->msgend); // flags unused
2358 mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
2359 const mDNSu8 *const rdata = (const mDNSu8 *)get_rdata(&request->msgptr, request->msgend, rdlen);
2360 mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
2363 if (!request->msgptr)
2366 "[R%d] DNSServiceUpdateRecord(unreadable parameters)", request->request_id);
2371 const mDNSBool foundTSRParams = get_service_attr_tsr_params(request, &tsrTimestamp, &tsrHostkeyHash);
2376 request->request_id, tsrTimestamp, tsrHostkeyHash);
2380 if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
2382 if (request->terminate == connection_termination)
2385 for (const registered_record_entry *reptr = request->reg_recs; reptr; reptr = reptr->next)
2391 result = handle_tsr_update_request(request, reptr->rr, tsrTimestamp, tsrHostkeyHash);
2395 result = update_record(reptr->rr, rdlen, rdata, ttl, &reptr->external_advertise, request->request_id);
2399 request->request_id, DM_NAME_PARAM(reptr->rr->resrec.name),
2401 request->process_id, request->pid_name);
2409 if (request->terminate != regservice_termination_callback)
2412 "[R%d] DNSServiceUpdateRecord(not a registered service ref)", request->request_id);
2417 request_servicereg *servicereg = request->servicereg;
2421 "[R%d] DNSServiceUpdateRecord: updating the record of a service registered with zero port", request->request_id);
2453 result = handle_tsr_update_request(request, rr, tsrTimestamp, tsrHostkeyHash);
2458 result = update_record(rr, rdlen, rdata, ttl, &i->external_advertise, request->request_id);
2465 if (request->terminate == regservice_termination_callback)
2467 servicereg = request->servicereg;
2475 request->request_id, DM_NAME_PARAM(srvName), nameHash, DNS_TYPE_PARAM(rrType),
2476 request->process_id, request->pid_name);
2482 mDNSlocal mStatus remove_record(request_state *request)
2485 registered_record_entry *e, **ptr = &request->reg_recs;
2487 while (*ptr && (*ptr)->key != request->hdr.reg_index) ptr = &(*ptr)->next;
2488 if (!*ptr) { LogMsg("%3d: DNSServiceRemoveRecord(%u) not found", request->sd, request->hdr.reg_index); return mStatus_BadReferenceErr; }
2493 request->sd, e->key, RRDisplayString(&mDNSStorage, &e->rr->resrec), request->process_id, request->pid_name);
2498 external_stop_advertising_service(&e->rr->resrec, request->flags, request->process_id);
2502 LogMcastS(e->rr, request, reg_stop);
2506 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
2507 mdns_powerlog_register_record_stop(request->pid_name, e->powerlog_start_time, usesAWDL);
2520 mDNSlocal mStatus remove_extra(const request_state *const request, service_instance *const serv, mDNSu16 *const rrtype)
2527 if (ptr->ClientID == request->hdr.reg_index) // found match
2533 external_stop_advertising_service(&ptr->r.resrec, request->flags, request->process_id);
2543 mDNSlocal mStatus handle_removerecord_request(request_state *request)
2546 get_flags(&request->msgptr, request->msgend); // flags unused
2548 if (!request->msgptr)
2551 "[R%d] DNSServiceRemoveRecord(unreadable parameters)", request->request_id);
2556 if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
2558 // LocateSubordinateRequest returns the connection it was passed if the request is not referring to a
2559 // subordinate request. In this case, if request->terminate == connection_terminate, that means that this
2562 if (request->terminate == connection_termination)
2563 err = remove_record(request);
2565 // Otherwise, the only type of request object to which DNSServiceRemoveRecord could apply is one that
2566 // was created with DNSServiceRegister, which is indicated by request->terminate == regservice_termination_callback.
2567 // So if that's not the case, the request is invalid.
2568 else if (request->terminate != regservice_termination_callback)
2571 "[R%d] DNSServiceRemoveRecord(not a registered service ref)", request->request_id);
2578 // In this case request is a request created with DNSServiceRegister, and there may be more than one
2581 const request_servicereg *const servicereg = request->servicereg;
2584 err = remove_extra(request, i, &rrtype);
2590 request->request_id,
2592 rrtype ? DNSTypeName(rrtype) : "<NONE>", request->process_id, request->pid_name, err);
2683 mDNSlocal mStatus register_service_instance(request_state *const request, const domainname *const domain)
2686 request_servicereg *const servicereg = request->servicereg;
2692 const mDNSBool foundTSRParams = get_service_attr_tsr_params(request, &tsrTimestamp, &tsrHostkeyHash);
2740 instance->request = request;
2769 interfaceID, regservice_callback, instance, request->flags);
2771 if (!result && (request->interfaceIndex != kDNSServiceInterfaceIndexLocalOnly) && DomainIsLocal)
2773 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
2774 request->powerlog_start_time = mdns_powerlog_service_register_start(request->pid_name, usesAWDL);
2783 result = updateTSRRecord(request, currentTSR, timestampContinuous, tsrHostkeyHash);
2798 result = add_record_to_service(request, instance, kDNSType_OPT, sizeof(rdataOpt), rdataOpt, kHostNameTTL);
2818 request->request_id, DM_NAME_PARAM(instance->srs.RR_SRV.resrec.name),
2822 LogMcastS(&instance->srs.RR_SRV, request, reg_start);
2836 request_state *request;
2839 for (request = all_requests; request; request = request->next)
2841 request_servicereg *const servicereg = request->servicereg;
2842 if (request->terminate != regservice_termination_callback) continue;
2844 if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
2851 if (!*ptr) register_service_instance(request, &d->name);
2866 if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
2874 if (si->clientnotified) SendServiceRemovalNotification(&si->srs); // Do this *before* clearing si->request backpointer
2875 // Now that we've cut this service_instance from the list, we MUST clear the si->request backpointer.
2883 // a service_instance with a stale si->request backpointer pointing to memory that's already been freed.
2884 si->request = NULL;
2911 mDNSlocal mStatus _handle_regservice_request_start(request_state *const request, const domainname *const d)
2915 request->terminate = regservice_termination_callback;
2916 err = register_service_instance(request, d);
2919 err = AuthorizedDomain(request, d, AutoRegistrationDomains) ? register_service_instance(request, d) : mStatus_NoError;
2923 const request_servicereg *const servicereg = request->servicereg;
2931 if (!ptr->uid || SystemUID(request->uid) || request->uid == ptr->uid)
2932 register_service_instance(request, &ptr->name);
2940 mDNSlocal void _return_regservice_request_error(request_state *const request, const mStatus error)
2942 request_servicereg *const servicereg = request->servicereg;
2950 if (GenerateNTDResponse(NULL, 0, request, &rep, reg_service_reply_op, 0, error) != mStatus_NoError)
2952 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEFAULT, "[R%u] DNSServiceRegister _return_regservice_request_error: error(%d)", request->request_id, error);
2956 append_reply(request, rep);
2960 mDNSlocal mStatus _handle_regservice_request_with_trust(request_state *const request, const domainname *const d)
2963 if (!request->peer_token)
2965 request->request_id, request->pid_name, request->process_id);
2966 err = _handle_regservice_request_start(request, d);
2970 const audit_token_t *const token = mdns_audit_token_get_token(request->peer_token);
2972 const request_servicereg *const servicereg = request->servicereg;
2978 if (!_prepare_trusts_for_request(request))
3015 error = _handle_regservice_request_start(request, _d);
3016 // No context means the request was canceled before we got here
3020 _return_regservice_request_error(request, error);
3026 CFArrayAppendValue(request->trusts, trust);
3038 err = _handle_regservice_request_start(request, d);
3050 mDNSlocal mStatus handle_regservice_request(request_state *const request)
3059 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
3060 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
3064 if (!request->servicereg)
3066 request->servicereg = (request_servicereg *)callocL("request_servicereg", sizeof(*request->servicereg));
3067 mdns_require_action_quiet(request->servicereg, exit, err = mStatus_NoMemoryErr; uds_log_error(
3068 "[R%u] Failed to allocate memory for service registration request", request->request_id));
3098 if (get_string(&request->msgptr, request->msgend, name, sizeof(name )) < 0 ||
3099 get_string(&request->msgptr, request->msgend, type_as_string, sizeof(type_as_string)) < 0 ||
3100 get_string(&request->msgptr, request->msgend, domain, sizeof(domain )) < 0 ||
3101 get_string(&request->msgptr, request->msgend, host, sizeof(host )) < 0)
3104 request->flags = flags;
3105 request->interfaceIndex = interfaceIndex;
3106 request_servicereg *const servicereg = request->servicereg;
3113 if (request->msgptr + 2 > request->msgend) request->msgptr = NULL;
3116 servicereg->port.b[0] = *request->msgptr++;
3117 servicereg->port.b[1] = *request->msgptr++;
3120 servicereg->txtlen = get_uint16(&request->msgptr, request->msgend);
3121 msgTXTData = get_rdata(&request->msgptr, request->msgend, servicereg->txtlen);
3123 if (!request->msgptr) { LogMsg("%3d: DNSServiceRegister(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
3193 LogMsg("Client application[%d](%s) registered %d identical instances of service %##s port %u.", request->process_id,
3194 request->pid_name, count+1, srv.c, mDNSVal16(servicereg->port));
3199 UDS_LOG_CLIENT_REQUEST(MDNS_LOG_CATEGORY_MDNS, MDNS_LOG_DEFAULT, "DNSServiceRegister START", &ptr_name, request,
3203 // We need to unconditionally set request->terminate, because even if we didn't successfully
3206 // We also need to set request->terminate first, before adding additional service instances,
3207 // because the udsserver_validatelists uses the request->terminate function pointer to determine
3208 // what kind of request this is, and therefore what kind of list validation is required.
3209 request->terminate = NULL;
3215 err = _handle_regservice_request_with_trust(request, &d);
3224 err = _handle_regservice_request_start(request, &d);
3227 err = _handle_regservice_request_start(request, &d);
3410 ubrowse->q.request_id = info->request_id; // This browse request is started on behalf of the original browse request.
3441 b->q.request_id = info->request_id; // This browse request is started on behalf of the original browse request.
3523 request_state *request;
3526 for (request = all_requests; request; request = request->next)
3528 if (request->terminate != browse_termination_callback) continue; // Not a browse operation
3529 if (!request->browse->default_domain) continue; // Not an auto-browse operation
3530 if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
3532 browser_t **ptr = &request->browse->browsers;
3537 if (!*ptr) add_domain_to_browser(request, &d->name);
3547 if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
3934 mDNSlocal mStatus _handle_browse_request_start(request_state *request, const char *domain)
3939 request->terminate = browse_termination_callback;
3944 err = add_domain_to_browser(request, &d);
3950 if (!sdom->uid || SystemUID(request->uid) || request->uid == sdom->uid)
3952 err = add_domain_to_browser(request, &sdom->name);
3966 mDNSlocal void _return_browse_request_error(request_state *request, mStatus error)
3970 GenerateBrowseReply(NULL, 0, request, &rep, browse_reply_op, 0, error);
3973 "[R%d] DNSServiceBrowse _return_browse_request_error: error (%d)", request->request_id, error);
3975 append_reply(request, rep);
3978 mDNSlocal mStatus _handle_browse_request_with_trust(request_state *request, const char * domain)
3981 if (!request->peer_token)
3983 LogRedact(MDNS_LOG_CATEGORY_MDNS, MDNS_LOG_WARNING, "[R%u] _handle_browse_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
3984 err = _handle_browse_request_start(request, domain);
3992 const request_browse *const browse = request->browse;
4002 const audit_token_t *const token = mdns_audit_token_get_token(request->peer_token);
4008 request->sign_result = mDNSfalse; // Reset this flag if not system privileged
4013 "[R%u] _handle_browse_request_with_trust: has media discovery entitlement", request->request_id);
4014 request->sign_result = mDNStrue; // Always sign results for media discovery entitlement
4022 if (!_prepare_trusts_for_request(request))
4061 error = _handle_browse_request_start(request, _domain);
4062 // No context means the request was canceled before we got here
4066 _return_browse_request_error(request, error);
4072 CFArrayAppendValue(request->trusts, trust);
4084 err = _handle_browse_request_start(request, domain);
4096 mDNSlocal mStatus handle_browse_request(request_state *request)
4104 if (!request->browse)
4106 request->browse = (request_browse *)callocL("request_browse", sizeof(*request->browse));
4107 mdns_require_action_quiet(request->browse, exit, err = mStatus_NoMemoryErr; uds_log_error(
4108 "[R%u] Failed to allocate memory for browse request", request->request_id));
4110 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
4111 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
4131 if (get_string(&request->msgptr, request->msgend, regtype, sizeof(regtype)) < 0 ||
4132 get_string(&request->msgptr, request->msgend, domain, sizeof(domain )) < 0) return(mStatus_BadParamErr);
4134 if (!request->msgptr) { LogMsg("%3d: DNSServiceBrowse(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
4137 err = get_signed_result_flags_tlvs(request);
4138 if (err) { LogMsg("%3d: handle_browse_request err reading Validation TLVS", request->sd); return(err); }
4141 request->flags = flags;
4142 request->interfaceIndex = interfaceIndex;
4160 request_browse *const browse = request->browse;
4168 "DNSServiceBrowse START", mDNSNULL, request, mDNSfalse, "service type: " PRI_DM_NAME ", domain: " PRI_S,
4174 "PID[%d](" PUB_S ")", request->request_id, request->process_id, request->pid_name);
4183 // We need to unconditionally set request->terminate, because even if we didn't successfully
4186 request->terminate = NULL;
4195 err = _handle_browse_request_with_trust(request, domain);
4199 err = _handle_browse_request_start(request, domain);
4202 err = _handle_browse_request_start(request, domain);
4212 mDNSlocal void resolve_termination_callback(request_state *request)
4214 request_resolve *const resolve = request->resolve;
4218 &resolve->qtxt.qname, request, mDNStrue, "SRV name: " PRI_DM_NAME, DM_NAME_PARAM_NONNULL(&resolve->qtxt.qname));
4222 LogMcastQ(&resolve->qsrv, request, q_stop);
4226 external_stop_resolving_service(resolve->qsrv.InterfaceID, &resolve->qsrv.qname, request->flags, request->process_id);
4230 if (request->powerlog_start_time != 0)
4232 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
4233 mdns_powerlog_resolve_stop(request->pid_name, request->powerlog_start_time, usesAWDL);
4234 request->powerlog_start_time = 0;
4245 mDNSlocal mStatus _handle_resolve_request_start(request_state *const request, const _resolve_start_params_t *const params)
4249 request_resolve *const resolve = request->resolve;
4261 request->terminate = resolve_termination_callback;
4263 if ((request->interfaceIndex != kDNSServiceInterfaceIndexLocalOnly) && IsLocalDomain(¶ms->fqdn))
4265 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
4266 request->powerlog_start_time = mdns_powerlog_resolve_start(request->pid_name, usesAWDL);
4269 LogMcastQ(&resolve->qsrv, request, q_start);
4271 if (callExternalHelpers(params->InterfaceID, ¶ms->fqdn, request->flags))
4275 external_start_resolving_service(params->InterfaceID, ¶ms->fqdn, request->flags, request->process_id);
4333 // For resolve request, we do not deliver remove event to the client.
4552 mDNSlocal void _return_resolve_request_error(request_state * request, mStatus error)
4560 "[R%u] DNSServiceResolve _return_resolve_request_error: error(%d)", request->request_id, error);
4570 rep = create_reply(resolve_reply_op, len, request);
4584 append_reply(request, rep);
4587 mDNSlocal mStatus _handle_resolve_request_with_trust(request_state *request, const _resolve_start_params_t * const params)
4590 if (!request->peer_token)
4592 LogRedact(MDNS_LOG_CATEGORY_MDNS, MDNS_LOG_WARNING, "[R%u] _handle_resolve_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
4593 err = _handle_resolve_request_start(request, params);
4597 const audit_token_t *const token = mdns_audit_token_get_token(request->peer_token);
4605 if (!_prepare_trusts_for_request(request))
4643 error = _handle_resolve_request_start(request, _params);
4644 // No context means the request was canceled before we got here
4648 _return_resolve_request_error(request, error);
4654 CFArrayAppendValue(request->trusts, trust);
4666 err = _handle_resolve_request_start(request, params);
4678 mDNSlocal mStatus handle_resolve_request(request_state *request)
4684 if (!request->resolve)
4686 request->resolve = (request_resolve *)callocL("request_resolve", sizeof(*request->resolve));
4687 mdns_require_action_quiet(request->resolve, exit, err = mStatus_NoMemoryErr; uds_log_error(
4688 "[R%u] Failed to allocate memory for resolve request", request->request_id));
4691 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
4692 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
4722 if (get_string(&request->msgptr, request->msgend, name, sizeof(name )) < 0 ||
4723 get_string(&request->msgptr, request->msgend, params.regtype, sizeof(params.regtype)) < 0 ||
4724 get_string(&request->msgptr, request->msgend, domain, sizeof(domain )) < 0)
4727 if (!request->msgptr) { LogMsg("%3d: DNSServiceResolve(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
4730 err = get_signed_browse_tlvs(request);
4731 if (err) { LogMsg("%3d: handle_resolve_request err reading Validation TLVS", request->sd); return(err); }
4737 request->flags = flags;
4738 request->interfaceIndex = interfaceIndex;
4741 request_resolve *const resolve = request->resolve;
4757 resolve->qsrv.pid = request->process_id;
4758 resolve->qsrv.euid = request->uid;
4760 resolve->qsrv.QuestionContext = request;
4777 resolve->qtxt.pid = request->process_id;
4778 resolve->qtxt.euid = request->uid;
4780 resolve->qtxt.QuestionContext = request;
4787 if (!AuthorizedDomain(request, &fqdn, AutoBrowseDomains)) return(mStatus_NoError);
4791 &resolve->qsrv.qname, request, mDNSfalse, "SRV name: " PRI_DM_NAME, DM_NAME_PARAM(&resolve->qsrv.qname));
4793 request->terminate = NULL;
4798 if (request->signed_obj)
4800 mdns_signed_browse_result_t browseResult = mdns_signed_browse_result_downcast(request->signed_obj);
4808 request->request_id);
4817 request->request_id);
4825 request->request_id, DM_NAME_PARAM(&resolve->qsrv.qname), interfaceIndex);
4826 request->sign_result = mDNSfalse;
4827 mdns_forget(&request->signed_obj);
4839 err = _handle_resolve_request_with_trust(request, ¶ms);
4843 err = _handle_resolve_request_start(request, ¶ms);
4846 err = _handle_resolve_request_start(request, ¶ms);
5049 mDNSlocal void queryrecord_termination_callback(request_state *request)
5051 const domainname *const qname = QueryRecordClientRequestGetQName(request->queryrecord);
5054 const mDNSu16 qtype = QueryRecordClientRequestGetType(request->queryrecord);
5056 "DNSServiceQueryRecord STOP", qname, request, mDNStrue, "qname: " PRI_DM_NAME ", qtype: " PUB_DNS_TYPE,
5059 QueryRecordClientRequestStop(request->queryrecord);
5061 if (request->powerlog_start_time != 0)
5063 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
5064 mdns_powerlog_query_record_stop(request->pid_name, request->powerlog_start_time, usesAWDL);
5065 request->powerlog_start_time = 0;
5099 mDNSlocal mStatus _handle_queryrecord_request_start(request_state *request, const uds_queryrecord_params_t *const params)
5101 request->terminate = queryrecord_termination_callback;
5102 QueryRecordClientRequest *queryrecord = request->queryrecord;
5103 const mStatus err = QueryRecordClientRequestStart(queryrecord, ¶ms->cr, queryrecord_result_reply, request);
5108 if ((request->interfaceIndex != kDNSServiceInterfaceIndexLocalOnly) && IsLocalDomain(qname))
5110 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
5111 request->powerlog_start_time = mdns_powerlog_query_record_start(request->pid_name, usesAWDL);
5120 mDNSlocal void _return_queryrecord_request_error(request_state * request, mStatus error)
5129 request->request_id, request->hdr.op == query_request ? "QueryRecord" : "GetAddrInfo", error);
5139 rep = create_reply(request->hdr.op == query_request ? query_reply_op : addrinfo_reply_op, len, request);
5154 append_reply(request, rep);
5157 mDNSlocal mStatus _handle_queryrecord_request_with_trust(request_state *request,
5161 if (!request->peer_token)
5163 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_WARNING, "[R%u] _handle_queryrecord_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
5164 err = _handle_queryrecord_request_start(request, params);
5183 const audit_token_t *const token = mdns_audit_token_get_token(request->peer_token);
5192 if (!_prepare_trusts_for_request(request))
5231 error = _handle_queryrecord_request_start(request, _params);
5232 // No context means the request was canceled before we got here
5236 _return_queryrecord_request_error(request, error);
5242 CFArrayAppendValue(request->trusts, trust);
5254 err = _handle_queryrecord_request_start(request, params);
5267 mDNSlocal void get_queryrecord_tlvs(request_state *const request, uds_queryrecord_params_t *const params)
5269 mdns_require_quiet(request->msgptr, exit);
5270 mdns_require_quiet(request->hdr.ipc_flags & IPC_FLAGS_TRAILING_TLVS, exit);
5272 const mDNSu8 *const start = (const mDNSu8 *)request->msgptr;
5273 const mDNSu8 *const end = (const mDNSu8 *)request->msgend;
5293 request->custom_service_id = params->cr.customID;
5304 mDNSlocal mStatus handle_queryrecord_request(request_state *request)
5307 if (!request->queryrecord)
5309 request->queryrecord = (QueryRecordClientRequest *)callocL("QueryRecordClientRequest", sizeof(*request->queryrecord));
5310 mdns_require_action_quiet(request->queryrecord, exit, err = mStatus_NoMemoryErr; uds_log_error(
5311 "[R%u] Failed to allocate memory for query record request", request->request_id));
5315 params.cr.flags = get_flags(&request->msgptr, request->msgend);
5316 params.cr.interfaceIndex = get_uint32(&request->msgptr, request->msgend);
5317 if (get_string(&request->msgptr, request->msgend, params.qname, sizeof(params.qname)) < 0)
5322 params.cr.qtype = get_uint16(&request->msgptr, request->msgend);
5323 params.cr.qclass = get_uint16(&request->msgptr, request->msgend);
5324 params.cr.requestID = request->request_id;
5325 params.cr.effectivePID = request->validUUID ? 0 : request->process_id;
5326 params.cr.effectiveUUID = request->validUUID ? request->uuid : mDNSNULL;
5327 params.cr.peerUID = request->uid;
5329 params.cr.peerToken = request->peer_token;
5331 if (!request->msgptr)
5334 "[R%d] DNSServiceQueryRecord(unreadable parameters)", request->request_id);
5338 request->flags = params.cr.flags;
5339 request->interfaceIndex = params.cr.interfaceIndex;
5341 get_queryrecord_tlvs(request, ¶ms);
5344 err = get_signed_browse_tlvs(request);
5345 if (err) { LogMsg("%3d: handle_queryrecord_request err reading Validation TLVS", request->sd); return(err); }
5348 get_tracker_info_tlvs(request);
5352 enablesDNSSEC = dns_service_flags_enables_dnssec(request->flags);
5366 MDNS_LOG_DEFAULT, "DNSServiceQueryRecord START", &query_name, request, mDNSfalse, enablesDNSSEC,
5370 request->terminate = NULL;
5376 if (request->signed_obj)
5378 mdns_signed_browse_result_t browseResult = mdns_signed_browse_result_downcast(request->signed_obj);
5379 if (browseResult && mdns_signed_browse_result_contains(browseResult, query_name.c, request->interfaceIndex))
5383 request->request_id);
5390 request->sign_result = mDNSfalse;
5391 mdns_forget(&request->signed_obj);
5398 err = _handle_queryrecord_request_with_trust(request, ¶ms);
5403 err = _handle_queryrecord_request_start(request, ¶ms);
5413 mDNSlocal reply_state *format_enumeration_reply(request_state *request,
5425 reply = create_reply(enumeration_reply_op, len, request);
5434 mDNSlocal void enum_termination_callback(request_state *request)
5436 request_enumeration *const enumeration = request->enumeration;
5440 LogInfo("%3d: DNSServiceEnumeration Cancel WAB Registration PID[%d](%s)", request->sd, request->process_id, request->pid_name);
5445 LogInfo("%3d: DNSServiceEnumeration Cancel WAB Browse PID[%d](%s)", request->sd, request->process_id, request->pid_name);
5457 request_state *request = question->QuestionContext;
5466 const request_enumeration *const enumeration = request->enumeration;
5479 reply = format_enumeration_reply(request, domain, flags, kDNSServiceInterfaceIndexAny, kDNSServiceErr_NoError);
5484 request->request_id, mDNSVal16(question->TargetQID), DM_LABEL_PARAM(&question->qname),
5487 append_reply(request, reply);
5490 mDNSlocal mStatus handle_enum_request(request_state *request)
5493 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
5497 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
5500 mdns_require_action_quiet(request->msgptr, exit, err = mStatus_BadParamErr; uds_log_error(
5501 "[R%u] DNSServiceEnumerateDomains(unreadable parameters)", request->request_id));
5503 if (!request->enumeration)
5505 request->enumeration = (request_enumeration *)callocL("request_enumeration", sizeof(*request->enumeration));
5506 mdns_require_action_quiet(request->enumeration, exit, err = mStatus_NoMemoryErr; uds_log_error(
5507 "[R%u] Failed to allocate memory for enumeration request", request->request_id));
5509 request->flags = flags;
5510 request->interfaceIndex = interfaceIndex;
5513 request_enumeration *const enumeration = request->enumeration;
5518 enumeration->q_all.QuestionContext = request;
5519 enumeration->q_default.QuestionContext = request;
5520 if (!reg) enumeration->q_autoall.QuestionContext = request;
5526 LogOperation("%3d: DNSServiceEnumerateDomains(%X=%s)", request->sd, flags,
5529 err = mDNS_GetDomains(&mDNSStorage, &enumeration->q_all, t_all, NULL, InterfaceID, enum_result_callback, request);
5532 err = mDNS_GetDomains(&mDNSStorage, &enumeration->q_default, t_default, NULL, InterfaceID, enum_result_callback, request);
5536 err = mDNS_GetDomains(&mDNSStorage, &enumeration->q_autoall, mDNS_DomainTypeBrowseAutomatic, NULL, InterfaceID, enum_result_callback, request);
5543 if (!err) request->terminate = enum_termination_callback;
5550 LogInfo("%3d: DNSServiceEnumerateDomains Start WAB Registration PID[%d](%s)", request->sd, request->process_id, request->pid_name);
5555 LogInfo("%3d: DNSServiceEnumerateDomains Start WAB Browse PID[%d](%s)", request->sd, request->process_id, request->pid_name);
5567 mDNSlocal mStatus handle_reconfirm_request(request_state *request)
5570 AuthRecord *rr = read_rr_from_ipc_msg(request, 0, 0);
5578 "DNSServiceReconfirmRecord START", rr->resrec.name, request, mDNSfalse,
5585 "DNSServiceReconfirmRecord FAILED", rr->resrec.name, request, mDNSfalse,
5596 mDNSlocal mStatus handle_release_request(request_state *request)
5598 (void) request;
5603 mDNSlocal mStatus handle_setdomain_request(request_state *request)
5607 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
5609 if (get_string(&request->msgptr, request->msgend, domainstr, sizeof(domainstr)) < 0 ||
5611 { LogMsg("%3d: DNSServiceSetDefaultDomainForUser(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
5613 LogOperation("%3d: DNSServiceSetDefaultDomainForUser(%##s)", request->sd, domain.c);
5624 mDNSlocal void handle_getproperty_request(request_state *request)
5628 if (get_string(&request->msgptr, request->msgend, prop, sizeof(prop)) >= 0)
5631 "[R%d] DNSServiceGetProperty(" PUB_S ")", request->request_id, prop);
5635 send_all(request->sd, (const char *)&x, sizeof(x));
5641 send_all(request->sd, (const char *)&BadParamErr, sizeof(BadParamErr));
5644 mDNSlocal void handle_connection_delegate_request(request_state *request)
5646 (void) request;
5660 mDNSlocal void port_mapping_termination_callback(request_state *request)
5662 request_port_mapping *const pm = request->pm;
5665 request->request_id, DNSServiceProtocol(pm->NATinfo.Protocol),
5667 request->process_id, request->pid_name, request_state_get_duration(request));
5672 // Called via function pointer when we get a NAT Traversal (address request or port mapping) response
5675 request_state *request = (request_state *)n->clientContext;
5680 if (!request) { LogMsg("port_mapping_create_request_callback called with unknown request_state object"); return; }
5689 rep = create_reply(port_mapping_reply_op, replyLen, request);
5697 const request_port_mapping *const pm = request->pm;
5711 request->request_id, DNSServiceProtocol(pm->NATinfo.Protocol),
5716 append_reply(request, rep);
5719 mDNSlocal mStatus handle_port_mapping_request(request_state *request)
5724 DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
5725 mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
5727 mDNSu8 protocol = (mDNSu8)get_uint32(&request->msgptr, request->msgend);
5730 if (!request->pm)
5732 request->pm = (request_port_mapping *)callocL("request_port_mapping", sizeof(*request->pm));
5733 mdns_require_action_quiet(request->pm, exit, err = mStatus_NoMemoryErr; uds_log_error(
5734 "[R%u] Failed to allocate memory for port mapping request", request->request_id));
5736 request_port_mapping *const pm = request->pm;
5737 if (request->msgptr + 8 > request->msgend) request->msgptr = NULL;
5740 pm->NATinfo.IntPort.b[0] = *request->msgptr++;
5741 pm->NATinfo.IntPort.b[1] = *request->msgptr++;
5742 pm->ReqExt.b[0] = *request->msgptr++;
5743 pm->ReqExt.b[1] = *request->msgptr++;
5744 ttl = get_uint32(&request->msgptr, request->msgend);
5747 if (!request->msgptr)
5750 "[R%d] DNSServiceNATPortMappingCreate(unreadable parameters)", request->request_id);
5754 if (protocol == 0) // If protocol == 0 (i.e. just request public address) then IntPort, ExtPort, ttl must be zero too
5764 request->flags = flags;
5765 request->interfaceIndex = interfaceIndex;
5771 pm->NATinfo.clientContext = request;
5775 request->request_id, protocol, mDNSVal16(pm->NATinfo.IntPort), mDNSVal16(pm->ReqExt),
5776 pm->NATinfo.NATLease, request->process_id, request->pid_name);
5779 else request->terminate = port_mapping_termination_callback;
5788 mDNSlocal void addrinfo_termination_callback(request_state *request)
5790 GetAddrInfoClientRequest *const addrinfo = request->addrinfo;
5793 "DNSServiceGetAddrInfo STOP", GetAddrInfoClientRequestGetQName(addrinfo), request,
5798 if (request->powerlog_start_time != 0)
5800 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
5801 mdns_powerlog_getaddrinfo_stop(request->pid_name, request->powerlog_start_time, usesAWDL);
5802 request->powerlog_start_time = 0;
5815 mDNSlocal mStatus _handle_addrinfo_request_start(request_state *request, const _addrinfo_start_params_t * const params)
5819 request->terminate = addrinfo_termination_callback;
5823 gaiParams.requestID = request->request_id;
5825 gaiParams.interfaceIndex = request->interfaceIndex;
5826 gaiParams.flags = request->flags;
5828 gaiParams.effectivePID = request->validUUID ? 0 : request->process_id;
5829 gaiParams.effectiveUUID = request->validUUID ? request->uuid : mDNSNULL;
5830 gaiParams.peerUID = request->uid;
5833 gaiParams.customID = request->custom_service_id;
5836 gaiParams.peerToken = request->peer_token;
5839 get_tracker_info_tlvs(request);
5841 err = GetAddrInfoClientRequestStart(request->addrinfo, &gaiParams, queryrecord_result_reply, request);
5845 const domainname *const qname = GetAddrInfoClientRequestGetQName(request->addrinfo);
5846 if ((request->interfaceIndex != kDNSServiceInterfaceIndexLocalOnly) && IsLocalDomain(qname))
5848 const mDNSBool usesAWDL = ClientRequestUsesAWDL(request->interfaceIndex, request->flags);
5849 request->powerlog_start_time = mdns_powerlog_getaddrinfo_start(request->pid_name, usesAWDL);
5858 mDNSlocal void _return_addrinfo_request_error(request_state * request, mStatus error)
5860 _return_queryrecord_request_error(request, error);
5863 mDNSlocal mStatus _handle_addrinfo_request_with_trust(request_state *request, const _addrinfo_start_params_t * const params)
5866 if (!request->peer_token)
5868 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_WARNING, "[R%u] _handle_addrinfo_request_with_trust: no audit token for pid(%s %d)", request->request_id, request->pid_name, request->process_id);
5869 err = _handle_addrinfo_request_start(request, params);
5873 const audit_token_t *const token = mdns_audit_token_get_token(request->peer_token);
5881 if (!_prepare_trusts_for_request(request))
5919 error = _handle_addrinfo_request_start(request, _params);
5920 // No context means the request was canceled before we got here
5924 _return_addrinfo_request_error(request, error);
5930 CFArrayAppendValue(request->trusts, trust);
5942 err = _handle_addrinfo_request_start(request, params);
5954 mDNSlocal mStatus handle_addrinfo_request(request_state *request)
5957 if (!request->addrinfo)
5959 request->addrinfo = (GetAddrInfoClientRequest *)callocL("GetAddrInfoClientRequest", sizeof(*request->addrinfo));
5960 mdns_require_action_quiet(request->addrinfo, exit, err = mStatus_NoMemoryErr; uds_log_error(
5961 "[R%u] Failed to allocate memory for addrinfo request", request->request_id));
5966 flags = get_flags(&request->msgptr, request->msgend);
5967 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
5968 params.protocols = get_uint32(&request->msgptr, request->msgend);
5969 if (get_string(&request->msgptr, request->msgend, params.hostname, sizeof(params.hostname)) < 0)
5974 if (!request->msgptr)
5976 LogMsg("%3d: DNSServiceGetAddrInfo(unreadable parameters)", request->sd);
5984 if (request->msgptr && (request->hdr.ipc_flags & IPC_FLAGS_TRAILING_TLVS))
5987 const mDNSu8 *const start = (const mDNSu8 *)request->msgptr;
5988 const mDNSu8 *const end = (const mDNSu8 *)request->msgend;
5992 request->custom_service_id = Querier_RegisterCustomDNSServiceWithPListData(data, len);
5999 err = get_signed_resolve_tlvs(request);
6000 if (err) { LogMsg("%3d: handle_addrinfo_request err reading Validation TLVS", request->sd); return(err); }
6002 request->flags = flags;
6003 request->interfaceIndex = interfaceIndex;
6007 enablesDNSSEC = dns_service_flags_enables_dnssec(request->flags);
6013 "DNSServiceGetAddrInfo START", &qname, request, mDNSfalse, enablesDNSSEC,
6016 request->terminate = NULL;
6022 if (request->signed_obj)
6024 mdns_signed_resolve_result_t resolveResult = mdns_signed_resolve_result_downcast(request->signed_obj);
6032 request->request_id);
6041 request->request_id);
6049 request->request_id, params.hostname, request->interfaceIndex);
6050 request->sign_result = mDNSfalse;
6051 mdns_forget(&request->signed_obj);
6058 err = _handle_addrinfo_request_with_trust(request, ¶ms);
6062 err = _handle_addrinfo_request_start(request, ¶ms);
6065 err = _handle_addrinfo_request_start(request, ¶ms);
6073 // MARK: - Main Request Handler etc.
6077 request_state *request;
6079 request = (request_state *) callocL("request_state", sizeof(*request));
6080 if (!request) FatalError("ERROR: calloc");
6082 *p = request;
6083 return(request);
6105 "[R%u] ERROR: read data from a completed request", req->request_id);
6145 // Largest conceivable single request is a DNSServiceRegisterRecord() or DNSServiceAddRecord()
6326 mDNSlocal void returnAsyncErrorCode(request_state *const request, const mStatus error)
6334 "[R%u] returnAsyncErrorCode: error code(%d)", request->request_id, error);
6349 rep = create_reply(async_error_op, len, request);
6363 append_reply(request, rep);
6536 // if the parent request is a delegate connection, copy the
6558 // Check if the request wants no asynchronous replies.
6571 // There's no return data for a cancel request (DNSServiceRefDeallocate returns no result)
6644 request_state *request = NewRequest();
6645 request->ts = t_morecoming;
6646 request->sd = sd;
6647 request->errsd = sd;
6648 request->request_id = GetNewRequestID();
6649 request->request_start_time_secs = 0;
6650 request->last_full_log_time_secs = 0;
6651 set_peer_pid(request);
6652 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEBUG, "%3d: connect_callback: Adding FD for uid %u", request->sd, request->uid);
6653 udsSupportAddFDToEventLoop(sd, request_callback, request, &request->platform_data);
7658 LogToFD(fd, "%3d: Orhpan operation %p; parent %p not found in request list", req->sd);
7825 LogMemCorruption("UDS request list: %p is garbage (%d)", req, req->sd);
7828 LogMemCorruption("UDS request list: req->primary should not point to self %p/%d", req, req->sd);
7831 LogMemCorruption("UDS request list: Subordinate request %p/%d/%p should not have replies (%p)",
7836 LogMemCorruption("UDS request list: req %p primary %p is misaligned (%d)", req, p, req->sd);
7838 LogMemCorruption("UDS request list: req %p primary %p is garbage (%d)", req, p, p->sd);
8010 if (!dnssd_SocketValid(r->sd)) // If this request is finished, unlink it from the list and free the memory
8012 // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
Indexes created Sun Oct 25 00:26:45 UTC 2026