imapparser.h

#ifndef _IMAPPARSER_H
#define _IMAPPARSER_H
/**********************************************************************
 *
 *   imapparser.h  - IMAP4rev1 Parser
 *   Copyright (C) 2001-2002 Michael Haeckel <haeckel@kde.org>
 *   Copyright (C) 2000 Sven Carstens <s.carstens@gmx.de>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *   Send comments and bug fixes to s.carstens@gmx.de
 *
 *********************************************************************/

#include "imap4-config.h"
#include "imaplist.h"
#include "imapcommand.h"
#include "imapinfo.h"
#include "mailheader.h"

#include <kio/authinfo.h>
#include <kio/slavebase.h>

#include <QHash>
#include <QList>
#include <QStringList>
#include <QByteArray>

class KUrl;
class QString;
class mailAddress;
class mimeHeader;

class parseString
{
public:
  parseString() : pos(0) {}
  char operator[](int i) const { return data.length() > (i + pos) ? data[i + pos] : '\0'; }
  bool isEmpty() const { return pos >= data.size(); }
  QByteArray cstr() const
  {
    if ( pos >= data.size() ) {
      return QByteArray();
    }
    return QByteArray( data.data() + pos, data.size() - pos );
  }
  int find(char c, int index = 0) const
  {
    int res = data.indexOf( c, index + pos );
    return ( res == -1 ) ? res : ( res - pos );
  }
  // Warning: does not check for going past end of "data"
  void takeLeftNoResize(QByteArray& dest, uint len) const
  {
    memmove( dest.data(), data.data() + pos, len );
  }
  // Warning: does not check for going past end of "data"
  void takeMidNoResize(QByteArray& dest, uint start, uint len) const
  {
    memmove( dest.data(), data.data() + pos + start, len );
  }
  void clear()
  {
    data.resize( 0 );
    pos = 0;
  }
  uint length()
  {
    return data.size() - pos;
  }
  void fromString(const QString &s)
  {
    clear();
    data = s.toLatin1();
  }
  QByteArray data;
  int pos;
};

class imapCache
{
public:
  imapCache ()
  {
    myHeader = NULL;
    mySize = 0;
    myFlags = 0;
    myUid = 0;
  }

  ~imapCache ()
  {
    delete myHeader;
  }

  mailHeader *getHeader ()
  {
    return myHeader;
  }
  void setHeader (mailHeader * inHeader)
  {
    myHeader = inHeader;
  }

  ulong getSize ()
  {
    return mySize;
  }
  void setSize (ulong inSize)
  {
    mySize = inSize;
  }

  ulong getUid ()
  {
    return myUid;
  }
  void setUid (ulong inUid)
  {
    myUid = inUid;
  }

  ulong getFlags ()
  {
    return myFlags;
  }
  void setFlags (ulong inFlags)
  {
    myFlags = inFlags;
  }

  QByteArray getDate ()
  {
    return myDate;
  }
  void setDate (const QByteArray & _str)
  {
    myDate = _str;
  }
  void clear()
  {
    delete myHeader;
    myHeader = NULL;
    mySize = 0;
    myFlags = 0;
    myDate = QByteArray();
    myUid = 0;
  }

protected:
  mailHeader * myHeader;
  ulong mySize;
  ulong myFlags;
  ulong myUid;
  QByteArray myDate;
};


class imapParser
{

public:

  enum IMAP_STATE {
    ISTATE_NO,       
    ISTATE_CONNECT,  
    ISTATE_LOGIN,    
    ISTATE_SELECT    
  };

public:
    imapParser ();
    virtual ~ imapParser ();

  enum IMAP_STATE getState () { return currentState; }
  void setState(enum IMAP_STATE state) { currentState = state; }

  /* @brief return the currently selected mailbox */
  const QString getCurrentBox ()
  {
    return KIMAP::decodeImapFolderName( currentBox );
  }

  CommandPtr sendCommand (CommandPtr aCmd);
  CommandPtr doCommand (CommandPtr aCmd);


