ircproxy  The Ultimate Cyborg

---

Matcher.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Matcher.h
//! @brief This file contains the declaration 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 MATCHER_H
#define MATCHER_H

#ifndef USE_PCH
#include <string>
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <libcw/events.h>
#include <sys/types.h>
#include <regex.h>
#include "debug.h"
#endif

#include "match.h"
#include "MessageIn.h"
#include "Counter.h"

//! Match types that do not need an extra argument.
enum match0_type {
  // Ordered roughly in the order of matching speed.
  anystring_mt = 0,
  nonemptystring_mt = 1,
  anyglobalchannel_mt = 2,      // Any string starting with a '#'.
  anylocalchannel_mt = 3,       // Any string starting with a '&'.
  anychannel_mt = 4,            // Any string starting with a '#' or '&'.
  anyserver_mt = 5,             // Any string containing a dot.
  anynick_mt = 6,               // Any string that is not a channel or server.
  mynick_mt = 8,
  localserver_mt = 9
};

//! Match types that need one extra argument (the pattern to match against).
enum match1_type {
  // Ordered roughly in the order of matching speed.
  exactmatch_mt = 7,
  wildcard_mt = 10,             // ? == one character, * == any string of characters.
  regexp_mt = 11
};

#ifdef CWDEBUG
extern std::ostream& operator<<(std::ostream& os, match0_type mt);
extern std::ostream& operator<<(std::ostream& os, match1_type mt);
#endif

static int const prefix = -1;

//! Matcher base class.
class Matcher {
  private:
    int M_param;                //!< Parameter, or prefix when M_param is -1.
    bool M_single_param;        //!< True if we only match against parameter M_param. False if we match against parameters M_param and higher.

  public:
    //! Construct a Matcher that matches against parameter \a param, including all following parameters if \a single_param is true.
    Matcher(int param, bool single_param) : M_param(param), M_single_param(single_param) { }
    //! Virtual destructor.
    virtual ~Matcher() { }

    //! Create and return a shared pointer to a Matcher.
    //  (when \a single_param is false, starting at) parameter \a param, of type \a mt.
    static boost::shared_ptr<Matcher> create(int param, match0_type mt, bool single_param = true);
    //! Create and return a shared pointer to a Matcher.
    //  (when \a single_param is false, starting at) parameter \a param, of type \a mt and pattern \a arg to match against.
    static boost::shared_ptr<Matcher> create(int param, match1_type mt, std::string const& arg, bool single_param = true);

    //! Returns true if message \a msg matches this Matcher.
    bool match(ServerMessageIn const& msg);

#ifdef CWDEBUG
    virtual void print_type_on(std::ostream&) const = 0;
    //! For debugging purposes. Write the contents of this object to \a os.
    virtual void print_on(std::ostream& os) const
    {
      os << "param:";
      if (M_param == prefix)
        os << "prefix";
      else
        os << M_param;
      os << ", single_param:" << (M_single_param ? "true" : "false");
    }
#endif

  protected:
    //! Match implementation interface filled in by derived classes.
    //  Returns true if the Matcher matches the string starting at \a start with length \a len.
    virtual bool match_impl(ServerSession const& server_session, char const* start, size_t len) = 0;

  public:
    //! Returns an indication of the match algorithm speed (smaller is faster).
    virtual int sort_value(void) = 0;
};

//! A Matcher base class for matchers that do not take an extra argument.
//  These matchers match against information in the associated ServerConnection.
class Matcher_noarg : public Matcher {
  protected:
    match0_type M_mt;                           //!< The match type.

  public:
    //! Construct a Matcher_noarg object of type \a mt that will match against parameter \a param (and on, if \a single_param is false).
    Matcher_noarg(int param, match0_type mt, bool single_param) : Matcher(param, single_param), M_mt(mt) { }

#ifdef CWDEBUG
    //! For debugging purposes. Write the class name to \a os.
    virtual void print_type_on(std::ostream& os) const { os << "Matcher_noarg"; }
    //! For debugging purposes. Write the match type to \a os.
    virtual void print_on(std::ostream& os) const { os << "mt:" << M_mt; }
#endif

