Lines Matching defs:same
497 // the target name is still the same), and then when we stop question B, UpdateQuestionDuplicates
720 // SameResourceRecordSignature returns true if two resources records have the same name, type, and class, and may be sent
721 // (or were received) on the same interface (i.e. if *both* records specify an interface, then it has to match).
727 // SameResourceRecordNameClassInterface is functionally the same as SameResourceRecordSignature, except rrtype does not have to match
746 // complete ownership of *all* types for this name, so *any* record type with the same name is a conflict.
785 // (If two responders on the network are offering the same information,
1051 // (a) the RecordTypes are the same, or
1497 // If a bunch of hosts have all been configured with the same name, then they'll all
1498 // conflict and run through the same series of names: name-2, name-3, name-4, etc.,
1552 if (drt == mDNS_Dereg_conflict) // If this was a conflict, see that all duplicates get the same treatment
1835 rr->resrec.namehash == rr2->resrec.namehash && // ... and have the same name
2464 // the whole RRSet as an atomic unit. That means that if we have any other records with the same name/type/class
2735 // Run through remainder of list clearing SendNSECNow flag for all other records which would generate the same NSEC
2916 // For all the reconfirmations in a given batch, we want to use the same random value
3037 // we check if we have an address record for the same name. If we do have an IPv4 address for a given
3255 // because if some other host is probing at the same time, we each want to know what the other is
3285 // and bump UnansweredQueries so that we don't spin trying to send the same cache expiration query repeatedly
4431 // returns true to indicate the same.
4552 // that they're still the same. If m->NewQuestions has changed (because mDNS_StopQuery_internal
5326 // returns results for both at the same time. If we are looking for the _autotunnel6 record, then skip this logic
5624 // Note: scopeid is the same as intf->InterfaceID. It is passed in so that we don't have to call the
5781 // for "IDX". Hence, we want to use the same ID across all interfaces.
5784 // option check below will set the same ID across the records from the same owner. Records
5797 // initialize with the new ID. For subsequent interfaces, we want to use the same ID.
5798 // At the end, all the updates sent across all the interfaces with the same ID.
5815 // For now we follow that same logic for SPS registrations too.
6184 * This function attempts to detect if multiple interfaces are on the same subnet.
6190 * and conclude that multiple interfaces are on the same subnet only if these packets
6191 * are seen on other interfaces on the same system
6217 LogSPS("%s : Already registered for the same subnet (IPv4) for interface %s", __func__, intf->ifname);
6504 // ... and the same for NextSPSAttempt
6908 // PacketRRConflict is called when we've received an RR (pktrr) which has the same name
6916 // are members of the same RRSet, then this is not a conflict.
6971 // If there really is another live host out there with the same name, it will answer our probes and we'll then rename.
7225 // As we have verified this question to be part of the same subset,
7256 // If we don't have any answers for this question, but we do own another record with the same name,
7317 // Check if this question is the same as any of mine.
7325 // question belongs in the same group. As the group is expected to be
7535 // If two clients on different interfaces do queries that invoke the same optional additional answer,
7833 // Accept A and AAAA if we accepted something before in the same packet as most likely related to the
7837 LogInfo("ExpectingMulticastResponseForRecord:A:AAAA: accepting %s, from %#a due to same packet %d", CRDisplayString(m, rr), srcaddr, m->PktNum);
7856 // The record and the question belong to the same subset. Set the
8102 mDNSBool same = SameDomainName(&q->qname, rr->name);
8103 if (same && (q->qtype == rr->rrtype || rr->rrtype == kDNSType_CNAME))
8105 LogInfo("IsResponseAcceptable: Accepting, same name and qtype %s, CR %s", DNSTypeName(q->qtype),
8122 if (same && ((typeCovered == q->qtype) || (typeCovered == kDNSType_CNAME)))
8374 // TBD: Need to purge and revalidate if the cached NSECS and the new set are not same.
8404 // it will create additional cache groups for the same name. To avoid that,
8552 // <rdar://problem/4015377> mDNS -F returns the same domain multiple times with different casing
8568 // same set.
8800 // 2. If this is an LLQ response, we handle it much the same
9012 // from the DNS server that queried. We follow the same logic here. If we can find a matching quetion based
9014 // came from the same DNS server that we sent the query to.
9150 // same machine giving different answers for the reverse mapping record, or there are two machines on the
9151 // network using the same IP address.) This is simply a misconfiguration, and there's nothing we can do
9166 // have any record(s) of the same type that we should re-assert to rescue them
9307 // Look for records in the cache with the same signature as this new one with the cache flush
9308 // bit set, and either (a) if they're fresh, just make sure the whole RRSet has the same TTL
9314 // "fresh" and would be incorrectly resurrected back to the same TTL as the rest of the RRSet,
9354 // If record is recent, just ensure the whole RRSet has the same TTL (as required by DNS semantics)
9387 // bridged onto the same Ethernet. When X announces its AirPort IP address with the cache-flush bit
9501 // simple, we use the same mechanism for both lists.
9540 ScheduleWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.HMAC); // Schedule all other records with the same owner to be woken
10338 // Targets are considered the same if both queries are untargeted, or
10339 // if both are targeted to the same address+port
10351 // the queries that are not marked SuppressUnusable. But if the query is not suppressed, they are treated the same as
10374 if (q->InterfaceID == question->InterfaceID && // with the same InterfaceID,
10375 SameQTarget(q, question) && // and same unicast/multicast target settings
10543 //Returns 0 if the newname is the same as the old match
10555 // If we find a match and the number of labels is the same as bestcount, then
10663 // InterfaceID for discussion and the same holds good for ServiceID):
11625 // Ensure DNS related info of duplicate question is same as the orig question
12090 // 2. The interface ID is different, but the target host and port are the same
12091 // This implies that we're seeing the exact same SRV record on more than one interface, so we should
12694 // remedy the conflict, and a name that differs only in capitalization will just suffer the exact same conflict again.
12882 // connected machines establish link at exactly the same time, we don't want them all
12883 // to go and hit the network with identical queries at exactly the same moment.
13009 // See if another representative *of the same type* exists. If not, we mave have gone from
13497 // using the same system default name, and if we don't take this precaution then
13540 // could inadvertently advertise its service under the same name "Stuart's Printer", which might be confusing for users.
14526 // Make sure all the duplicate questions point to the same DNSServer so that delivery
14550 // mcast resolvers. Today we get both mcast and ucast configuration using the same
14626 // All non-scoped resolvers share the same resGroupID. At no point in time a cache entry using DNSServer
14628 // resolvers don't share the same resGroupID. A few examples to describe the interaction with how we pick
14634 // pointer immediately (qDNSServer and rDNSServer may be different but still share the same resGroupID). If we don't
14638 // the same resGroupID.
14644 // pick a new DNSServer for the question which may or may not be NULL and set the cache record's pointer to the same
14647 // - Two questions scoped and non-scoped for the same name will pick two different DNSServer and will end up creating separate
14766 // As the DNSServers for this cache record is not the same anymore, we don't
14792 // different DNS servers can give different answers to the same question.
14999 // handlers to just turn around and attempt to re-register those same records.