Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2020 Project CHIP Authors
       4             :  *
       5             :  *    Licensed under the Apache License, Version 2.0 (the "License");
       6             :  *    you may not use this file except in compliance with the License.
       7             :  *    You may obtain a copy of the License at
       8             :  *
       9             :  *        http://www.apache.org/licenses/LICENSE-2.0
      10             :  *
      11             :  *    Unless required by applicable law or agreed to in writing, software
      12             :  *    distributed under the License is distributed on an "AS IS" BASIS,
      13             :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14             :  *    See the License for the specific language governing permissions and
      15             :  *    limitations under the License.
      16             :  */
      17             : 
      18             : #pragma once
      19             : 
      20             : #include <lib/dnssd/minimal_mdns/responders/ReplyFilter.h>
      21             : 
      22             : #include "Parser.h"
      23             : #include "Query.h"
      24             : 
      25             : namespace mdns {
      26             : namespace Minimal {
      27             : 
      28             : /// A reply filter implementation based on a received/parsed query.
      29             : class QueryReplyFilter : public ReplyFilter
      30             : {
      31             : public:
      32         298 :     QueryReplyFilter(const QueryData & queryData) : mQueryData(queryData) {}
      33             : 
      34        1961 :     bool Accept(QType qType, QClass qClass, FullQName qname) override
      35             :     {
      36        1961 :         if (!AcceptableQueryType(qType))
      37             :         {
      38         467 :             return false;
      39             :         }
      40             : 
      41        1494 :         if (!AcceptableQueryClass(qClass))
      42             :         {
      43           0 :             return false;
      44             :         }
      45             : 
      46        1494 :         return AcceptablePath(qname);
      47             :     }
      48             : 
      49             :     /// Ignore qname matches during Accept calls (if set to true, only qtype and qclass are matched).
      50             :     ///
      51             :     /// Ignoring qname is useful when sending related data replies: cliens often query for PTR
      52             :     /// records however to avoid chattyness, servers generally send all of PTR, SRV (pointed to by PTR)
      53             :     /// and A/AAAA (pointed to by SRV).
      54         149 :     QueryReplyFilter & SetIgnoreNameMatch(bool ignore)
      55             :     {
      56         149 :         mIgnoreNameMatch = ignore;
      57         149 :         return *this;
      58             :     }
      59             : 
      60         149 :     QueryReplyFilter & SetSendingAdditionalItems(bool additional)
      61             :     {
      62         149 :         mSendingAdditionalItems = additional;
      63         149 :         return *this;
      64             :     }
      65             : 
      66             : private:
      67        1961 :     bool AcceptableQueryType(QType qType)
      68             :     {
      69        1961 :         if (mSendingAdditionalItems)
      70             :         {
      71         394 :             return true;
      72             :         }
      73             : 
      74        1567 :         return ((mQueryData.GetType() == QType::ANY) || (mQueryData.GetType() == qType));
      75             :     }
      76             : 
      77        1494 :     bool AcceptableQueryClass(QClass qClass)
      78             :     {
      79        1494 :         return ((mQueryData.GetClass() == QClass::ANY) || (mQueryData.GetClass() == qClass));
      80             :     }
      81             : 
      82        1494 :     bool AcceptablePath(FullQName qname)
      83             :     {
      84        1494 :         if (mIgnoreNameMatch || mQueryData.IsAnnounceBroadcast())
      85             :         {
      86        1096 :             return true;
      87             :         }
      88             : 
      89         398 :         return (mQueryData.GetName() == qname);
      90             :     }
      91             : 
      92             :     const QueryData & mQueryData;
      93             :     bool mIgnoreNameMatch        = false;
      94             :     bool mSendingAdditionalItems = false;
      95             : };
      96             : 
      97             : } // namespace Minimal
      98             : } // namespace mdns