  protected:
    virtual bool match_impl(ServerSession const& server_session, char const* start, size_t len);

  public:
    //! Implementation of pure virtual function Matcher::sort_value().
    virtual int sort_value(void) { return M_mt; }
};

//! Wildcard (* and ?) matcher.
class Matcher_matchcomp : public Matcher {
  private:
    char* M_cmask;              //!< Compiled mask.
    int M_minlen;               //!< The minimum length of a string that can match.

  public:
    //! Construct a Matcher_matchcomp instance that matches parameter \a param (and on if \a single_param is false) against mask \a arg.
    Matcher_matchcomp(int param, std::string const& arg, bool single_param) :
        Matcher(param, single_param), M_cmask(new char[arg.size() + 1])
        { AllocTag(M_cmask, "Matcher_matchcomp::M_cmask"); matchcomp(M_cmask, &M_minlen, NULL, arg.c_str()); }
    //! Destructor.
    ~Matcher_matchcomp() { delete [] M_cmask; }

#ifdef CWDEBUG
    //! For debugging purposes. Write the class name to \a os.
    virtual void print_type_on(std::ostream& os) const { os << "Matcher_matchcomp"; }
    //! For debugging purposes. Write the compiled mask to \a os.
    virtual void print_on(std::ostream& os) const
        { os << "cmask: \"" << M_cmask << "\", minlen: " << M_minlen; }
#endif

  protected:
    //! Implementation of pure virtual function Matcher::match_impl.
    //  Returns true if the mask matches the string starting at \a start with length \a len.
    virtual bool match_impl(ServerSession const& LIBCW_UNUSED(server_session), char const* start, size_t len)
        { return len >= (size_t)M_minlen && matchexec(start, len, M_cmask, M_minlen) == 0; }

  public:
    //! Implementation of pure virtual function Matcher::sort_value().
    virtual int sort_value(void) { return wildcard_mt; }
};

//! Regular expression matcher.
class Matcher_regexp : public Matcher {
  private:
    regex_t M_regex;            //!< Compiled regular expression.

  public:
    //! Construct a Matcher_regexp instance that matches parameter \a param (and on if \a single_param is false) against pattern \a arg.
    Matcher_regexp(int param, std::string const& arg, bool single_param) :
        Matcher(param, single_param)
        {
#if defined(CWDEBUG) || defined(DEBUG)
          int regcomp_error =
#endif
              regcomp(&M_regex, arg.c_str(), REG_ICASE | REG_NOSUB);
          ASSERT(regcomp_error == 0); }
    //! Destructor.
    ~Matcher_regexp() { regfree(&M_regex); }

#ifdef CWDEBUG
    //! For debugging purposes. Write the class name to \a os.
    virtual void print_type_on(std::ostream& os) const { os << "Matcher_regexp"; }
    //! For debugging purposes. Write the compiled pattern to \a os.
    virtual void print_on(std::ostream& os) const { os << "regex: " << M_regex; }
#endif

  protected:
    virtual bool match_impl(ServerSession const& server_session, char const* start, size_t len);

  public:
    //! Implementation of pure virtual function Matcher::sort_value().
    virtual int sort_value(void) { return regexp_mt; }
};

//! Exact match matcher.
class Matcher_exactmatch : public Matcher {
  private:
    std::string M_string;       //!< The string to match.

  public:
    //! Construct a Matcher_exactmatch instance that matches parameter \a param (and on if \a single_param is false) against string \a arg.
    Matcher_exactmatch(int param, std::string const& arg, bool single_param) :
        Matcher(param, single_param), M_string(arg) { }

#ifdef CWDEBUG
    //! For debugging purposes. Write the class name to \a os.
    virtual void print_type_on(std::ostream& os) const { os << "Matcher_exactmatch"; }
    //! For debugging purposes. Write the string to match to \a os.
    virtual void print_on(std::ostream& os) const { os << "string: \"" << M_string << '"'; }
#endif

