ircproxy  The Ultimate Cyborg

---

Matcher.cc

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Matcher.cc
//! @brief This file contains the implementation of the Matcher classes.
//
// Copyright (C) 2006, 2007 by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.

#ifndef USE_PCH
#include "sys.h"
#include "debug.h"
#endif

#include "Matcher.h"
#include "is_channel.h"
#include "Identity.h"
#include "match.h"
#include "MessageIn.h"

bool Matcher_noarg::match_impl(ServerSession const& server_session, char const* start, size_t len)
{
  switch(M_mt)
  {
    case anystring_mt:
      return true;
    case nonemptystring_mt:
      return len > 0;
    case anyserver_mt:
    {
      for (char const* p = start; p < start + len; ++p)
        if (*p == '.')
          return true;
      return false;
    }
    case localserver_mt:
    {
      Dout(dc::matcher|continued_cf, "localserver_mt: get_irc_name() = \"" <<
          server_session.server_connection().server()->get_irc_name() << "\"; input = \"" << buf2str(start, len) << "\", ");
      bool result = server_session.server_connection().server()->get_irc_name().compare(0, std::string::npos, start, len) == 0;
      Dout(dc::finish, "returning " << (result ? "true" : "false"));
      return result;
    }
    case anynick_mt:
      return len > 0 && !is_channel(start);
    case mynick_mt:
    {
      Dout(dc::matcher|continued_cf, "mynick_mt: server_in_nick() = \"" <<
          server_session.nicks().in_nick() << "\"; input = \"" << buf2str(start, len) << "\", ");
      bool result = server_session.nicks().in_nick().compare(0, std::string::npos, start, len) == 0;
      Dout(dc::finish, "returning " << (result ? "true" : "false"));
      return result;
    }
    case anychannel_mt:
      return len > 0 && is_channel(start);
    case anyglobalchannel_mt:
      return len > 0 && *start == '#';
    case anylocalchannel_mt:
      return len > 0 && *start == '&';
  }
  // Never reached.
  return false;
}

boost::shared_ptr<Matcher> Matcher::create(int param, match1_type mt, std::string const& arg, bool single_param)
{
  boost::shared_ptr<Matcher> matcher;
  switch(mt)
  {
    case wildcard_mt:
      matcher.reset(NEW(Matcher_matchcomp(param, arg, single_param)));
      break;
    case regexp_mt:
      matcher.reset(NEW(Matcher_regexp(param, arg, single_param)));
      break;
    case exactmatch_mt:
      matcher.reset(NEW(Matcher_exactmatch(param, arg, single_param)));
      break;
  }
  return matcher;
}

bool Matcher_regexp::match_impl(ServerSession const& LIBCW_UNUSED(server_session), char const* start, size_t len)
{
  char c = start[len];
  const_cast<char*>(start)[len] = '\0';
  bool success = regexec(&M_regex, start, 0, NULL, 0) == 0;
  const_cast<char*>(start)[len] = c;
  return success;
}

bool Matcher::match(ServerMessageIn const& msg)
{
  MessageIn::Part const& part((M_param == prefix) ? msg.prefix_part() : msg.params()[M_param]);
  char const* start = part.start();
  size_t len = M_single_param ? part.len() : (msg.end() - start);
  Dout(dc::matcher|continued_cf, "Matching \"" << buf2str(start, len) << "\" against {" << cwprint(*this) << "} : ");
  bool result = match_impl(msg.server_session(), start, len);
  Dout(dc::finish, (result ? "(matched)" : "(did not match)"));
  return result;
}

void MatcherEventRequestQueue::destroy_requests(void)
{
  ASSERT(!M_event_requests_locked);
  while (!M_event_requests.empty())
  {
    M_event_requests.front()->release();
    M_event_requests.pop_front();
  }
}

bool MatcherEventRequestQueue::trigger(MatcherEventRequestBase::event_type_ct const& event_type)
{
#if 0   // Too verbose.
  DoutEntering(dc::matcher, "MatcherEventRequestQueue::trigger(" <<
      libcwd::type_info_of<MatcherEventRequestBase::event_type_ct>().demangled_name() <<
      " const& " << event_type << ")");
#endif
  bool sink = false;
  {
    ASSERT(M_event_requests_locked > 0 || M_event_requests_tmp.empty());
    Increment tmp(M_event_requests_locked);
    event_requests_ct::iterator iter = M_event_requests.begin();
    while (iter != M_event_requests.end())
    {
      if ((*iter)->canceled())
      {
        Dout(dc::matcher, "Removing canceled " << **iter);
        (*iter)->release();
        iter = M_event_requests.erase(iter);
      }
      else if ((*iter)->request_data().is_match(event_type.message()))
      {
        Dout(dc::matcher, "Calling handle() for " << **iter);
        (*iter)->handle(event_type);
        sink = (*iter)->request_data().sink();
        (*iter)->release();
        iter = M_event_requests.erase(iter);
      }
      else
        ++iter;
    }
  }
  if (M_event_requests_locked == 0)
    while (!M_event_requests_tmp.empty())
    {
      add_request(M_event_requests_tmp.front());
      M_event_requests_tmp.pop_front();
    }
  return sink;
}

bool MatchRequestList::check_list(ServerMessageIn const& msg) const
{
  for (std::multiset<boost::shared_ptr<Matcher> >::const_iterator iter = M_conditions.begin();
      iter != M_conditions.end(); ++iter)
  {
    if (!(*iter)->match(msg))
      return false;
  }
  return true;
}

---