Lines Matching refs:Questions
343 for (q = m->Questions; q; q=q->next)
346 LogMemCorruption("Questions list: %p is garbage (%lX %p)", q, q->ThisQInterval, q->next);
348 LogMemCorruption("Questions list: Duplicate Question %p should not have LocalSocket set %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype));
364 for (q = m->Questions; q; q=q->next) if (q == cr->CRActiveQuestion) break;
365 if (!q) LogMemCorruption("Cache slot %lu: CRActiveQuestion %p not in m->Questions list %s", slot, cr->CRActiveQuestion, CRDisplayString(m, cr));
379 // Returns true if this is a unique, authoritative LocalOnly record that answers questions of type
688 // a) SuppressUnusable questions that are suppressed
722 // themselves. Without that check we can get into a case where we have two duplicate questions,
931 m->CurrentQuestion = m->Questions;
949 // delivers the appropriate add/remove events to listening questions:
951 // stopping if it reaches a NewLocalOnlyQuestion -- brand-new questions are handled by AnswerNewLocalOnlyQuestion().
953 // our main question list, delivering answers to mDNSInterface_Any questions as appropriate,
954 // stopping if it reaches a NewQuestion -- brand-new questions are handled by AnswerNewQuestion().
985 // If this AuthRecord is marked LocalOnly or P2P, then we want to deliver it to all local 'mDNSInterface_Any' questions
1108 // In addition, when probing we send our questions with the wildcard type kDNSQType_ANY,
3692 // 1. If a cache record is currently referenced by *no* active questions,
3765 // Delay before restarting questions on a flapping interface.
3783 // so that the reconfirmation questions can be grouped into a single query packet
3841 debugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d, total questions %d",
4372 // Scan our list of questions to see which:
4378 m->CurrentQuestion = m->Questions;
4479 // Scan our list of questions
4481 // (b) to update the state variables for *all* the questions we're going to send
4482 // Note: Don't set NextScheduledQuery until here, because uDNS_CheckCurrentQuestion in the loop above can add new questions to the list,
4486 for (q = m->Questions; q && q != m->NewQuestions; q=q->next)
4567 // For all questions (not just the ones we're sending) check what the next scheduled event will be
4686 // Put query questions in this packet
4687 for (q = m->Questions; q && q != m->NewQuestions; q=q->next)
4792 // Put probe questions in this packet
4882 LogRedact(MDNS_LOG_CATEGORY_MDNS, MDNS_LOG_DEBUG, "SendQueries: %u questions will be sent in a later request on InterfaceID= %p",
4887 // Put our known answer list (either new one from this question or questions, or remainder of old one from last time)
5001 // There might be more records left in the known answer list, or more questions to send
5050 // 4c. Debugging check: Make sure we sent all our planned questions
5051 // Do this AFTER the lingering cache records check above, because that will prevent spurious warnings for questions
5053 for (q = m->Questions; q; q=q->next)
5059 // There will not be an active interface for questions applied to mDNSInterface_BLE
5329 // We do this for mDNS questions and uDNS one-shot questions, but not for
5330 // uDNS LongLived questions, because that would mess up our LLQ lease renewal timing.
5448 // For CNAME results to non-CNAME questions, only inform the client if they want all intermediates or if
5501 m->CurrentQuestion = m->Questions;
5552 // If new questions are created as a result of invoking client callbacks, they will be added to
5565 for (q = m->Questions; q && q != m->NewQuestions; q=q->next)
5615 m->CurrentQuestion = m->Questions;
5631 // If new questions are created as a result of invoking client callbacks, they will be added to
5645 m->CurrentQuestion = m->Questions;
5646 // We do this for *all* questions, not stopping when we get to m->NewQuestions,
5661 // If new questions are created as a result of invoking client callbacks, they will be added to
5673 m->CurrentQuestion = m->Questions;
5675 // We stop when we get to NewQuestions -- for new questions their CurrentAnswers/LargeAnswers/UniqueAnswers counters
5682 // before the question became suppressed. We need to skip the suppressed questions here as
5875 if (rr->CRActiveQuestion) // If this record has one or more active questions, tell them it's going away
5885 // MaxQuestionInterval. If we have inactive questions referring to negative cache entries,
5992 // We handle mDNSInterface_Any and scoped questions here. See LocalOnlyRecordAnswersQuestion for more
5993 // details on how we handle this case. For P2P we just handle "Interface_Any" questions. For LocalOnly
5994 // we handle both mDNSInterface_Any and scoped questions.
6049 // Today, we suppress questions (not send them on the wire) for several reasons e.g.,
6093 // CacheRecordRmv() both use that themselves when walking the list of (non-new) questions generating callbacks.
6316 // 2. As LocalOnly questions should also be answered by any other Auth records local to the machine,
6352 // The local host is the authoritative source for LocalOnly questions
6410 // 1. Records that answer still-active questions are not candidates for recycling.
6515 // summary deletion without giving the proper callback to any questions that are monitoring it.
6610 mDNSlocal void TimeoutQuestions_internal(mDNS *const m, DNSQuestion* questions, mDNSInterfaceID InterfaceID)
6615 m->CurrentQuestion = questions;
6649 TimeoutQuestions_internal(m, m->Questions, mDNSInterface_Any);
6846 // 4. See if we can answer any of our new local questions from the cache
6925 // to our local questions
6957 // then send our responses, probes, and questions.
6958 // We check the cache first, because there might be records close to expiring that trigger questions to refresh them.
6974 for (q = m->Questions; q && q != m->NewQuestions; q=q->next)
7003 // See if any questions (or local-only questions) have timed out
7041 for (q = m->Questions; q; q = q->next)
7124 m->RestartQuestion = m->Questions;
7129 // GetZoneData questions are referenced by other questions (original query that started the GetZoneData
7171 // Suppressed status does not affect questions that are answered using local records
7202 // Retrigger all our uDNS questions
7206 m->CurrentQuestion = m->Questions;
7221 // Retrigger all our mDNS questions
7222 for (q = m->Questions; q; q=q->next) // Scan our list of questions
8024 // But then if the interface goes away, we won't stop these questions because
8026 // to stop both the browse and resolve questions.
8394 for (q = m->Questions; q; q = q->next)
8526 // Initialize the response fields so we can answer the questions
8530 // *** 1. Write out the list of questions we are actually going to answer with this packet
8546 if (!responseptr) { debugf("GenerateUnicastResponse: Ran out of space for questions!"); return(mDNSNULL); }
8552 if (response->h.numQuestions == 0) { LogMsg("GenerateUnicastResponse: ERROR! Why no questions?"); return(mDNSNULL); }
9069 DNSQuestion *DupQuestions = mDNSNULL; // Our questions that are identical to questions in this packet
9156 // * suppress their own identical questions when they see these questions, and
9286 for (q = m->Questions; q; q=q->next)
9376 // Having built our ExpectedAnswers list from the questions in this packet, we then remove
9503 // *** 8. If we think other machines are likely to answer these questions, set our response suppression timer,
9678 for (q = m->Questions; q; q=q->next)
9705 for (q = m->Questions; q; q=q->next)
10751 // Create the SOA record as we may have to return this to the questions
11212 for (q = m->Questions; q; q=q->next)
11295 // Subsequently, if we reissue questions from within the mDNSResponder e.g., DNS server
11297 // Currently, we do this for for both multicast and unicast questions as long as the record
11302 for (q = m->Questions; q; q=q->next)
11309 break; // Why break here? Aren't there other questions we might want to look at?-- SC July 2010
11647 // 1. We ignore questions (if any) in mDNS response packets
11679 // answer questions in this packet's question section, but which aren't tagged with this packet's
11987 // Initialize the DNS server on the resource record which will now filter what questions we answer with
12763 // See if we need to generate negative cache entries for unanswered unicast questions
13736 // 4. Response packets that answer questions may cause our client to issue new questions
13749 // We keep SuppressUnusable questions separate so that we can return a quick response to them and not get blocked behind
13751 // non-SuppressUnusable questions. This should be fine as the goal of SuppressUnusable is to return quickly only if it
13761 // for multicast questions, we don't want to treat LongLived as anything special
13773 // This prevents circular references, where two questions are each marked as a duplicate of the other.
13776 for (q = m->Questions; q && (q != question); q = q->next)
13828 // This is called after a question is deleted, in case other identical questions were being suppressed as duplicates
13846 for (q = m->Questions; q; q=q->next) // Scan our list of questions
13847 if (q->DuplicateOf == question) // To see if any questions were referencing this as their duplicate
13880 // Duplicate questions aren't eligible to have Discovery Proxy subscribers, so a simple
13901 // No need to close old q->LocalSocket first -- duplicate questions can't have their own sockets
14131 // 1) Unscoped questions (NULL InterfaceID) should consider *only* unscoped DNSServers ( DNSServer
14134 // 2) Scoped questions (non-NULL InterfaceID) should consider *only* scoped DNSServers (DNSServer
14137 // 3) Scoped questions (non-zero ServiceID) should consider *only* scoped DNSServers (DNSServer
14147 // as scoped questions should not pick non-scoped DNSServer entry (Refer to (2) above).
14189 // But any questions that has mDNSInterface_Any scope that are started/restarted before we receive the update
14395 for (q = m->Questions; q; q=q->next)
14688 // SuppressUnusable does not affect questions that are answered from the local records (/etc/hosts)
14689 // and Suppressed status does not mean anything for these questions. As we are going to stop the
14708 // 2. Previously it was not suppressed and now it is suppressed. We need to restart the questions
14714 // the question is not suppressed, we don't want two active questions sending packets on the wire.
14719 // will restart at the end. The main reason for the two step process is to handle duplicate questions.
14720 // If there are duplicate questions, calling stop inherits the values from another question on the list (which
14722 // suppressed before. At the end when we have restarted all questions, none of them is active as each
14723 // inherits from one another and we need to reactivate one of the questions here which is a little hacky.
14725 // It is much cleaner and less error prone to build a list of questions and restart at the end.
14749 // We look through all questions including new questions. During network change events,
14750 // we potentially restart questions here in this function that ends up as new questions,
14753 // new questions, we would never change its Suppressed status.
14763 m->RestartQuestion = m->Questions;
14800 m->RestartQuestion = m->Questions;
14866 // Need not initialize the DNS Configuration for Local Only OR P2P Questions when timeout not specified
14879 // Note that we set the timeout for all questions. If this turns out to be a duplicate,
14916 // Don't call SetNextQueryTime() if a LocalOnly OR P2P Question since those questions
15018 // We won't need one for duplicate questions, or from questions answered immediately out of the cache.
15113 // both multicast and unicast browse questions but we should initialize
15131 for (qptr = localOnlyOrP2P ? &m->LocalOnlyQuestions : &m->Questions; (q = *qptr) != mDNSNULL; qptr = &q->next)
15135 // it doesn't precede any questions that are supposed to be answered earlier or at the same clock time as
15136 // itself, and such that it doesn't follow any questions that are supposed to be answered later than itself.
15148 // 2. For questions that are duplicates, make sure that the new question is inserted after its primary
15239 "number of enabled questions: %d.", mDNSVal16(question->TargetQID),
15258 const DNSQuestion *const qlist = localOnlyOrP2P ? m->LocalOnlyQuestions : m->Questions;
15406 DNSQuestion **qp = &m->Questions;
15461 // CRActiveQuestion replacement. If there are no such questions, but there's at least one unsuppressed inactive
15464 for (q = m->Questions; q && (q != m->NewQuestions); q = q->next)
15529 for (q = m->Questions; q; q=q->next)
15617 LogRedact(MDNS_LOG_CATEGORY_DEFAULT, MDNS_LOG_DEBUG, "[Q%u] number of sensitive logging enabled questions: "
15624 // Must drop the lock before releasing DNSSEC context because its finalizer may stop other questions, which would
15664 DNSQuestion *const *qp = LocalOnlyOrP2PInterface(question->InterfaceID) ? &m->LocalOnlyQuestions : &m->Questions;
16785 // Therefore, when registering an interface, we want to re-trigger our questions and re-probe our Resource Records,
16868 for (q = m->Questions; q; q=q->next) // Scan our list of questions
17024 LogRedact(MDNS_LOG_CATEGORY_MDNS, MDNS_LOG_DEFAULT, "Last representative of InterfaceID deregistered; marking questions etc. dormant - "
17042 // 1. Deactivate any questions specific to this interface, and tag appropriate questions
17044 for (q = m->Questions; q; q=q->next)
17046 if (mDNSOpaque16IsZero(q->TargetQID)) // Only deactivate multicast quesstions. (Unicast questions are stopped when/if the associated DNS server group goes away.)
17072 // if the interface does come back, any relevant questions will be reactivated anyway
17636 for (q = m->Questions; q; q=q->next) if (mDNSSameOpaque16(id, q->TargetQID)) return mDNStrue;
17704 // We ignore ARP Announcements here -- Announcements are not questions, they're assertions, so we don't need to answer them.
18295 m->Questions = mDNSNULL;
18476 // opportunistically along with other non-probe questions.
18568 // Make sure all the duplicate questions point to the same DNSServer so that delivery
18686 // questions here. Neither question nor cache point to mcast resolvers. Questions
18711 // from scoped resolver will be used to answer non-scoped questions and vice versa, as scoped and non-scoped
18731 // - Two questions scoped and non-scoped for the same name will pick two different DNSServer and will end up creating separate
18739 // First, restart questions whose suppression status will change. The suppression status of each question in a given
18744 for (q = m->Questions; q; q = q->next)
18788 // Now, change the server for each question set, if necessary. Note that questions whose suppression status changed
18790 for (q = m->Questions; q; q = q->next)
18813 // When we get here, any such servers should have zero questions associated with them.
18819 // not referenced by any questions. In this case, we just delete the push server rather than trying
18847 // We already walked the questions and restarted/reactivated them if the dns server
18854 // For cache entries that have active questions we might have skipped rescheduling
18855 // the questions if they were suppressed (see above). To keep it simple, we walk
Indexes created Sat May 02 00:23:24 UTC 2026