  protected:
    //! Implementation of pure virtual function Matcher::match_impl.
    //  Returns true if the string starting at \a start with length \a len is equal.
    virtual bool match_impl(ServerSession const& LIBCW_UNUSED(server_session), char const* start, size_t len)
        { return M_string.compare(0, std::string::npos, start, len) == 0; }

  public:
    //! Implementation of pure virtual function Matcher::sort_value().
    virtual int sort_value(void) { return exactmatch_mt; }
};

//! Create and return a matcher of match0_type \a mt.
inline boost::shared_ptr<Matcher> Matcher::create(int param, match0_type mt, bool single_param)
{
  return boost::shared_ptr<Matcher>(NEW(Matcher_noarg(param, mt, single_param)));
}

//! Returns true if \a matcher1 is expected to be a faster match than \a matcher2.
inline bool operator<(boost::shared_ptr<Matcher> const& matcher1, boost::shared_ptr<Matcher> const& matcher2)
{
  return matcher1->sort_value() < matcher2->sort_value();
}

//! A list of match requests.
struct MatchRequestList :public boost::noncopyable {
  int M_command;                                                //!< The command to match.
  std::multiset<boost::shared_ptr<Matcher> > M_conditions;      //!< All other conditions to match (if any).

  //! Default constructor.
  MatchRequestList(void) : M_command(-2) { }

  //! Check if message \a msg equals command M_command and all conditions M_conditions.
  bool is_match(ServerMessageIn const& msg) const
  {
    ASSERT(M_command != -2);    // Initialized?
    if (M_command != msg.key())
      return false;
    return check_list(msg);
  }

  private:
    //! Returns true if the message \a msg matches all conditions.
    bool check_list(ServerMessageIn const& msg) const;
};

//! A match request.
class MatchRequest {
  private:
    boost::shared_ptr<MatchRequestList> M_match_request_list;   //!< Shared pointer to the match request list.
    bool M_sink;
  public:
    //! Construct a MatchRequest instance.
    MatchRequest(bool sink = false) : M_match_request_list(NEW(MatchRequestList)), M_sink(sink) { }
    bool sink(void) const { return M_sink; }
    //! Request a match event for command \a command.
    MatchRequest& operator()(int command)
    {
      M_match_request_list->M_conditions.clear();
      M_match_request_list->M_command = command;
      return *this;
    }
    //! Request a match for any string at parameter \a param (and on if \a single_param is false).
    MatchRequest& anystring(int param, bool single_param = true)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, anystring_mt, single_param));
      return *this;
    }
    //! Request a match event for any non-empty string at parameter \a param (and on if \a single_param is false).
    MatchRequest& nonemptystring(int param, bool single_param = true)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, nonemptystring_mt, single_param));
      return *this;
    }
    //! Request a match if parameter \a param contains any server name.
    MatchRequest& anyserver(int param)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, anyserver_mt, true));
      return *this;
    }
    //! Request a match if parameter \a param contains our server.
    MatchRequest& localserver(int param)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, localserver_mt, true));
      return *this;
    }
    //! Request a match if parameter \a param contains any nick name.
    MatchRequest& anynick(int param)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, anynick_mt, true));
      return *this;
    }
    //! Request a match if parameter \a param contains our nick name.
    MatchRequest& mynick(int param)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, mynick_mt, true));
      return *this;
    }
    //! Request a match if parameter \a param contains any channel name.
    MatchRequest& anychannel(int param)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, anychannel_mt, true));
      return *this;
    }
    //! Request a match if parameter \a param contains any global channel name.
    MatchRequest& anyglobalchannel(int param)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, anyglobalchannel_mt, true));
      return *this;
    }
    //! Request a match if parameter \a param contains any local channel name.
    MatchRequest& anylocalchannel(int param)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, anylocalchannel_mt, true));
      return *this;
    }
    //! Request a match if parameter \a param (and on if \a single_param is false) matches mask \a arg.
    MatchRequest& wildcard(std::string const& arg, int param, bool single_param = true)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, wildcard_mt, arg, single_param));
      return *this;
    }
    //! Request a match if parameter \a param (and on if \a single_param is false) matches regular expression \a arg.
    MatchRequest& regexp(std::string const& arg, int param, bool single_param = true)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, regexp_mt, arg, single_param));
      return *this;
    }
    //! Request a match if parameter \a param (and on if \a single_param is false) matches the string \a arg exactly.
    MatchRequest& exactmatch(std::string const& arg, int param, bool single_param = true)
    {
      M_match_request_list->M_conditions.insert(Matcher::create(param, exactmatch_mt, arg, single_param));
      return *this;
    }
    //! Returns true if all match conditions are fullfilled.
    bool is_match(ServerMessageIn const& msg) const { return M_match_request_list->is_match(msg); }
