src/acl/BoolOps.cc

   1 /*
   2  * Copyright (C) 1996-2020 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 #include "squid.h"
  10 #include "acl/BoolOps.h"
  11 #include "acl/Checklist.h"
  12 #include "Debug.h"
  13 #include "sbuf/SBuf.h"
  14
  15 /* Acl::NotNode */
  16
  17 Acl::NotNode::NotNode(ACL *acl)
  18 {
  19     assert(acl);
  20     Must(strlen(acl->name) <= sizeof(name)-2);
  21     name[0] = '!';
  22     name[1] = '\0';
  23     xstrncpy(&name[1], acl->name, sizeof(name)-1); // -1 for '!'
  24     add(acl);
  25 }
  26
  27 void
  28 Acl::NotNode::parse()
  29 {
  30     // Not implemented: by the time an upper level parser discovers
  31     // an '!' operator, there is nothing left for us to parse.
  32     assert(false);
  33 }
  34
  35 int
  36 Acl::NotNode::doMatch(ACLChecklist *checklist, Nodes::const_iterator start) const
  37 {
  38     assert(start == nodes.begin()); // we only have one node
  39
  40     if (checklist->matchChild(this, start, *start))
  41         return 0; // converting match into mismatch
  42
  43     if (!checklist->keepMatching())
  44         return -1; // suspend on async calls and stop on failures
  45
  46     return 1; // converting mismatch into match
  47 }
  48
  49 char const *
  50 Acl::NotNode::typeString() const
  51 {
  52     return "!";
  53 }
  54
  55 ACL *
  56 Acl::NotNode::clone() const
  57 {
  58     // Not implemented: we are not a named ACL type in squid.conf so nobody
  59     // should try to create a NotNode instance by ACL type name (which is
  60     // what clone() API is for -- it does not really clone anything).
  61     assert(false);
  62     return NULL;
  63 }
  64
  65 SBufList
  66 Acl::NotNode::dump() const
  67 {
  68     SBufList text;
  69     text.push_back(SBuf(name));
  70     return text;
  71 }
  72
  73 /* Acl::AndNode */
  74
  75 char const *
  76 Acl::AndNode::typeString() const
  77 {
  78     return "and";
  79 }
  80
  81 ACL *
  82 Acl::AndNode::clone() const
  83 {
  84     return new AndNode;
  85 }
  86
  87 int
  88 Acl::AndNode::doMatch(ACLChecklist *checklist, Nodes::const_iterator start) const
  89 {
  90     // find the first node that does not match
  91     for (Nodes::const_iterator i = start; i != nodes.end(); ++i) {
  92         if (!checklist->matchChild(this, i, *i))
  93             return checklist->keepMatching() ? 0 : -1;
  94     }
  95
  96     // one and not zero on empty because in math empty product equals identity
  97     return 1; // no mismatches found (i.e., all kids matched)
  98 }
  99
 100 void
 101 Acl::AndNode::parse()
 102 {
 103     // Not implemented: AndNode cannot be configured directly. See Acl::AllOf.
 104     assert(false);
 105 }
 106
 107 /* Acl::OrNode */
 108
 109 char const *
 110 Acl::OrNode::typeString() const
 111 {
 112     return "any-of";
 113 }
 114
 115 ACL *
 116 Acl::OrNode::clone() const
 117 {
 118     return new OrNode;
 119 }
 120
 121 bool
 122 Acl::OrNode::bannedAction(ACLChecklist *, Nodes::const_iterator) const
 123 {
 124     return false;
 125 }
 126
 127 int
 128 Acl::OrNode::doMatch(ACLChecklist *checklist, Nodes::const_iterator start) const
 129 {
 130     lastMatch_ = nodes.end();
 131
 132     // find the first node that matches, but stop if things go wrong
 133     for (Nodes::const_iterator i = start; i != nodes.end(); ++i) {
 134         if (bannedAction(checklist, i))
 135             continue;
 136         if (checklist->matchChild(this, i, *i)) {
 137             lastMatch_ = i;
 138             return 1;
 139         }
 140
 141         if (!checklist->keepMatching())
 142             return -1; // suspend on async calls and stop on failures
 143     }
 144
 145     // zero and not one on empty because in math empty sum equals zero
 146     return 0; // all nodes mismatched
 147 }
 148
 149 void
 150 Acl::OrNode::parse()
 151 {
 152     // Not implemented: OrNode cannot be configured directly. See Acl::AnyOf.
 153     assert(false);
 154 }
 155