imapparser.h

#ifndef _IMAPPARSER_H
#define _IMAPPARSER_H
/**********************************************************************
 *
 *   imapparser.h  - IMAP4rev1 Parser
 *   Copyright (C) 2001-2002 Michael Haeckel <haeckel@kde.org>
 *   Copyright (C) 2000 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 <tqstringlist.h>
#include <tqvaluelist.h>
#include <tqptrlist.h>
#include <tqasciidict.h>
 
#include <tdeio/authinfo.h>
#include <tdeio/slavebase.h>
 
#include "imaplist.h"
#include "imapcommand.h"
#include "imapinfo.h"
 
#include "mailheader.h"
 
class KURL;
class TQString;
class mailAddress;
class mimeHeader;
 
 
class parseString
{
public:
  parseString() { pos = 0; }
  char operator[](uint i) const { return data[i + pos]; }
  bool isEmpty() const { return pos >= data.size(); }
  TQCString cstr() const
  {
    if (pos >= data.size()) return TQCString();
    return TQCString(data.data() + pos, data.size() - pos + 1);
  }
  int find(char c, int index = 0)
  {
    int res = data.find(c, index + pos);
    return (res == -1) ? res : (res - pos);
  }
  // Warning: does not check for going past end of "data"
  void takeLeft(TQCString& dest, uint len) const
  {
    dest.resize(len + 1);
    tqmemmove(dest.data(), data.data() + pos, len);
  }
  // Warning: does not check for going past end of "data"
  void takeLeftNoResize(TQCString& dest, uint len) const
  {
    tqmemmove(dest.data(), data.data() + pos, len);
  }
  // Warning: does not check for going past end of "data"
  void takeMid(TQCString& dest, uint start, uint len) const
  {
    dest.resize(len + 1);
    tqmemmove(dest.data(), data.data() + pos + start, len);
  }
  // Warning: does not check for going past end of "data"
  void takeMidNoResize(TQCString& dest, uint start, uint len) const
  {
    tqmemmove(dest.data(), data.data() + pos + start, len);
  }
  void clear()
  {
    data.resize(0);
    pos = 0;
  }
  uint length()
  {
    if( pos < data.size() ) {
      return data.size() - pos;
    } else {
      return 0;
    }
  }
  void fromString(const TQString &s)
  {
    clear();
    data.duplicate(s.latin1(), s.length());
  }
  TQByteArray data;
  uint pos;
};
 
class imapCache
{
public:
  imapCache ()
  {
    myHeader = NULL;
    mySize = 0;
    myFlags = 0;
    myUid = 0;
  }
 
  ~imapCache ()
  {
    if (myHeader) 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;
  }
 
  TQCString getDate ()
  {
    return myDate;
  }
  void setDate (const TQCString & _str)
  {
    myDate = _str;
  }
  void clear()
  {
    if (myHeader) delete myHeader;
    myHeader = NULL;
    mySize = 0;
    myFlags = 0;
    myDate = TQCString();
    myUid = 0;
  }
 
protected:
  mailHeader * myHeader;
  ulong mySize;
  ulong myFlags;
  ulong myUid;
  TQCString 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 TQString getCurrentBox ()
  {
    return rfcDecoder::fromIMAP(currentBox);
  };
 
  imapCommand *sendCommand (imapCommand * aCmd);
  imapCommand *doCommand (imapCommand * aCmd);
 
 
  bool clientLogin (const TQString & aUser, const TQString & aPass, TQString & resultInfo);
  bool clientAuthenticate (TDEIO::SlaveBase *slave, TDEIO::AuthInfo &ai, const TQString & aFTQDN,
    const TQString & aAuth, bool isSSL, TQString & resultInfo);
 
  int parseLoop ();
 
  void parseUntagged (parseString & result);
 
  void parseRecent (ulong value, parseString & result);
  void parseResult (TQByteArray & result, parseString & rest,
                    const TQString & command = TQString());
  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 parsetStatus (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, TQPtrList<mailAddress>& list);
  const mailAddress& parseAddress (parseString & inWords, mailAddress& buffer);
 
  void parseBody (parseString & inWords);
 
  mimeHeader *parseBodyStructure (parseString & inWords,
    TQString & section, mimeHeader * inHeader = 0);
 
  mimeHeader *parseSimplePart (parseString & inWords, TQString & section,
      mimeHeader * localPart = 0);
 
  TQAsciiDict < TQString > parseParameters (parseString & inWords);
 
  TQAsciiDict < TQString > parseDisposition (parseString & inWords);
 
  // reimplement these
 
  virtual void parseRelay (const TQByteArray & buffer);
 
  virtual void parseRelay (ulong);
 
  virtual bool parseRead (TQByteArray & buffer, ulong len, ulong relay = 0);
 
  virtual bool parseReadLine (TQByteArray & buffer, ulong relay = 0);
 
  virtual void parseWriteLine (const TQString &);
 
  // generic parser routines
 
  void parseSentence (parseString & inWords);
 
  TQCString parseLiteralC(parseString & inWords, bool relay = false,
                           bool stopAtBracket = false, int *outlen = 0);
  inline TQByteArray parseLiteral (parseString & inWords, bool relay = false,
                           bool stopAtBracket = false) {
    int len = 0; // string size
    // Choice: we can create an extra TQCString, or we can get the buffer in
    // the wrong size to start.  Let's try option b.
    TQCString tmp = parseLiteralC(inWords, relay, stopAtBracket, &len);
    return TQByteArray().duplicate(tmp.data(), len);
  }
 
  // static parser routines, can be used elsewhere
 
  static TQCString b2c(const TQByteArray &ba)
  { return TQCString(ba.data(), ba.size() + 1); }
 
  static TQCString parseOneWordC (parseString & inWords,
    bool stopAtBracket = FALSE, int *len = 0);
 
  static bool parseOneNumber (parseString & inWords, ulong & num);
 
  static void parseURL (const KURL & _url, TQString & _box, TQString & _section,
                        TQString & _type, TQString & _uid, TQString & _validity,
                        TQString & _info);
 
 
  imapCache *getLastHandled ()
  {
    return lastHandled;
  };
 
  const TQStringList & getResults ()
  {
    return lastResults;
  };
 
  const imapInfo & geStatus ()
  {
    return lasStatus;
  };
  const imapInfo & getSelected ()
  {
    return selectInfo;
  };
 
  const TQByteArray & getContinuation ()
  {
    return continuation;
  };
 
  bool hasCapability (const TQString &);
 
  void removeCapability (const TQString & cap);
 
  static inline void skipWS (parseString & inWords)
  {
    char c;
    while (!inWords.isEmpty() &&
      ((c = inWords[0]) == ' ' || c == '\t' || c == '\r' || c == '\n'))
    {
      inWords.pos++;
    }
  }
 
  TQString namespaceForBox( const TQString & box );
 
 
protected:
 
  enum IMAP_STATE currentState;
 
  TQString currentBox;
 
  imapInfo selectInfo;
 
  imapInfo lasStatus;
 
  TQStringList imapCapabilities;
 
  TQValueList < imapList > listResponses;
 
  TQPtrList < imapCommand > sentQueue;  // no autodelete
  TQPtrList < imapCommand > completeQueue;  // autodelete !!
 
  TQStringList unhandled;
 
  TQByteArray continuation;
 
  TQString seenUid;
  imapCache *lastHandled;
 
  ulong commandCounter;
 
  TQStringList lastResults;
 
  TQMap<TQString, TQString> namespaceToDelimiter;
 
  TQStringList imapNamespaces;
 
private:
 
  imapParser & operator = (const imapParser &); // hide the copy ctor
 
};
#endif