path: root/src/include/operators.h

/**
 *  @file operators.h
 *  @brief  Declaration of all operators.
 *  @author Andreas Aardal Hanssen, Erwin Hoffmann
 *  @date 2002-2005, 2023
 */

#ifndef operators_h_included
#define operators_h_included

#include "depot.h"
#include "imapparser.h"
#include "message.h"
#include "recursivedescent.h"
#include "session.h"

#include <string>
#include <vector>

namespace Binc {

  struct Operator {
    enum class ProcessResult { OK, BAD, NO, NOTHING, ABORT };

    virtual ProcessResult process(Depot &, Request &) = 0;
    virtual Parser::ParseResult parse(Request &, Parser &) = 0;
    virtual Session::State getState() const = 0;
    virtual const std::string getName() const = 0;

    virtual ~Operator() = default;
  };

  struct AppendOperator : public Operator {
    ProcessResult process(Depot &, Request &) final;
    Parser::ParseResult parse(Request &, Parser &) final;
    const std::string getName() const final;
    Session::State getState() const final;

    AppendOperator();
    ~AppendOperator();
  };

  class AuthenticateOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &) override;
    virtual Parser::ParseResult parse(Request &, Parser &) override;

    const std::string getName() const override;
    Session::State getState() const override;

    ProcessResult Login(std::string &username, std::string &password);
    ProcessResult Plain(std::string &username, std::string &password);
    ProcessResult Cram(std::string &username, std::string &password, std::string &challenge);

    AuthenticateOperator();
    ~AuthenticateOperator();
  };

  class CapabilityOperator : public Operator {
    std::vector<std::string> capabilities;

  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    void addCapability(const std::string &cap);

    CapabilityOperator();
    ~CapabilityOperator();
  };

  class CheckOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    CheckOperator();
    ~CheckOperator();
  };

  class CreateOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    CreateOperator();
    ~CreateOperator();
  };

  class CloseOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    CloseOperator();
    ~CloseOperator();
  };

  class CopyOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    CopyOperator();
    ~CopyOperator();
  };

  class DeleteOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    DeleteOperator();
    ~DeleteOperator();
  };

  class ExpungeOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    ExpungeOperator();
    ~ExpungeOperator();
  };

  class FetchOperator : public Operator {
  protected:
    Parser::ParseResult expectSectionText(BincImapParserFetchAtt &f_in, Parser &p) const;
    Parser::ParseResult expectSection(BincImapParserFetchAtt &f_in, Parser &p) const;
    Parser::ParseResult expectFetchAtt(BincImapParserFetchAtt &f_in, Parser &p) const;
    Parser::ParseResult expectOffset(BincImapParserFetchAtt &f_in, Parser &p) const;
    Parser::ParseResult expectHeaderList(BincImapParserFetchAtt &f_in, Parser &p) const;

  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    FetchOperator();
    ~FetchOperator();
  };

  class IdOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    IdOperator();
    ~IdOperator();
  };

  class IdleOperator : public Operator {
  protected:
    Parser::ParseResult expectSectionText(BincImapParserFetchAtt &f_in) const;
    Parser::ParseResult expectSection(BincImapParserFetchAtt &f_in) const;
    Parser::ParseResult expectFetchAtt(BincImapParserFetchAtt &f_in) const;
    Parser::ParseResult expectOffset(BincImapParserFetchAtt &f_in) const;
    Parser::ParseResult expectHeaderList(BincImapParserFetchAtt &f_in) const;

  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    IdleOperator();
    ~IdleOperator();
  };

  class ListOperator : public Operator {
  protected:
    enum MailboxFlags {
      DIR_SELECT = 0x01,
      DIR_MARKED = 0x02,
      DIR_NOINFERIORS = 0x04,
      DIR_LEAF = 0x08
    };

    std::map<std::string, unsigned int> cache;
    time_t cacheTimeout;

  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    ListOperator();
    ~ListOperator();
  };

  class LoginOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    LoginOperator();
    ~LoginOperator();
  };

  class LogoutOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    LogoutOperator();
    ~LogoutOperator();
  };

  class LsubOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    LsubOperator();
    ~LsubOperator();
  };

  class NamespaceOperator : public Operator {
  public:
    virtual ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    NamespaceOperator();
    ~NamespaceOperator();
  };

  class NoopOperator : public Operator {
  public:
    virtual ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    NoopOperator();
    ~NoopOperator();
  };

  class NoopPendingOperator : public NoopOperator {
  public:
    ProcessResult process(Depot &, Request &);

    NoopPendingOperator();
    ~NoopPendingOperator();
  };

  class RenameOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    RenameOperator();
    ~RenameOperator();
  };

  class SearchOperator : public Operator {
  protected:
    Parser::ParseResult expectSearchKey(BincImapParserSearchKey &s_in, Parser &p) const;

    class SearchNode {
      std::string date;
      std::string astring;
      std::string bstring;
      unsigned int number;

      int type;
      mutable int weight;
      const SequenceSet *bset;

      std::vector<SearchNode> children;

    public:
      enum {
        S_ALL,
        S_ANSWERED,
        S_BCC,
        S_BEFORE,
        S_BODY,
        S_CC,
        S_DELETED,
        S_FLAGGED,
        S_FROM,
        S_KEYWORD,
        S_NEW,
        S_OLD,
        S_ON,
        S_RECENT,
        S_SEEN,
        S_SINCE,
        S_SUBJECT,
        S_TEXT,
        S_TO,
        S_UNANSWERED,
        S_UNDELETED,
        S_UNFLAGGED,
        S_UNKEYWORD,
        S_UNSEEN,
        S_DRAFT,
        S_HEADER,
        S_LARGER,
        S_NOT,
        S_OR,
        S_SENTBEFORE,
        S_SENTON,
        S_SENTSINCE,
        S_SMALLER,
        S_UID,
        S_UNDRAFT,
        S_SET,
        S_AND
      };

      static bool convertDate(const std::string &date,
                              time_t &t,
                              const std::string &delim = "-");
      static bool convertDateHeader(const std::string &d_in, time_t &t);

      void order();

      bool match(Mailbox *,
                 Message *,
                 unsigned seqnr,
                 unsigned int lastmessage,
                 unsigned int lastuid) const;

      int getType() const;
      int getWeight() const;
      void setWeight(int i);

      void init(const BincImapParserSearchKey &a);

      static bool compareNodes(const SearchNode &a, const SearchNode &b)
      {
        return a.getWeight() < b.getWeight();
      }

      SearchNode();
      SearchNode(const BincImapParserSearchKey &a);
    };

  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    SearchOperator();
    ~SearchOperator();
  };

  class SelectOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    SelectOperator();
    ~SelectOperator();
  };

  class ExamineOperator : public SelectOperator {
  public:
    const std::string getName() const;
    ExamineOperator();
    ~ExamineOperator();
  };

  class StarttlsOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;
    ProcessResult goStartTLS() const;

    StarttlsOperator();
    ~StarttlsOperator();
  };

  class StatusOperator : public Operator {
    std::map<int, Status> statuses;

  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    StatusOperator();
    ~StatusOperator();
  };

  class StoreOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    StoreOperator();
    ~StoreOperator();
  };

  class SubscribeOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    SubscribeOperator();
    ~SubscribeOperator();
  };

  class UnsubscribeOperator : public Operator {
  public:
    ProcessResult process(Depot &, Request &);
    virtual Parser::ParseResult parse(Request &, Parser &);

    const std::string getName() const;
    Session::State getState() const;

    UnsubscribeOperator();
    ~UnsubscribeOperator();
  };
}

#endif