#ifdef CWDEBUG
    //! For debugging purposes. Returns the internal MatchRequestList.
    MatchRequestList const& match_request_list(void) const { return *M_match_request_list; }
#endif
};

//!  @brief The type of the argument that is returned with the callback
class MatcherEventType {
  private:
    ServerMessageIn const& M_message;   //!< Reference to the incoming message that matches.

  public:
    //! Constructor.
    MatcherEventType(ServerMessageIn const& message) : M_message(message) { }

    //! Accessor.
    ServerMessageIn const& message(void) const { return M_message; }
};

//! Matcher event request base class.
class MatcherEventRequestBase : public event_request_base_tct<MatcherEventType> {
  public:
    typedef MatchRequest event_request_data_ct;         //!< The request data type.
  private:
    event_request_data_ct M_request_data;               //!< The request data.
  public:
    //! Constructor.
    MatcherEventRequestBase(event_client_tracker_ct* event_client_tracker, event_request_data_ct request_data) :
        event_request_base_tct<MatcherEventType>(event_client_tracker), M_request_data(request_data)
        { Dout(dc::objects, "Constructing MatcherEventRequestBase(" << request_data << ")"); }
#ifdef CWDEBUG
    //! Destructor.
    ~MatcherEventRequestBase() { Dout(dc::objects, "Destructing MatcherEventRequestBase " << *this); }
    //! Copy-constructor.
    MatcherEventRequestBase(MatcherEventRequestBase const& request) :
        event_request_base_tct<MatcherEventType>(request),
        M_request_data(request.M_request_data)
        { Dout(dc::objects, "Copy-constructing MatcherEventRequestBase from " << request); }
#endif
    //! Returns the request data.
    event_request_data_ct const& request_data(void) const { return M_request_data; }

    //! Write MatcherEventRequestBase \a request to \a os.
    friend std::ostream& operator<<(std::ostream& os, MatcherEventRequestBase const& request);
};

//! Matches event request queue.
class MatcherEventRequestQueue {
    typedef std::deque<MatcherEventRequestBase*> event_requests_ct;     //!< Event request queue type.
  private:
    Counter M_event_requests_locked;                                    //!< Non-zero if M_event_requests is being processed in a loop.
    event_requests_ct M_event_requests;                                 //!< The queued event requests.
    event_requests_ct M_event_requests_tmp;                             //!< Temporary event request queue for when M_event_requests is locked.
  protected:
    //! Add an event request to the queue.
    void add_request(MatcherEventRequestBase* request)
        {
          if (M_event_requests_locked)
            M_event_requests_tmp.push_back(request);
          else
            M_event_requests.push_back(request);
        }
    //! Destructor.
    ~MatcherEventRequestQueue() { destroy_requests(); }
  public:
    //! Destroy all remaining event requests in the queue.
    void destroy_requests(void);
    //! Trigger the event. Returns true if the event should not be handled any further.
    bool trigger(MatcherEventRequestBase::event_type_ct const& event_type);
};

//! The event server for MatcherEventType.
typedef event_data_server_tct<MatcherEventRequestBase, MatcherEventRequestQueue> MatcherEventServer;

#endif // MATCHER_H

---