  bool clientLogin (const QString & aUser, const QString & aPass, QString & resultInfo);
  bool clientAuthenticate (KIO::SlaveBase *slave, KIO::AuthInfo &ai, const QString & aFQDN,
    const QString & aAuth, bool isSSL, QString & resultInfo);

  int parseLoop ();

  void parseUntagged (parseString & result);

  void parseRecent (ulong value, parseString & result);
  void parseResult (QByteArray & result, parseString & rest,
                    const QString & command = QString());
  void parseCapability (parseString & result);
  void parseFlags (parseString & result);
  void parseList (parseString & result);
  void parseLsub (parseString & result);
  void parseListRights (parseString & result);
  void parseMyRights (parseString & result);
  void parseSearch (parseString & result);
  void parseStatus (parseString & result);
  void parseExists (ulong value, parseString & result);
  void parseExpunge (ulong value, parseString & result);
  void parseAcl (parseString & result);
  void parseAnnotation (parseString & result);
  void parseNamespace (parseString & result);
  void parseQuotaRoot (parseString & result);
  void parseQuota (parseString & result);
  void parseCustom (parseString & result);
  void parseOtherUser (parseString & result);
  void parseDelegate (parseString & result);
  void parseOutOfOffice (parseString & result);

  void parseFetch (ulong value, parseString & inWords);

  mailHeader *parseEnvelope (parseString & inWords);
  void parseAddressList (parseString & inWords, QList<mailAddress *>& list);
  const mailAddress& parseAddress (parseString & inWords, mailAddress& buffer);

  void parseBody (parseString & inWords);

  mimeHeader *parseBodyStructure (parseString & inWords,
    QString & section, mimeHeader * inHeader = 0);

  mimeHeader *parseSimplePart (parseString & inWords, QString & section,
      mimeHeader * localPart = 0);

  QHash< QByteArray, QString > parseParameters (parseString & inWords);

  QHash< QByteArray, QString > parseDisposition (parseString & inWords);

  // reimplement these

  virtual void parseRelay (const QByteArray & buffer);

  virtual void parseRelay (ulong);

  virtual bool parseRead (QByteArray & buffer, long len, long relay = 0);

  virtual bool parseReadLine (QByteArray & buffer, long relay = 0);

  virtual void parseWriteLine (const QString &);

  // generic parser routines

  void parseSentence (parseString & inWords);

  QByteArray parseLiteral(parseString & inWords, bool relay = false,
                          bool stopAtBracket = false);

  // static parser routines, can be used elsewhere

  static QByteArray parseOneWord (parseString & inWords,
    bool stopAtBracket = false);

  static bool parseOneNumber (parseString & inWords, ulong & num);

  static void parseURL (const KUrl & _url, QString & _box, QString & _section,
                        QString & _type, QString & _uid, QString & _validity,
                        QString & _info);


  imapCache *getLastHandled ()
  {
    return lastHandled;
  }

  const QStringList & getResults ()
  {
    return lastResults;
  }

  const imapInfo & getStatus ()
  {
    return lastStatus;
  }
  const imapInfo & getSelected ()
  {
    return selectInfo;
  }

  const QByteArray & getContinuation ()
  {
    return continuation;
  }

  bool hasCapability (const QString &);

  void removeCapability (const QString & cap);

  static inline void skipWS (parseString & inWords)
  {
    char c;
    while ( !inWords.isEmpty() &&
            ( ( c = inWords[0] ) == ' ' || c == '\t' || c == '\r' || c == '\n' ) ) {
      inWords.pos++;
    }
  }

  QString namespaceForBox( const QString & box );


protected:

  enum IMAP_STATE currentState;

  QString currentBox;

  imapInfo selectInfo;

  imapInfo lastStatus;

  QStringList imapCapabilities;

  QList < imapList > listResponses;

  QList <CommandPtr> sentQueue;
  QList <CommandPtr> completeQueue;

  QStringList unhandled;

  QByteArray continuation;

  QString seenUid;
  imapCache *lastHandled;

  ulong commandCounter;

  QStringList lastResults;

  QMap<QString, QString> namespaceToDelimiter;

  QStringList imapNamespaces;

private:

  imapParser & operator = (const imapParser &); // hide the copy ctor

};
#endif