kde-playground/kdepimlibs/kimap/imapstreamparser.cpp

/*
    Copyright (c) 2006 - 2007 Volker Krause <vkrause@kde.org>
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

    Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
    Author: Kevin Ottens <kevin@kdab.com>

    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.

    This library 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 Library General Public
    License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "imapstreamparser.h"

#include <ctype.h>
#include <QIODevice>

using namespace KIMAP;

ImapStreamParser::ImapStreamParser( QIODevice *socket, bool serverModeEnabled )
{
  m_socket = socket;
  m_isServerModeEnabled = serverModeEnabled;
  m_position = 0;
  m_literalSize = 0;
}

ImapStreamParser::~ImapStreamParser()
{
}

QString ImapStreamParser::readUtf8String()
{
  QByteArray tmp;
  tmp = readString();
  QString result = QString::fromUtf8( tmp );
  return result;
}

QByteArray ImapStreamParser::readString()
{
  QByteArray result;
  if ( !waitForMoreData( m_data.length() == 0 ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  stripLeadingSpaces();
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }

  // literal string
  // TODO: error handling
  if ( hasLiteral() ) {
    while ( !atLiteralEnd() ) {
      result += readLiteralPart();
    }
    return result;
  }

  // quoted string
  return parseQuotedString();
}

bool ImapStreamParser::hasString()
{
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  int savedPos = m_position;
  stripLeadingSpaces();
  int pos = m_position;
  m_position = savedPos;
  if ( m_data.at( pos ) == '{' ) {
    return true; //literal string
  }
  if ( m_data.at( pos ) == '"' ) {
    return true; //quoted string
  }
  if ( m_data.at( pos ) != ' ' &&
       m_data.at( pos ) != '(' &&
       m_data.at( pos ) != ')' &&
       m_data.at( pos ) != '[' &&
       m_data.at( pos ) != ']' &&
       m_data.at( pos ) != '\n' &&
       m_data.at( pos ) != '\r' ) {
    return true;  //unquoted string
  }

  return false; //something else, not a string
}

bool ImapStreamParser::hasLiteral()
{
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  int savedPos = m_position;
  stripLeadingSpaces();
  if ( m_data.at( m_position ) == '{' ) {
    int end = -1;
    do {
      end = m_data.indexOf( '}', m_position );
      if ( !waitForMoreData( end == -1 ) ) {
        throw ImapParserException( "Unable to read more data" );
      }
    } while ( end == -1 );
    Q_ASSERT( end > m_position );
    m_literalSize = m_data.mid( m_position + 1, end - m_position - 1 ).toInt();
    // strip CRLF
    m_position = end + 1;
    // ensure that the CRLF is available
    if ( !waitForMoreData( m_position + 1 >= m_data.length() ) ) {
      throw ImapParserException( "Unable to read more data" );
    }
    if ( m_position < m_data.length() && m_data.at( m_position ) == '\r' ) {
      ++m_position;
    }
    if ( m_position < m_data.length() && m_data.at( m_position ) == '\n' ) {
      ++m_position;
    }

    //FIXME: Makes sense only on the server side?
    if ( m_isServerModeEnabled && m_literalSize > 0 ) {
      sendContinuationResponse( m_literalSize );
    }
    return true;
  } else {
    m_position = savedPos;
    return false;
  }
}

bool ImapStreamParser::atLiteralEnd() const
{
  return ( m_literalSize == 0 );
}

QByteArray ImapStreamParser::readLiteralPart()
{
  static qint64 maxLiteralPartSize = 4096;
  int size = qMin(maxLiteralPartSize, m_literalSize);

  if ( !waitForMoreData( m_data.length() < m_position + size ) ) {
    throw ImapParserException( "Unable to read more data" );
  }

  if ( m_data.length() < m_position + size ) { // Still not enough data
    // Take what's already there
    size = m_data.length() - m_position;
  }

  QByteArray result = m_data.mid( m_position, size );
  m_position += size;
  m_literalSize -= size;
  Q_ASSERT( m_literalSize >= 0 );
  trimBuffer();

  return result;
}

bool ImapStreamParser::hasList()
{
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  int savedPos = m_position;
  stripLeadingSpaces();
  int pos = m_position;
  m_position = savedPos;
  if ( m_data.at( pos ) == '(' ) {
    return true;
  }
  return false;
}

bool ImapStreamParser::atListEnd()
{
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  int savedPos = m_position;
  stripLeadingSpaces();
  int pos = m_position;
  m_position = savedPos;
  if ( m_data.at( pos ) == ')' ) {
    m_position = pos + 1;
    return true;
  }
  return false;
}

QList<QByteArray> ImapStreamParser::readParenthesizedList()
{
  QList<QByteArray> result;
  if ( !waitForMoreData( m_data.length() <= m_position ) ) {
    throw ImapParserException( "Unable to read more data" );
  }

  stripLeadingSpaces();
  if ( m_data.at( m_position ) != '(' ) {
    return result; //no list found
  }

  bool concatToLast = false;
  int count = 0;
  int sublistbegin = m_position;
  int i = m_position + 1;
  Q_FOREVER {
    if ( !waitForMoreData( m_data.length() <= i ) ) {
      m_position = i;
      throw ImapParserException( "Unable to read more data" );
    }
    if ( m_data.at( i ) == '(' ) {
      ++count;
      if ( count == 1 ) {
        sublistbegin = i;
      }
      ++i;
      continue;
    }
    if ( m_data.at( i ) == ')' ) {
      if ( count <= 0 ) {
        m_position = i + 1;
        return result;
      }
      if ( count == 1 ) {
        result.append( m_data.mid( sublistbegin, i - sublistbegin + 1 ) );
      }
      --count;
      ++i;
      continue;
    }
    if ( m_data.at( i ) == ' ' ) {
      ++i;
      continue;
    }
    if ( m_data.at( i ) == '"' ) {
      if ( count > 0 ) {
        m_position = i;
        parseQuotedString();
        i = m_position;
        continue;
      }
    }
    if ( m_data.at( i ) == '[' ) {
      concatToLast = true;
      if ( result.isEmpty() ) {
        result.append( QByteArray() );
      }
      result.last() += '[';
      ++i;
      continue;
    }
    if ( m_data.at( i ) == ']' ) {
      concatToLast = false;
      result.last() += ']';
      ++i;
      continue;
    }
    if ( count == 0 ) {
      m_position = i;
      QByteArray ba;
      if ( hasLiteral() ) {
        while ( !atLiteralEnd() ) {
          ba += readLiteralPart();
        }
      } else {
        ba = readString();
      }

      // We might sometime get some unwanted CRLF, but we're still not at the end
      // of the list, would make further string reads fail so eat the CRLFs.
      while ( ( m_position < m_data.size() ) &&
              ( m_data.at( m_position ) == '\r' || m_data.at( m_position ) == '\n' ) ) {
        m_position++;
      }

      i = m_position - 1;
      if ( concatToLast ) {
        result.last() += ba;
      } else {
        result.append( ba );
      }
    }
    ++i;
  }

  throw ImapParserException( "Something went very very wrong!" );
}

bool ImapStreamParser::hasResponseCode()
{
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  int savedPos = m_position;
  stripLeadingSpaces();
  int pos = m_position;
  m_position = savedPos;
  if ( m_data.at( pos ) == '[' ) {
    m_position = pos + 1;
    return true;
  }
  return false;
}

bool ImapStreamParser::atResponseCodeEnd()
{
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  int savedPos = m_position;
  stripLeadingSpaces();
  int pos = m_position;
  m_position = savedPos;
  if ( m_data.at( pos ) == ']' ) {
    m_position = pos + 1;
    return true;
  }
  return false;
}

QByteArray ImapStreamParser::parseQuotedString()
{
  QByteArray result;
  if ( !waitForMoreData( m_data.length() == 0 ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  stripLeadingSpaces();
  int end = m_position;
  result.clear();
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }

  bool foundSlash = false;
  // quoted string
  if ( m_data.at( m_position ) == '"' ) {
    ++m_position;
    int i = m_position;
    Q_FOREVER {
      if ( !waitForMoreData( m_data.length() <= i ) ) {
        m_position = i;
        throw ImapParserException( "Unable to read more data" );
      }
      if ( m_data.at( i ) == '\\' ) {
        i += 2;
        foundSlash = true;
        continue;
      }
      if ( m_data.at( i ) == '"' ) {
        result = m_data.mid( m_position, i - m_position );
        end = i + 1; // skip the '"'
        break;
      }
      ++i;
    }
  }

  // unquoted string
  else {
    bool reachedInputEnd = true;
    int i = m_position;
    Q_FOREVER {
      if ( !waitForMoreData( m_data.length() <= i ) ) {
        m_position = i;
        throw ImapParserException( "Unable to read more data" );
      }
      if ( m_data.at( i ) == ' ' ||
           m_data.at( i ) == '(' ||
           m_data.at( i ) == ')' ||
           m_data.at( i ) == '[' ||
           m_data.at( i ) == ']' ||
           m_data.at( i ) == '\n' ||
           m_data.at( i ) == '\r' ||
           m_data.at( i ) == '"' ) {
        end = i;
        reachedInputEnd = false;
        break;
      }
      if ( m_data.at( i ) == '\\' ) {
        foundSlash = true;
      }
      i++;
    }
    if ( reachedInputEnd ) { //FIXME: how can it get here?
      end = m_data.length();
    }

    result = m_data.mid( m_position, end - m_position );
  }

  // strip quotes
  if ( foundSlash ) {
    while ( result.contains( "\\\"" ) ) {
      result.replace( "\\\"", "\"" );
    }
    while ( result.contains( "\\\\" ) ) {
      result.replace( "\\\\", "\\" );
    }
  }
  m_position = end;
  return result;
}

qint64 ImapStreamParser::readNumber( bool * ok )
{
  qint64  result;
  if ( ok ) {
    *ok = false;
  }
  if ( !waitForMoreData( m_data.length() == 0 ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  stripLeadingSpaces();
  if ( !waitForMoreData( m_position >= m_data.length() ) ) {
    throw ImapParserException( "Unable to read more data" );
  }
  if ( m_position >= m_data.length() ) {
    throw ImapParserException( "Unable to read more data" );
  }
  int i = m_position;
  Q_FOREVER {
    if ( !waitForMoreData( m_data.length() <= i ) ) {
      m_position = i;
      throw ImapParserException( "Unable to read more data" );
    }
    if ( !isdigit( m_data.at( i ) ) ) {
      break;
    }
    ++i;
  }
  const QByteArray tmp = m_data.mid( m_position, i - m_position );
  result = tmp.toLongLong( ok );
  m_position = i;
  return result;
}

void ImapStreamParser::stripLeadingSpaces()
{
  for ( int i = m_position; i < m_data.length(); ++i ) {
    if ( m_data.at( i ) != ' ' ) {
      m_position = i;
      return;
    }
  }
  m_position = m_data.length();
}

bool ImapStreamParser::waitForMoreData( bool wait )
{
   if ( wait ) {
     if ( m_socket->bytesAvailable() > 0 ||
          m_socket->waitForReadyRead( 30000 ) ) {
        m_data.append( m_socket->readAll() );
     } else {
       return false;
     }
   }
   return true;
}

void ImapStreamParser::setData( const QByteArray &data )
{
  m_data = data;
}

QByteArray ImapStreamParser::readRemainingData()
{
  return m_data.mid( m_position );
}

int ImapStreamParser::availableDataSize() const
{
  return m_socket->bytesAvailable() + m_data.size() - m_position;
}

bool ImapStreamParser::atCommandEnd()
{
  int savedPos = m_position;
  do {
    if ( !waitForMoreData( m_position >= m_data.length() ) ) {
      throw ImapParserException( "Unable to read more data" );
    }
    stripLeadingSpaces();
  } while ( m_position >= m_data.size() );

  if ( m_data.at( m_position ) == '\n' || m_data.at( m_position ) == '\r' ) {
    if ( m_data.at( m_position ) == '\r' ) {
      ++m_position;
    }
    if ( m_position < m_data.length() && m_data.at( m_position ) == '\n' ) {
      ++m_position;
    }

    // We'd better empty m_data from time to time before it grows out of control
    trimBuffer();

    return true; //command end
  }
  m_position = savedPos;
  return false; //something else
}

QByteArray ImapStreamParser::readUntilCommandEnd()
{
  QByteArray result;
  int i = m_position;
  int paranthesisBalance = 0;
  Q_FOREVER {
    if ( !waitForMoreData( m_data.length() <= i ) ) {
      m_position = i;
      throw ImapParserException( "Unable to read more data" );
    }
    if ( m_data.at( i ) == '{' ) {
      m_position = i - 1;
      hasLiteral(); //init literal size
      result.append( m_data.mid( i - 1, m_position - i + 1 ) );
      while ( !atLiteralEnd() ) {
        result.append( readLiteralPart() );
      }
      i = m_position;
    }
    if ( m_data.at( i ) == '(' ) {
      paranthesisBalance++;
    }
    if ( m_data.at( i ) == ')' ) {
      paranthesisBalance--;
    }
    if ( ( i == m_data.length() && paranthesisBalance == 0 ) ||
         m_data.at( i ) == '\n'  || m_data.at( i ) == '\r') {
      break; //command end
    }
    result.append( m_data.at( i ) );
    ++i;
  }
  m_position = i;
  atCommandEnd();
  return result;
}

void ImapStreamParser::sendContinuationResponse( qint64 size )
{
  QByteArray block = "+ Ready for literal data (expecting " +
                     QByteArray::number( size ) + " bytes)\r\n";
  m_socket->write( block );
  m_socket->waitForBytesWritten( 30000 );
}

void ImapStreamParser::trimBuffer()
{
  if ( m_position < 4096 ) { // right() is expensive, so don't do it for every line
    return;
  }
  m_data = m_data.right( m_data.size() - m_position );
  m_position = 0;
}