path: root/comm/mailnews/imap/src/nsImapServerResponseParser.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "msgCore.h"  // for pre-compiled headers
#include "nsMimeTypes.h"
#include "nsImapCore.h"
#include "nsImapProtocol.h"
#include "nsImapServerResponseParser.h"
#include "nsIImapFlagAndUidState.h"
#include "nsImapNamespace.h"
#include "nsImapUtils.h"
#include "nsCRT.h"
#include "nsMsgUtils.h"
#include "mozilla/Logging.h"

////////////////// nsImapServerResponseParser /////////////////////////

extern mozilla::LazyLogModule IMAP;  // defined in nsImapProtocol.cpp

nsImapServerResponseParser::nsImapServerResponseParser(
    nsImapProtocol& imapProtocolConnection)
    : nsImapGenericParser(),
      fReportingErrors(true),
      fCurrentFolderReadOnly(false),
      fCurrentLineContainedFlagInfo(false),
      fServerIsNetscape3xServer(false),
      fSeqNumOfFirstUnseenMsg(0),
      fNumberOfExistingMessages(0),
      fNumberOfRecentMessages(0),
      fSizeOfMostRecentMessage(0),
      fTotalDownloadSize(0),
      fCurrentCommandTag(nullptr),
      fSelectedMailboxName(nullptr),
      fIMAPstate(kNonAuthenticated),
      fLastChunk(false),
      fNextChunkStartsWithNewline(false),
      fServerConnection(imapProtocolConnection),
      fHostSessionList(nullptr) {
  fSearchResults = nsImapSearchResultSequence::CreateSearchResultSequence();
  fFolderAdminUrl = nullptr;
  fNetscapeServerVersionString = nullptr;
  fXSenderInfo = nullptr;
  fSupportsUserDefinedFlags = 0;
  fSettablePermanentFlags = 0;
  fCapabilityFlag = kCapabilityUndefined;
  fLastAlert = nullptr;
  fDownloadingHeaders = false;
  fGotPermanentFlags = false;
  fFolderUIDValidity = 0;
  fHighestModSeq = 0;
  fAuthChallenge = nullptr;
  fStatusUnseenMessages = 0;
  fStatusRecentMessages = 0;
  fStatusNextUID = nsMsgKey_None;
  fNextUID = nsMsgKey_None;
  fStatusExistingMessages = 0;
  fReceivedHeaderOrSizeForUID = nsMsgKey_None;
  fUtf8AcceptEnabled = false;
  fStdJunkNotJunkUseOk = false;
}

nsImapServerResponseParser::~nsImapServerResponseParser() {
  PR_Free(fCurrentCommandTag);
  delete fSearchResults;
  PR_Free(fFolderAdminUrl);
  PR_Free(fNetscapeServerVersionString);
  PR_Free(fXSenderInfo);
  PR_Free(fLastAlert);
  PR_Free(fSelectedMailboxName);
  PR_Free(fAuthChallenge);
}

bool nsImapServerResponseParser::LastCommandSuccessful() {
  return (!CommandFailed() && !fServerConnection.DeathSignalReceived() &&
          nsImapGenericParser::LastCommandSuccessful());
}

// returns true if things look ok to continue
bool nsImapServerResponseParser::GetNextLineForParser(char** nextLine) {
  bool rv = true;
  *nextLine = fServerConnection.CreateNewLineFromSocket();
  if (fServerConnection.DeathSignalReceived() ||
      NS_FAILED(fServerConnection.GetConnectionStatus()))
    rv = false;
  // we'd really like to try to silently reconnect, but we shouldn't put this
  // message up just in the interrupt case
  if (NS_FAILED(fServerConnection.GetConnectionStatus()) &&
      !fServerConnection.DeathSignalReceived())
    fServerConnection.AlertUserEventUsingName("imapServerDisconnected");
  return rv;
}

bool nsImapServerResponseParser::CommandFailed() {
  return fCurrentCommandFailed;
}

void nsImapServerResponseParser::SetCommandFailed(bool failed) {
  fCurrentCommandFailed = failed;
}

bool nsImapServerResponseParser::UntaggedResponse() {
  return fUntaggedResponse;
}

void nsImapServerResponseParser::SetFlagState(nsIImapFlagAndUidState* state) {
  fFlagState = state;
}

uint32_t nsImapServerResponseParser::SizeOfMostRecentMessage() {
  return fSizeOfMostRecentMessage;
}

// Call this when adding a pipelined command to the session
void nsImapServerResponseParser::IncrementNumberOfTaggedResponsesExpected(
    const char* newExpectedTag) {
  fNumberOfTaggedResponsesExpected++;
  PR_Free(fCurrentCommandTag);
  fCurrentCommandTag = PL_strdup(newExpectedTag);
  if (!fCurrentCommandTag) HandleMemoryFailure();
}

void nsImapServerResponseParser::InitializeState() {
  fCurrentCommandFailed = false;
  fNumberOfRecentMessages = 0;
  fReceivedHeaderOrSizeForUID = nsMsgKey_None;
  fUntaggedResponse = false;
}

// RFC3501:  response = *(continue-req / response-data) response-done
//           response-data = "*" SP (resp-cond-state / resp-cond-bye /
//                           mailbox-data / message-data / capability-data) CRLF
//           continue-req    = "+" SP (resp-text / base64) CRLF
void nsImapServerResponseParser::ParseIMAPServerResponse(
    const char* aCurrentCommand, bool aIgnoreBadAndNOResponses,
    char* aGreetingWithCapability) {
  NS_ASSERTION(aCurrentCommand && *aCurrentCommand != '\r' &&
                   *aCurrentCommand != '\n' && *aCurrentCommand != ' ',
               "Invalid command string");
  bool sendingIdleDone = !strcmp(aCurrentCommand, "DONE" CRLF);
  if (sendingIdleDone) fWaitingForMoreClientInput = false;

  // Reinitialize the parser
  SetConnected(true);
  SetSyntaxError(false);

  // Reinitialize our state
  InitializeState();

  // the default is to not pipeline
  fNumberOfTaggedResponsesExpected = 1;
  int numberOfTaggedResponsesReceived = 0;

  nsCString copyCurrentCommand(aCurrentCommand);
  if (!fServerConnection.DeathSignalReceived()) {
    char* placeInTokenString = nullptr;
    char* tagToken = nullptr;
    const char* commandToken = nullptr;
    bool inIdle = false;
    if (!sendingIdleDone) {
      placeInTokenString = copyCurrentCommand.BeginWriting();
      tagToken = NS_strtok(WHITESPACE, &placeInTokenString);
      commandToken = NS_strtok(WHITESPACE, &placeInTokenString);
    } else
      commandToken = "DONE";
    if (tagToken) {
      PR_Free(fCurrentCommandTag);
      fCurrentCommandTag = PL_strdup(tagToken);
      if (!fCurrentCommandTag) HandleMemoryFailure();
      inIdle = commandToken && !strcmp(commandToken, "IDLE");
    }

    if (commandToken && ContinueParse())
      PreProcessCommandToken(commandToken, aCurrentCommand);

    if (ContinueParse()) {
      ResetLexAnalyzer();

      if (aGreetingWithCapability) {
        PR_FREEIF(fCurrentLine);
        fCurrentLine = aGreetingWithCapability;
      }

      // When inIdle, only one pass through "do" and "while" below occurs.
      do {
        AdvanceToNextToken();

        // untagged responses [RFC3501, Sec. 2.2.2]
        while (ContinueParse() && fNextToken && *fNextToken == '*') {
          response_data();
          if (ContinueParse()) {
            if (!fAtEndOfLine)
              SetSyntaxError(true);
            else if (!inIdle && !fCurrentCommandFailed &&
                     !aGreetingWithCapability)
              AdvanceToNextToken();
          }
          // For checking expected response to IDLE command below and
          // for checking if an untagged response occurred by the caller.
          fUntaggedResponse = true;
        }

        // command continuation request [RFC3501, Sec. 7.5]
        if (ContinueParse() && fNextToken &&
            *fNextToken == '+')  // never pipeline APPEND or AUTHENTICATE
        {
          NS_ASSERTION(
              (fNumberOfTaggedResponsesExpected -
               numberOfTaggedResponsesReceived) == 1,
              " didn't get the number of tagged responses we expected");
          numberOfTaggedResponsesReceived = fNumberOfTaggedResponsesExpected;
          if (commandToken && !PL_strcasecmp(commandToken, "authenticate") &&
              placeInTokenString &&
              (!PL_strncasecmp(placeInTokenString, "CRAM-MD5",
                               strlen("CRAM-MD5")) ||
               !PL_strncasecmp(placeInTokenString, "NTLM", strlen("NTLM")) ||
               !PL_strncasecmp(placeInTokenString, "GSSAPI",
                               strlen("GSSAPI")) ||
               !PL_strncasecmp(placeInTokenString, "MSN", strlen("MSN")))) {
            // we need to store the challenge from the server if we are using
            // CRAM-MD5 or NTLM.
            authChallengeResponse_data();
          }
        } else
          numberOfTaggedResponsesReceived++;

        if (numberOfTaggedResponsesReceived < fNumberOfTaggedResponsesExpected)
          response_tagged();

      } while (
          ContinueParse() && !inIdle &&
          (numberOfTaggedResponsesReceived < fNumberOfTaggedResponsesExpected));

      // check and see if the server is waiting for more input
      // it's possible that we ate this + while parsing certain responses (like
      // cram data), in these cases, the parsing routine for that specific
      // command will manually set fWaitingForMoreClientInput so we don't lose
      // that information....
      if ((fNextToken && *fNextToken == '+') || inIdle) {
        if (inIdle &&
            !((fNextToken && *fNextToken == '+') || fUntaggedResponse)) {
          // IDLE "response" + will not be "eaten" as described above since it
          // is not an authentication response. So if IDLE response does not
          // begin with '+' (continuation) or '*' (untagged and probably useful
          // response) then something is wrong and it is probably a tagged
          // NO or BAD due to transient error or bad configuration of the
          // server.
          if (!PL_strcmp(fCurrentCommandTag, fNextToken)) {
            response_tagged();
          } else {
            // Expected tag doesn't match the received tag. Not good, start
            // over.
            response_fatal();
          }
          // Show an alert notification containing the server response to bad
          // IDLE.
          fServerConnection.AlertUserEventFromServer(fCurrentLine, true);
        } else {
          fWaitingForMoreClientInput = true;
        }
      }
      // if we aren't still waiting for more input....
      else if (!fWaitingForMoreClientInput && !aGreetingWithCapability) {
        if (ContinueParse()) response_done();

        if (ContinueParse() && !CommandFailed()) {
          // a successful command may change the eIMAPstate
          ProcessOkCommand(commandToken);
        } else if (CommandFailed()) {
          // a failed command may change the eIMAPstate
          ProcessBadCommand(commandToken);
          if (fReportingErrors && !aIgnoreBadAndNOResponses)
            fServerConnection.AlertUserEventFromServer(fCurrentLine, false);
        }
      }
    }
  } else
    SetConnected(false);
}

void nsImapServerResponseParser::HandleMemoryFailure() {
  fServerConnection.AlertUserEventUsingName("imapOutOfMemory");
  nsImapGenericParser::HandleMemoryFailure();
}

// SEARCH is the only command that requires pre-processing for now.
// others will be added here.
void nsImapServerResponseParser::PreProcessCommandToken(
    const char* commandToken, const char* currentCommand) {
  fCurrentCommandIsSingleMessageFetch = false;
  fWaitingForMoreClientInput = false;

  if (!PL_strcasecmp(commandToken, "SEARCH"))
    fSearchResults->ResetSequence();
  else if (!PL_strcasecmp(commandToken, "SELECT") && currentCommand) {
    // the mailbox name must be quoted, so strip the quotes
    const char* openQuote = PL_strchr(currentCommand, '"');
    NS_ASSERTION(openQuote, "expected open quote in imap server response");
    if (!openQuote) {  // ill formed select command
      openQuote = PL_strchr(currentCommand, ' ');
    }
    PR_Free(fSelectedMailboxName);
    fSelectedMailboxName = PL_strdup(openQuote + 1);
    if (fSelectedMailboxName) {
      // strip the escape chars and the ending quote
      char* currentChar = fSelectedMailboxName;
      while (*currentChar) {
        if (*currentChar == '\\') {
          PL_strcpy(currentChar, currentChar + 1);
          currentChar++;  // skip what we are escaping
        } else if (*currentChar == '\"')
          *currentChar = 0;  // end quote
        else
          currentChar++;
      }
    } else
      HandleMemoryFailure();

    // we don't want bogus info for this new box
    // delete fFlagState;  // not our object
    // fFlagState = nullptr;
  } else if (!PL_strcasecmp(commandToken, "CLOSE")) {
    return;  // just for debugging
    // we don't want bogus info outside the selected state
    // delete fFlagState;  // not our object
    // fFlagState = nullptr;
  } else if (!PL_strcasecmp(commandToken, "UID")) {
    nsCString copyCurrentCommand(currentCommand);
    if (!fServerConnection.DeathSignalReceived()) {
      char* placeInTokenString = copyCurrentCommand.BeginWriting();
      (void)NS_strtok(WHITESPACE, &placeInTokenString);  // skip tag token
      (void)NS_strtok(WHITESPACE, &placeInTokenString);  // skip uid token
      char* fetchToken = NS_strtok(WHITESPACE, &placeInTokenString);
      if (!PL_strcasecmp(fetchToken, "FETCH")) {
        char* uidStringToken = NS_strtok(WHITESPACE, &placeInTokenString);
        // , and : are uid delimiters
        if (!PL_strchr(uidStringToken, ',') && !PL_strchr(uidStringToken, ':'))
          fCurrentCommandIsSingleMessageFetch = true;
      }
    }
  }
}

const char* nsImapServerResponseParser::GetSelectedMailboxName() {
  return fSelectedMailboxName;
}

nsImapSearchResultIterator*
nsImapServerResponseParser::CreateSearchResultIterator() {
  return new nsImapSearchResultIterator(*fSearchResults);
}

nsImapServerResponseParser::eIMAPstate
nsImapServerResponseParser::GetIMAPstate() {
  return fIMAPstate;
}

void nsImapServerResponseParser::PreauthSetAuthenticatedState() {
  fIMAPstate = kAuthenticated;
}

void nsImapServerResponseParser::ProcessOkCommand(const char* commandToken) {
  if (!PL_strcasecmp(commandToken, "LOGIN") ||
      !PL_strcasecmp(commandToken, "AUTHENTICATE"))
    fIMAPstate = kAuthenticated;
  else if (!PL_strcasecmp(commandToken, "LOGOUT"))
    fIMAPstate = kNonAuthenticated;
  else if (!PL_strcasecmp(commandToken, "SELECT") ||
           !PL_strcasecmp(commandToken, "EXAMINE"))
    fIMAPstate = kFolderSelected;
  else if (!PL_strcasecmp(commandToken, "CLOSE")) {
    fIMAPstate = kAuthenticated;
    // we no longer have a selected mailbox.
    PR_FREEIF(fSelectedMailboxName);
  } else if ((!PL_strcasecmp(commandToken, "LIST")) ||
             (!PL_strcasecmp(commandToken, "LSUB")) ||
             (!PL_strcasecmp(commandToken, "XLIST"))) {
    // fServerConnection.MailboxDiscoveryFinished();
    // This used to be reporting that we were finished
    // discovering folders for each time we issued a
    // LIST or LSUB.  So if we explicitly listed the
    // INBOX, or Trash, or namespaces, we would get multiple
    // "done" states, even though we hadn't finished.
    // Move this to be called from the connection object
    // itself.
  } else if (!PL_strcasecmp(commandToken, "FETCH")) {
    if (!fZeroLengthMessageUidString.IsEmpty()) {
      // "Deleting zero length message");
      fServerConnection.Store(fZeroLengthMessageUidString, "+Flags (\\Deleted)",
                              true);
      if (LastCommandSuccessful()) fServerConnection.Expunge();

      fZeroLengthMessageUidString.Truncate();
    }
  } else if (!PL_strcasecmp(commandToken, "GETQUOTAROOT")) {
    if (LastCommandSuccessful()) {
      nsCString str;
      fServerConnection.UpdateFolderQuotaData(kValidateQuota, str, 0, 0);
    }
  }
}

void nsImapServerResponseParser::ProcessBadCommand(const char* commandToken) {
  if (!PL_strcasecmp(commandToken, "LOGIN") ||
      !PL_strcasecmp(commandToken, "AUTHENTICATE"))
    fIMAPstate = kNonAuthenticated;
  else if (!PL_strcasecmp(commandToken, "LOGOUT"))
    fIMAPstate = kNonAuthenticated;  // ??
  else if (!PL_strcasecmp(commandToken, "SELECT") ||
           !PL_strcasecmp(commandToken, "EXAMINE"))
    fIMAPstate = kAuthenticated;  // nothing selected
  else if (!PL_strcasecmp(commandToken, "CLOSE"))
    fIMAPstate = kAuthenticated;  // nothing selected
}

// RFC3501:  response-data = "*" SP (resp-cond-state / resp-cond-bye /
//                           mailbox-data / message-data / capability-data) CRLF
// These are ``untagged'' responses [RFC3501, Sec. 2.2.2]
/*
 The RFC1730 grammar spec did not allow one symbol look ahead to determine
 between mailbox_data / message_data so I combined the numeric possibilities
 of mailbox_data and all of message_data into numeric_mailbox_data.

 It is assumed that the initial "*" is already consumed before calling this
 method. The production implemented here is
         response_data   ::= (resp_cond_state / resp_cond_bye /
                              mailbox_data / numeric_mailbox_data /
                              capability_data)
                              CRLF
*/
void nsImapServerResponseParser::response_data() {
  AdvanceToNextToken();

  if (ContinueParse()) {
    // Instead of comparing lots of strings and make function calls, try to
    // pre-flight the possibilities based on the first letter of the token.
    switch (NS_ToUpper(fNextToken[0])) {
      case 'O':  // OK
        if (NS_ToUpper(fNextToken[1]) == 'K')
          resp_cond_state(false);
        else
          SetSyntaxError(true);
        break;
      case 'N':  // NO
        if (NS_ToUpper(fNextToken[1]) == 'O')
          resp_cond_state(false);
        else if (!PL_strcasecmp(fNextToken, "NAMESPACE"))
          namespace_data();
        else
          SetSyntaxError(true);
        break;
      case 'B':  // BAD
        if (!PL_strcasecmp(fNextToken, "BAD"))
          resp_cond_state(false);
        else if (!PL_strcasecmp(fNextToken, "BYE"))
          resp_cond_bye();
        else
          SetSyntaxError(true);
        break;
      case 'F':
        if (!PL_strcasecmp(fNextToken, "FLAGS"))
          mailbox_data();
        else
          SetSyntaxError(true);
        break;
      case 'P':
        if (PL_strcasecmp(fNextToken, "PERMANENTFLAGS"))
          mailbox_data();
        else
          SetSyntaxError(true);
        break;
      case 'L':
        if (!PL_strcasecmp(fNextToken, "LIST") ||
            !PL_strcasecmp(fNextToken, "LSUB"))
          mailbox_data();
        else if (!PL_strcasecmp(fNextToken, "LANGUAGE"))
          language_data();
        else
          SetSyntaxError(true);
        break;
      case 'M':
        if (!PL_strcasecmp(fNextToken, "MAILBOX"))
          mailbox_data();
        else if (!PL_strcasecmp(fNextToken, "MYRIGHTS"))
          myrights_data(false);
        else
          SetSyntaxError(true);
        break;
      case 'S':
        if (!PL_strcasecmp(fNextToken, "SEARCH"))
          mailbox_data();
        else if (!PL_strcasecmp(fNextToken, "STATUS")) {
          AdvanceToNextToken();
          if (fNextToken) {
            char* mailboxName = CreateAstring();
            PL_strfree(mailboxName);
          }
          while (ContinueParse() && !fAtEndOfLine) {
            AdvanceToNextToken();
            if (!fNextToken) break;

            if (*fNextToken == '(') fNextToken++;
            if (!PL_strcasecmp(fNextToken, "UIDNEXT")) {
              AdvanceToNextToken();
              if (fNextToken) {
                fStatusNextUID = strtoul(fNextToken, nullptr, 10);
                // if this token ends in ')', then it is the last token
                // else we advance
                if (*(fNextToken + strlen(fNextToken) - 1) == ')')
                  fNextToken += strlen(fNextToken) - 1;
              }
            } else if (!PL_strcasecmp(fNextToken, "MESSAGES")) {
              AdvanceToNextToken();
              if (fNextToken) {
                fStatusExistingMessages = strtoul(fNextToken, nullptr, 10);
                // if this token ends in ')', then it is the last token
                // else we advance
                if (*(fNextToken + strlen(fNextToken) - 1) == ')')
                  fNextToken += strlen(fNextToken) - 1;
              }
            } else if (!PL_strcasecmp(fNextToken, "UNSEEN")) {
              AdvanceToNextToken();
              if (fNextToken) {
                fStatusUnseenMessages = strtoul(fNextToken, nullptr, 10);
                // if this token ends in ')', then it is the last token
                // else we advance
                if (*(fNextToken + strlen(fNextToken) - 1) == ')')
                  fNextToken += strlen(fNextToken) - 1;
              }
            } else if (!PL_strcasecmp(fNextToken, "RECENT")) {
              AdvanceToNextToken();
              if (fNextToken) {
                fStatusRecentMessages = strtoul(fNextToken, nullptr, 10);
                // if this token ends in ')', then it is the last token
                // else we advance
                if (*(fNextToken + strlen(fNextToken) - 1) == ')')
                  fNextToken += strlen(fNextToken) - 1;
              }
            } else if (*fNextToken == ')')
              break;
            else if (!fAtEndOfLine)
              SetSyntaxError(true);
          }
        } else
          SetSyntaxError(true);
        break;
      case 'C':
        if (!PL_strcasecmp(fNextToken, "CAPABILITY"))
          capability_data();
        else
          SetSyntaxError(true);
        break;
      case 'V':
        if (!PL_strcasecmp(fNextToken, "VERSION")) {
          // figure out the version of the Netscape server here
          PR_FREEIF(fNetscapeServerVersionString);
          AdvanceToNextToken();
          if (!fNextToken)
            SetSyntaxError(true);
          else {
            fNetscapeServerVersionString = CreateAstring();
            AdvanceToNextToken();
            if (fNetscapeServerVersionString) {
              fServerIsNetscape3xServer =
                  (*fNetscapeServerVersionString == '3');
            }
          }
          skip_to_CRLF();
        } else
          SetSyntaxError(true);
        break;
      case 'A':
        if (!PL_strcasecmp(fNextToken, "ACL")) {
          acl_data();
        } else if (!PL_strcasecmp(fNextToken, "ACCOUNT-URL")) {
          fMailAccountUrl.Truncate();
          AdvanceToNextToken();
          if (!fNextToken)
            SetSyntaxError(true);
          else {
            fMailAccountUrl.Adopt(CreateAstring());
            AdvanceToNextToken();
          }
        } else
          SetSyntaxError(true);
        break;
      case 'E':
        if (!PL_strcasecmp(fNextToken, "ENABLED")) enable_data();
        break;
      case 'X':
        if (!PL_strcasecmp(fNextToken, "XSERVERINFO"))
          xserverinfo_data();
        else if (!PL_strcasecmp(fNextToken, "XMAILBOXINFO"))
          xmailboxinfo_data();
        else if (!PL_strcasecmp(fNextToken, "XAOL-OPTION"))
          skip_to_CRLF();
        else if (!PL_strcasecmp(fNextToken, "XLIST"))
          mailbox_data();
        else {
          // check if custom command
          nsAutoCString customCommand;
          fServerConnection.GetCurrentUrl()->GetCommand(customCommand);
          if (customCommand.Equals(fNextToken)) {
            nsAutoCString customCommandResponse;
            while (Connected() && !fAtEndOfLine) {
              AdvanceToNextToken();
              customCommandResponse.Append(fNextToken);
              customCommandResponse.Append(' ');
            }
            fServerConnection.GetCurrentUrl()->SetCustomCommandResult(
                customCommandResponse);
          } else
            SetSyntaxError(true);
        }
        break;
      case 'Q':
        if (!PL_strcasecmp(fNextToken, "QUOTAROOT") ||
            !PL_strcasecmp(fNextToken, "QUOTA"))
          quota_data();
        else
          SetSyntaxError(true);
        break;
      case 'I':
        id_data();
        break;
      default:
        if (IsNumericString(fNextToken))
          numeric_mailbox_data();
        else
          SetSyntaxError(true);
        break;
    }

    if (ContinueParse()) PostProcessEndOfLine();
  }
}

void nsImapServerResponseParser::PostProcessEndOfLine() {
  // for now we only have to do one thing here
  // a fetch response to a 'uid store' command might return the flags
  // before it returns the uid of the message.  So we need both before
  // we report the new flag info to the front end

  // also check and be sure that there was a UID in the current response
  if (fCurrentLineContainedFlagInfo && CurrentResponseUID()) {
    fCurrentLineContainedFlagInfo = false;
    nsCString customFlags;
    fFlagState->GetCustomFlags(CurrentResponseUID(),
                               getter_Copies(customFlags));
    fServerConnection.NotifyMessageFlags(fSavedFlagInfo, customFlags,
                                         CurrentResponseUID(), fHighestModSeq);
  }
}

/*
 mailbox_data    ::=  "FLAGS" SPACE flag_list /
                               "LIST" SPACE mailbox_list /
                               "LSUB" SPACE mailbox_list /
                               "XLIST" SPACE mailbox_list /
                               "MAILBOX" SPACE text /
                               "SEARCH" [SPACE 1#nz_number] /
                               number SPACE "EXISTS" / number SPACE "RECENT"

This production was changed to accommodate predictive parsing

 mailbox_data    ::=  "FLAGS" SPACE flag_list /
                               "LIST" SPACE mailbox_list /
                               "LSUB" SPACE mailbox_list /
                               "XLIST" SPACE mailbox_list /
                               "MAILBOX" SPACE text /
                               "SEARCH" [SPACE 1#nz_number]
*/
void nsImapServerResponseParser::mailbox_data() {
  if (!PL_strcasecmp(fNextToken, "FLAGS")) {
    // this handles the case where we got the permanent flags response
    // before the flags response, in which case, we want to ignore these flags.
    if (fGotPermanentFlags)
      skip_to_CRLF();
    else
      parse_folder_flags(true);
  } else if (!PL_strcasecmp(fNextToken, "LIST") ||
             !PL_strcasecmp(fNextToken, "XLIST")) {
    AdvanceToNextToken();
    if (ContinueParse()) mailbox_list(false);
  } else if (!PL_strcasecmp(fNextToken, "LSUB")) {
    AdvanceToNextToken();
    if (ContinueParse()) mailbox_list(true);
  } else if (!PL_strcasecmp(fNextToken, "MAILBOX"))
    skip_to_CRLF();
  else if (!PL_strcasecmp(fNextToken, "SEARCH")) {
    fSearchResults->AddSearchResultLine(fCurrentLine);
    fServerConnection.NotifySearchHit(fCurrentLine);
    skip_to_CRLF();
  }
}

/*
 mailbox_list    ::= "(" #("\Marked" / "\Noinferiors" /
                              "\Noselect" / "\Unmarked" / flag_extension) ")"
                              SPACE (<"> QUOTED_CHAR <"> / nil) SPACE mailbox
*/

void nsImapServerResponseParser::mailbox_list(bool discoveredFromLsub) {
  RefPtr<nsImapMailboxSpec> boxSpec = new nsImapMailboxSpec;
  boxSpec->mFolderSelected = false;
  boxSpec->mBoxFlags = kNoFlags;
  boxSpec->mAllocatedPathName.Truncate();
  boxSpec->mHostName.Truncate();
  boxSpec->mConnection = &fServerConnection;
  boxSpec->mFlagState = nullptr;
  boxSpec->mDiscoveredFromLsub = discoveredFromLsub;
  boxSpec->mOnlineVerified = true;
  boxSpec->mBoxFlags &= ~kNameSpace;

  bool endOfFlags = false;
  fNextToken++;  // eat the first "("
  do {
    if (!PL_strncasecmp(fNextToken, "\\Marked", 7))
      boxSpec->mBoxFlags |= kMarked;
    else if (!PL_strncasecmp(fNextToken, "\\Unmarked", 9))
      boxSpec->mBoxFlags |= kUnmarked;
    else if (!PL_strncasecmp(fNextToken, "\\Noinferiors", 12)) {
      boxSpec->mBoxFlags |= kNoinferiors;
      // RFC 5258 \Noinferiors implies \HasNoChildren
      if (fCapabilityFlag & kHasListExtendedCapability)
        boxSpec->mBoxFlags |= kHasNoChildren;
    } else if (!PL_strncasecmp(fNextToken, "\\Noselect", 9))
      boxSpec->mBoxFlags |= kNoselect;
    else if (!PL_strncasecmp(fNextToken, "\\Drafts", 7))
      boxSpec->mBoxFlags |= kImapDrafts;
    else if (!PL_strncasecmp(fNextToken, "\\Trash", 6))
      boxSpec->mBoxFlags |= kImapXListTrash;
    else if (!PL_strncasecmp(fNextToken, "\\Sent", 5))
      boxSpec->mBoxFlags |= kImapSent;
    else if (!PL_strncasecmp(fNextToken, "\\Spam", 5) ||
             !PL_strncasecmp(fNextToken, "\\Junk", 5))
      boxSpec->mBoxFlags |= kImapSpam;
    else if (!PL_strncasecmp(fNextToken, "\\Archive", 8))
      boxSpec->mBoxFlags |= kImapArchive;
    else if (!PL_strncasecmp(fNextToken, "\\All", 4) ||
             !PL_strncasecmp(fNextToken, "\\AllMail", 8))
      boxSpec->mBoxFlags |= kImapAllMail;
    else if (!PL_strncasecmp(fNextToken, "\\Inbox", 6))
      boxSpec->mBoxFlags |= kImapInbox;
    else if (!PL_strncasecmp(fNextToken, "\\NonExistent", 11)) {
      boxSpec->mBoxFlags |= kNonExistent;
      // RFC 5258 \NonExistent implies \Noselect
      boxSpec->mBoxFlags |= kNoselect;
    } else if (!PL_strncasecmp(fNextToken, "\\Subscribed", 10))
      boxSpec->mBoxFlags |= kSubscribed;
    else if (!PL_strncasecmp(fNextToken, "\\Remote", 6))
      boxSpec->mBoxFlags |= kRemote;
    else if (!PL_strncasecmp(fNextToken, "\\HasChildren", 11))
      boxSpec->mBoxFlags |= kHasChildren;
    else if (!PL_strncasecmp(fNextToken, "\\HasNoChildren", 13))
      boxSpec->mBoxFlags |= kHasNoChildren;
    // we ignore flag other extensions

    endOfFlags = *(fNextToken + strlen(fNextToken) - 1) == ')';
    AdvanceToNextToken();
  } while (!endOfFlags && ContinueParse());

  if (ContinueParse()) {
    if (*fNextToken == '"') {
      fNextToken++;
      if (*fNextToken == '\\')  // handle escaped char
        boxSpec->mHierarchySeparator = *(fNextToken + 1);
      else
        boxSpec->mHierarchySeparator = *fNextToken;
    } else  // likely NIL.  Discovered late in 4.02 that we do not handle
            // literals here (e.g. {10} <10 chars>), although this is almost
            // impossibly unlikely
      boxSpec->mHierarchySeparator = kOnlineHierarchySeparatorNil;
    AdvanceToNextToken();
    if (ContinueParse()) mailbox(boxSpec);
  }
}

/* mailbox         ::= "INBOX" / astring
 */
void nsImapServerResponseParser::mailbox(nsImapMailboxSpec* boxSpec) {
  char* boxname = nullptr;
  const char* serverKey = fServerConnection.GetImapServerKey();
  bool xlistInbox = boxSpec->mBoxFlags & kImapInbox;

  if (!PL_strcasecmp(fNextToken, "INBOX") || xlistInbox) {
    boxname = PL_strdup("INBOX");
    if (xlistInbox) PR_Free(CreateAstring());
    AdvanceToNextToken();
  } else {
    boxname = CreateAstring();
    AdvanceToNextToken();
  }

  if (boxname && fHostSessionList) {
    fHostSessionList->SetNamespaceHierarchyDelimiterFromMailboxForHost(
        serverKey, boxname, boxSpec->mHierarchySeparator);

    nsImapNamespace* ns = nullptr;
    fHostSessionList->GetNamespaceForMailboxForHost(serverKey, boxname, ns);
    if (ns) {
      switch (ns->GetType()) {
        case kPersonalNamespace:
          boxSpec->mBoxFlags |= kPersonalMailbox;
          break;
        case kPublicNamespace:
          boxSpec->mBoxFlags |= kPublicMailbox;
          break;
        case kOtherUsersNamespace:
          boxSpec->mBoxFlags |= kOtherUsersMailbox;
          break;
        default:  // (kUnknownNamespace)
          break;
      }
      boxSpec->mNamespaceForFolder = ns;
    }
  }

  if (!boxname) {
    if (!fServerConnection.DeathSignalReceived()) HandleMemoryFailure();
  } else if (boxSpec->mConnection && boxSpec->mConnection->GetCurrentUrl()) {
    boxSpec->mConnection->GetCurrentUrl()->AllocateCanonicalPath(
        boxname, boxSpec->mHierarchySeparator,
        getter_Copies(boxSpec->mAllocatedPathName));
    nsIURI* aURL = nullptr;
    boxSpec->mConnection->GetCurrentUrl()->QueryInterface(NS_GET_IID(nsIURI),
                                                          (void**)&aURL);
    if (aURL) aURL->GetHost(boxSpec->mHostName);

    NS_IF_RELEASE(aURL);
    // storage for the boxSpec is now owned by server connection
    fServerConnection.DiscoverMailboxSpec(boxSpec);

    // if this was cancelled by the user,then we sure don't want to
    // send more mailboxes their way
    if (NS_FAILED(fServerConnection.GetConnectionStatus())) SetConnected(false);
  }

  if (boxname) PL_strfree(boxname);
}

/*
 message_data    ::= nz_number SPACE ("EXPUNGE" /
                              ("FETCH" SPACE msg_fetch) / msg_obsolete)

was changed to

numeric_mailbox_data ::=  number SPACE "EXISTS" / number SPACE "RECENT"
 / nz_number SPACE ("EXPUNGE" /
                              ("FETCH" SPACE msg_fetch) / msg_obsolete)

*/
void nsImapServerResponseParser::numeric_mailbox_data() {
  int32_t tokenNumber = atoi(fNextToken);
  AdvanceToNextToken();

  if (ContinueParse()) {
    if (!PL_strcasecmp(fNextToken, "FETCH")) {
      fFetchResponseIndex = tokenNumber;
      AdvanceToNextToken();
      if (ContinueParse()) msg_fetch();
    } else if (!PL_strcasecmp(fNextToken, "EXISTS")) {
      fNumberOfExistingMessages = tokenNumber;
      AdvanceToNextToken();
    } else if (!PL_strcasecmp(fNextToken, "RECENT")) {
      fNumberOfRecentMessages = tokenNumber;
      AdvanceToNextToken();
    } else if (!PL_strcasecmp(fNextToken, "EXPUNGE")) {
      if (!fServerConnection.GetIgnoreExpunges())
        fFlagState->ExpungeByIndex((uint32_t)tokenNumber);
      skip_to_CRLF();
    } else
      msg_obsolete();
  }
}

/*
msg_fetch       ::= "(" 1#("BODY" SPACE body /
"BODYSTRUCTURE" SPACE body /
"BODY[" section "]" SPACE nstring /
"ENVELOPE" SPACE envelope /
"FLAGS" SPACE "(" #(flag / "\Recent") ")" /
"INTERNALDATE" SPACE date_time /
"MODSEQ" SPACE "(" nz_number ")" /
"RFC822" [".HEADER" / ".TEXT"] SPACE nstring /
"RFC822.SIZE" SPACE number /
"UID" SPACE uniqueid) ")"

*/

void nsImapServerResponseParser::msg_fetch() {
  bool bNeedEndMessageDownload = false;

  // we have not seen a uid response or flags for this fetch, yet
  fCurrentResponseUID = 0;
  fCurrentLineContainedFlagInfo = false;
  fSizeOfMostRecentMessage = 0;
  // show any incremental progress, for instance, for header downloading
  fServerConnection.ShowProgress();

  fNextToken++;  // eat the '(' character

  // some of these productions are ignored for now
  while (ContinueParse() && (*fNextToken != ')')) {
    if (!PL_strcasecmp(fNextToken, "FLAGS")) {
      if (fCurrentResponseUID == 0)
        fFlagState->GetUidOfMessage(fFetchResponseIndex - 1,
                                    &fCurrentResponseUID);

      AdvanceToNextToken();
      if (ContinueParse()) flags();

      if (ContinueParse()) {  // eat the closing ')'
        fNextToken++;
        // there may be another ')' to close out
        // msg_fetch.  If there is then don't advance
        if (*fNextToken != ')') AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "UID")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        fCurrentResponseUID = strtoul(fNextToken, nullptr, 10);
        if (fCurrentResponseUID > fHighestRecordedUID)
          fHighestRecordedUID = fCurrentResponseUID;
        // size came before UID
        if (fSizeOfMostRecentMessage)
          fReceivedHeaderOrSizeForUID = CurrentResponseUID();
        // if this token ends in ')', then it is the last token
        // else we advance
        char lastTokenChar = *(fNextToken + strlen(fNextToken) - 1);
        if (lastTokenChar == ')')
          fNextToken += strlen(fNextToken) - 1;
        else if (lastTokenChar < '0' || lastTokenChar > '9') {
          // GIANT HACK
          // this is a corrupt uid - see if it's pre 5.08 Zimbra omitting
          // a space between the UID and MODSEQ
          if (strlen(fNextToken) > 6 &&
              !strcmp("MODSEQ", fNextToken + strlen(fNextToken) - 6))
            fNextToken += strlen(fNextToken) - 6;
        } else
          AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "MODSEQ")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        fNextToken++;  // eat '('
        uint64_t modSeq = ParseUint64Str(fNextToken);
        if (modSeq > fHighestModSeq) fHighestModSeq = modSeq;

        if (PL_strcasestr(fNextToken, ")")) {
          // eat token chars until we get the ')'
          fNextToken = strchr(fNextToken, ')');
          if (fNextToken) {
            fNextToken++;
            if (*fNextToken != ')') AdvanceToNextToken();
          } else
            SetSyntaxError(true);
        } else {
          SetSyntaxError(true);
        }
      }
    } else if (!PL_strcasecmp(fNextToken, "RFC822") ||
               !PL_strcasecmp(fNextToken, "RFC822.HEADER") ||
               !PL_strncasecmp(fNextToken, "BODY[HEADER", 11) ||
               !PL_strncasecmp(fNextToken, "BODY[]", 6) ||
               !PL_strcasecmp(fNextToken, "RFC822.TEXT") ||
               (!PL_strncasecmp(fNextToken, "BODY[", 5) &&
                PL_strstr(fNextToken, "HEADER"))) {
      if (fCurrentResponseUID == 0)
        fFlagState->GetUidOfMessage(fFetchResponseIndex - 1,
                                    &fCurrentResponseUID);

      if (!PL_strcasecmp(fNextToken, "RFC822.HEADER") ||
          !PL_strcasecmp(fNextToken, "BODY[HEADER]")) {
        // all of this message's headers
        AdvanceToNextToken();
        fDownloadingHeaders = true;
        BeginMessageDownload(MESSAGE_RFC822);  // initialize header parser
        bNeedEndMessageDownload = false;
        if (ContinueParse()) msg_fetch_headers(nullptr);
      } else if (!PL_strncasecmp(fNextToken, "BODY[HEADER.FIELDS", 19)) {
        fDownloadingHeaders = true;
        BeginMessageDownload(MESSAGE_RFC822);  // initialize header parser
        // specific message header fields
        while (ContinueParse() && fNextToken[strlen(fNextToken) - 1] != ']')
          AdvanceToNextToken();
        if (ContinueParse()) {
          bNeedEndMessageDownload = false;
          AdvanceToNextToken();
          if (ContinueParse()) msg_fetch_headers(nullptr);
        }
      } else {
        char* whereHeader = PL_strstr(fNextToken, "HEADER");
        if (whereHeader) {
          const char* startPartNum = fNextToken + 5;
          if (whereHeader > startPartNum) {
            int32_t partLength =
                whereHeader - startPartNum - 1;  //-1 for the dot!
            char* partNum = (char*)PR_CALLOC((partLength + 1) * sizeof(char));
            if (partNum) {
              PL_strncpy(partNum, startPartNum, partLength);
              if (ContinueParse()) {
                if (PL_strstr(fNextToken, "FIELDS")) {
                  while (ContinueParse() &&
                         fNextToken[strlen(fNextToken) - 1] != ']')
                    AdvanceToNextToken();
                }
                if (ContinueParse()) {
                  AdvanceToNextToken();
                  if (ContinueParse()) msg_fetch_headers(partNum);
                }
              }
              PR_Free(partNum);
            }
          } else
            SetSyntaxError(true);
        } else {
          fDownloadingHeaders = false;

          bool chunk = false;
          int32_t origin = 0;
          if (!PL_strncasecmp(fNextToken, "BODY[]<", 7)) {
            char* tokenCopy = 0;
            tokenCopy = PL_strdup(fNextToken);
            if (tokenCopy) {
              char* originString =
                  tokenCopy + 7;  // where the byte number starts
              char* closeBracket = PL_strchr(tokenCopy, '>');
              if (closeBracket && originString && *originString) {
                *closeBracket = 0;
                origin = atoi(originString);
                chunk = true;
              }
              PR_Free(tokenCopy);
            }
          }

          AdvanceToNextToken();
          if (ContinueParse()) {
            msg_fetch_content(chunk, origin, MESSAGE_RFC822);
          }
        }
      }
    } else if (!PL_strcasecmp(fNextToken, "RFC822.SIZE") ||
               !PL_strcasecmp(fNextToken, "XAOL.SIZE")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        bool sendEndMsgDownload =
            (GetDownloadingHeaders() &&
             fReceivedHeaderOrSizeForUID == CurrentResponseUID());
        fSizeOfMostRecentMessage = strtoul(fNextToken, nullptr, 10);
        fReceivedHeaderOrSizeForUID = CurrentResponseUID();
        if (sendEndMsgDownload) {
          fServerConnection.NormalMessageEndDownload();
          fReceivedHeaderOrSizeForUID = nsMsgKey_None;
        }

        if (fSizeOfMostRecentMessage == 0 && CurrentResponseUID()) {
          // on no, bogus Netscape 2.0 mail server bug
          char uidString[100];
          sprintf(uidString, "%ld", (long)CurrentResponseUID());

          if (!fZeroLengthMessageUidString.IsEmpty())
            fZeroLengthMessageUidString += ",";

          fZeroLengthMessageUidString += uidString;
        }

        // if this token ends in ')', then it is the last token
        // else we advance
        if (*(fNextToken + strlen(fNextToken) - 1) == ')')
          fNextToken += strlen(fNextToken) - 1;
        else
          AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "XSENDER")) {
      PR_FREEIF(fXSenderInfo);
      AdvanceToNextToken();
      if (!fNextToken)
        SetSyntaxError(true);
      else {
        fXSenderInfo = CreateAstring();
        AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "X-GM-MSGID")) {
      AdvanceToNextToken();
      if (!fNextToken)
        SetSyntaxError(true);
      else {
        fMsgID = CreateAtom();
        AdvanceToNextToken();
        nsCString msgIDValue;
        msgIDValue.Assign(fMsgID);
        if (fCurrentResponseUID == 0)
          fFlagState->GetUidOfMessage(fFetchResponseIndex - 1,
                                      &fCurrentResponseUID);
        fFlagState->SetCustomAttribute(fCurrentResponseUID, "X-GM-MSGID"_ns,
                                       msgIDValue);
        PR_FREEIF(fMsgID);
      }
    } else if (!PL_strcasecmp(fNextToken, "X-GM-THRID")) {
      AdvanceToNextToken();
      if (!fNextToken)
        SetSyntaxError(true);
      else {
        fThreadID = CreateAtom();
        AdvanceToNextToken();
        nsCString threadIDValue;
        threadIDValue.Assign(fThreadID);
        if (fCurrentResponseUID == 0)
          fFlagState->GetUidOfMessage(fFetchResponseIndex - 1,
                                      &fCurrentResponseUID);
        fFlagState->SetCustomAttribute(fCurrentResponseUID, "X-GM-THRID"_ns,
                                       threadIDValue);
        PR_FREEIF(fThreadID);
      }
    } else if (!PL_strcasecmp(fNextToken, "X-GM-LABELS")) {
      AdvanceToNextToken();
      if (!fNextToken)
        SetSyntaxError(true);
      else {
        fLabels = CreateParenGroup();
        nsCString labelsValue;
        labelsValue.Assign(fLabels);
        labelsValue.Cut(0, 1);
        labelsValue.Cut(labelsValue.Length() - 1, 1);
        if (fCurrentResponseUID == 0)
          fFlagState->GetUidOfMessage(fFetchResponseIndex - 1,
                                      &fCurrentResponseUID);
        fFlagState->SetCustomAttribute(fCurrentResponseUID, "X-GM-LABELS"_ns,
                                       labelsValue);
        PR_FREEIF(fLabels);
      }
    }

    // I only fetch RFC822 so I should never see these BODY responses
    else if (!PL_strcasecmp(fNextToken, "BODY"))
      skip_to_CRLF();  // I never ask for this
    else if (!PL_strncasecmp(fNextToken, "BODY[TEXT", 9)) {
      // This parses the "preview" response (first 2048 bytes of body text).
      mime_part_data();  // Note: TEXT is not an actual mime part.
    } else if (!PL_strcasecmp(fNextToken, "ENVELOPE")) {
      fDownloadingHeaders = true;
      bNeedEndMessageDownload = true;
      BeginMessageDownload(MESSAGE_RFC822);
      envelope_data();
    } else if (!PL_strcasecmp(fNextToken, "INTERNALDATE")) {
      fDownloadingHeaders =
          true;  // we only request internal date while downloading headers
      if (!bNeedEndMessageDownload) BeginMessageDownload(MESSAGE_RFC822);
      bNeedEndMessageDownload = true;
      internal_date();
    } else if (!PL_strcasecmp(fNextToken, "XAOL-ENVELOPE")) {
      fDownloadingHeaders = true;
      if (!bNeedEndMessageDownload) BeginMessageDownload(MESSAGE_RFC822);
      bNeedEndMessageDownload = true;
      xaolenvelope_data();
    } else {
      nsImapAction imapAction;
      if (!fServerConnection.GetCurrentUrl()) return;
      fServerConnection.GetCurrentUrl()->GetImapAction(&imapAction);
      nsAutoCString userDefinedFetchAttribute;
      fServerConnection.GetCurrentUrl()->GetCustomAttributeToFetch(
          userDefinedFetchAttribute);
      if ((imapAction == nsIImapUrl::nsImapUserDefinedFetchAttribute &&
           !strcmp(userDefinedFetchAttribute.get(), fNextToken)) ||
          imapAction == nsIImapUrl::nsImapUserDefinedMsgCommand) {
        AdvanceToNextToken();
        char* fetchResult;
        if (fNextToken[0] == '(')
          // look through the tokens until we find the closing ')'
          // we can have a result like the following:
          // ((A B) (C D) (E F))
          fetchResult = CreateParenGroup();
        else {
          fetchResult = CreateAstring();
          AdvanceToNextToken();
        }
        if (imapAction == nsIImapUrl::nsImapUserDefinedFetchAttribute)
          fServerConnection.GetCurrentUrl()->SetCustomAttributeResult(
              nsDependentCString(fetchResult));
        if (imapAction == nsIImapUrl::nsImapUserDefinedMsgCommand)
          fServerConnection.GetCurrentUrl()->SetCustomCommandResult(
              nsDependentCString(fetchResult));
        PR_Free(fetchResult);
      } else
        SetSyntaxError(true);
    }
  }

  if (ContinueParse()) {
    if (CurrentResponseUID() && CurrentResponseUID() != nsMsgKey_None &&
        fCurrentLineContainedFlagInfo && fFlagState) {
      fFlagState->AddUidFlagPair(CurrentResponseUID(), fSavedFlagInfo,
                                 fFetchResponseIndex - 1);
      for (uint32_t i = 0; i < fCustomFlags.Length(); i++)
        fFlagState->AddUidCustomFlagPair(CurrentResponseUID(),
                                         fCustomFlags[i].get());
      fCustomFlags.Clear();
    }

    if (fFetchingAllFlags)
      fCurrentLineContainedFlagInfo =
          false;  // do not fire if in PostProcessEndOfLine

    AdvanceToNextToken();  // eat the ')' ending token
    // should be at end of line
    if (bNeedEndMessageDownload) {
      if (ContinueParse()) {
        // complete the message download
        fServerConnection.NormalMessageEndDownload();
      } else
        fServerConnection.AbortMessageDownLoad();
    }
  }
}

typedef enum _envelopeItemType {
  envelopeString,
  envelopeAddress
} envelopeItemType;

typedef struct {
  const char* name;
  envelopeItemType type;
} envelopeItem;

// RFC3501:  envelope  = "(" env-date SP env-subject SP env-from SP
//                       env-sender SP env-reply-to SP env-to SP env-cc SP
//                       env-bcc SP env-in-reply-to SP env-message-id ")"
//           env-date    = nstring
//           env-subject = nstring
//           env-from    = "(" 1*address ")" / nil
//           env-sender  = "(" 1*address ")" / nil
//           env-reply-to= "(" 1*address ")" / nil
//           env-to      = "(" 1*address ")" / nil
//           env-cc      = "(" 1*address ")" / nil
//           env-bcc     = "(" 1*address ")" / nil
//           env-in-reply-to = nstring
//           env-message-id  = nstring

static const envelopeItem EnvelopeTable[] = {
    {"Date", envelopeString},        {"Subject", envelopeString},
    {"From", envelopeAddress},       {"Sender", envelopeAddress},
    {"Reply-to", envelopeAddress},   {"To", envelopeAddress},
    {"Cc", envelopeAddress},         {"Bcc", envelopeAddress},
    {"In-reply-to", envelopeString}, {"Message-id", envelopeString}};

void nsImapServerResponseParser::envelope_data() {
  AdvanceToNextToken();
  fNextToken++;  // eat '('
  for (int tableIndex = 0;
       tableIndex < (int)(sizeof(EnvelopeTable) / sizeof(EnvelopeTable[0]));
       tableIndex++) {
    if (!ContinueParse()) break;
    if (*fNextToken == ')') {
      SetSyntaxError(true);  // envelope too short
      break;
    }

    nsAutoCString headerLine(EnvelopeTable[tableIndex].name);
    headerLine += ": ";
    bool headerNonNil = true;
    if (EnvelopeTable[tableIndex].type == envelopeString) {
      nsAutoCString strValue;
      strValue.Adopt(CreateNilString());
      if (!strValue.IsEmpty())
        headerLine.Append(strValue);
      else
        headerNonNil = false;
    } else {
      nsAutoCString address;
      parse_address(address);
      headerLine += address;
      if (address.IsEmpty()) headerNonNil = false;
    }
    if (headerNonNil)
      fServerConnection.HandleMessageDownLoadLine(headerLine.get(), false);

    if (ContinueParse()) AdvanceToNextToken();
  }
  // Now we should be at the end of the envelope and have *fToken == ')'.
  // Skip this last parenthesis.
  AdvanceToNextToken();
}

void nsImapServerResponseParser::xaolenvelope_data() {
  // eat the opening '('
  fNextToken++;

  if (ContinueParse() && (*fNextToken != ')')) {
    AdvanceToNextToken();
    fNextToken++;  // eat '('
    nsAutoCString subject;
    subject.Adopt(CreateNilString());
    nsAutoCString subjectLine("Subject: ");
    subjectLine += subject;
    fServerConnection.HandleMessageDownLoadLine(subjectLine.get(), false);
    fNextToken++;  // eat the next '('
    if (ContinueParse()) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        nsAutoCString fromLine;
        if (!strcmp(GetSelectedMailboxName(), "Sent Items")) {
          // xaol envelope switches the From with the To, so we switch them back
          // and create a fake from line From: user@aol.com
          fromLine.AppendLiteral("To: ");
          nsAutoCString fakeFromLine("From: "_ns);
          fakeFromLine.Append(fServerConnection.GetImapUserName());
          fakeFromLine.AppendLiteral("@aol.com");
          fServerConnection.HandleMessageDownLoadLine(fakeFromLine.get(),
                                                      false);
        } else {
          fromLine.AppendLiteral("From: ");
        }
        parse_address(fromLine);
        fServerConnection.HandleMessageDownLoadLine(fromLine.get(), false);
        if (ContinueParse()) {
          AdvanceToNextToken();  // ge attachment size
          int32_t attachmentSize = atoi(fNextToken);
          if (attachmentSize != 0) {
            nsAutoCString attachmentLine("X-attachment-size: ");
            attachmentLine.AppendInt(attachmentSize);
            fServerConnection.HandleMessageDownLoadLine(attachmentLine.get(),
                                                        false);
          }
        }
        if (ContinueParse()) {
          AdvanceToNextToken();  // skip image size
          int32_t imageSize = atoi(fNextToken);
          if (imageSize != 0) {
            nsAutoCString imageLine("X-image-size: ");
            imageLine.AppendInt(imageSize);
            fServerConnection.HandleMessageDownLoadLine(imageLine.get(), false);
          }
        }
        if (ContinueParse()) AdvanceToNextToken();  // skip )
      }
    }
  }
}

void nsImapServerResponseParser::parse_address(nsAutoCString& addressLine) {
  // NOTE: Not sure this function correctly handling group address syntax.
  // See Bug 1609846.
  if (!strcmp(fNextToken, "NIL")) return;
  bool firstAddress = true;
  // should really look at chars here
  NS_ASSERTION(*fNextToken == '(', "address should start with '('");
  fNextToken++;  // eat the next '('
  while (ContinueParse() && *fNextToken == '(') {
    NS_ASSERTION(*fNextToken == '(', "address should start with '('");
    fNextToken++;  // eat the next '('

    if (!firstAddress) addressLine += ", ";

    firstAddress = false;
    char* personalName = CreateNilString();
    AdvanceToNextToken();
    char* atDomainList = CreateNilString();
    if (ContinueParse()) {
      AdvanceToNextToken();
      char* mailboxName = CreateNilString();
      if (ContinueParse()) {
        AdvanceToNextToken();
        char* hostName = CreateNilString();
        AdvanceToNextToken();
        if (mailboxName) {
          addressLine += mailboxName;
        }
        if (hostName) {
          addressLine += '@';
          addressLine += hostName;
          PR_Free(hostName);
        }
        if (personalName) {
          addressLine += " (";
          addressLine += personalName;
          addressLine += ')';
        }
      }
      PR_Free(mailboxName);
    }
    PR_Free(personalName);
    PR_Free(atDomainList);

    if (*fNextToken == ')') fNextToken++;
    // if the next token isn't a ')' for the address term,
    // then we must have another address pair left....so get the next
    // token and continue parsing in this loop...
    if (*fNextToken == '\0') AdvanceToNextToken();
  }
  if (*fNextToken == ')') fNextToken++;
  // AdvanceToNextToken();  // skip "))"
}

void nsImapServerResponseParser::internal_date() {
  AdvanceToNextToken();
  if (ContinueParse()) {
    nsAutoCString dateLine("Date: ");
    char* strValue = CreateNilString();
    if (strValue) {
      dateLine += strValue;
      free(strValue);
    }
    fServerConnection.HandleMessageDownLoadLine(dateLine.get(), false);
  }
  // advance the parser.
  AdvanceToNextToken();
}

void nsImapServerResponseParser::flags() {
  imapMessageFlagsType messageFlags = kNoImapMsgFlag;
  fCustomFlags.Clear();

  // clear the custom flags for this message
  // otherwise the old custom flags will stay around
  // see bug #191042
  if (fFlagState && CurrentResponseUID() != nsMsgKey_None)
    fFlagState->ClearCustomFlags(CurrentResponseUID());

  // eat the opening '('
  fNextToken++;
  while (ContinueParse() && (*fNextToken != ')')) {
    bool knownFlag = false;
    if (*fNextToken == '\\') {
      switch (NS_ToUpper(fNextToken[1])) {
        case 'S':
          if (!PL_strncasecmp(fNextToken, "\\Seen", 5)) {
            messageFlags |= kImapMsgSeenFlag;
            knownFlag = true;
          }
          break;
        case 'A':
          if (!PL_strncasecmp(fNextToken, "\\Answered", 9)) {
            messageFlags |= kImapMsgAnsweredFlag;
            knownFlag = true;
          }
          break;
        case 'F':
          if (!PL_strncasecmp(fNextToken, "\\Flagged", 8)) {
            messageFlags |= kImapMsgFlaggedFlag;
            knownFlag = true;
          }
          break;
        case 'D':
          if (!PL_strncasecmp(fNextToken, "\\Deleted", 8)) {
            messageFlags |= kImapMsgDeletedFlag;
            knownFlag = true;
          } else if (!PL_strncasecmp(fNextToken, "\\Draft", 6)) {
            messageFlags |= kImapMsgDraftFlag;
            knownFlag = true;
          }
          break;
        case 'R':
          if (!PL_strncasecmp(fNextToken, "\\Recent", 7)) {
            messageFlags |= kImapMsgRecentFlag;
            knownFlag = true;
          }
          break;
        default:
          break;
      }
    } else if (*fNextToken == '$') {
      switch (NS_ToUpper(fNextToken[1])) {
        case 'M':
          if ((fSupportsUserDefinedFlags &
               (kImapMsgSupportUserFlag | kImapMsgSupportMDNSentFlag)) &&
              !PL_strncasecmp(fNextToken, "$MDNSent", 8)) {
            messageFlags |= kImapMsgMDNSentFlag;
            knownFlag = true;
          }
          break;
        case 'F':
          if ((fSupportsUserDefinedFlags &
               (kImapMsgSupportUserFlag | kImapMsgSupportForwardedFlag)) &&
              !PL_strncasecmp(fNextToken, "$Forwarded", 10)) {
            messageFlags |= kImapMsgForwardedFlag;
            knownFlag = true;
          }
          break;
        default:
          break;
      }
    }
    if (!knownFlag && fFlagState) {
      nsAutoCString flag(fNextToken);
      int32_t parenIndex = flag.FindChar(')');
      if (parenIndex > 0) flag.SetLength(parenIndex);
      messageFlags |= kImapMsgCustomKeywordFlag;
      if (CurrentResponseUID() != nsMsgKey_None && CurrentResponseUID() != 0)
        fFlagState->AddUidCustomFlagPair(CurrentResponseUID(), flag.get());
      else
        fCustomFlags.AppendElement(flag);
    }
    if (PL_strcasestr(fNextToken, ")")) {
      // eat token chars until we get the ')'
      while (*fNextToken != ')') fNextToken++;
    } else
      AdvanceToNextToken();
  }

  if (ContinueParse())
    while (*fNextToken != ')') fNextToken++;

  fCurrentLineContainedFlagInfo = true;  // handled in PostProcessEndOfLine
  fSavedFlagInfo = messageFlags;
}

// RFC3501:  resp-cond-state = ("OK" / "NO" / "BAD") SP resp-text
//                             ; Status condition
void nsImapServerResponseParser::resp_cond_state(bool isTagged) {
  // According to RFC3501, Sec. 7.1, the untagged NO response "indicates a
  // warning; the command can still complete successfully."
  // However, the untagged BAD response "indicates a protocol-level error for
  // which the associated command can not be determined; it can also indicate an
  // internal server failure."
  // Thus, we flag an error for a tagged NO response and for any BAD response.
  if ((isTagged && !PL_strcasecmp(fNextToken, "NO")) ||
      !PL_strcasecmp(fNextToken, "BAD"))
    fCurrentCommandFailed = true;

  AdvanceToNextToken();
  if (ContinueParse()) resp_text();
}

/*
resp_text       ::= ["[" resp_text_code "]" SPACE] (text_mime2 / text)

  was changed to in order to enable a one symbol look ahead predictive
  parser.

    resp_text       ::= ["[" resp_text_code  SPACE] (text_mime2 / text)
*/
void nsImapServerResponseParser::resp_text() {
  if (ContinueParse() && (*fNextToken == '[')) resp_text_code();

  if (ContinueParse()) {
    if (!PL_strcmp(fNextToken, "=?"))
      text_mime2();
    else
      text();
  }
}
/*
 text_mime2       ::= "=?" <charset> "?" <encoding> "?"
                               <encoded-text> "?="
                               ;; Syntax defined in [MIME-2]
*/
void nsImapServerResponseParser::text_mime2() { skip_to_CRLF(); }

/*
 text            ::= 1*TEXT_CHAR

*/
void nsImapServerResponseParser::text() { skip_to_CRLF(); }

void nsImapServerResponseParser::parse_folder_flags(bool calledForFlags) {
  uint16_t junkNotJunkFlags = 0;

  do {
    AdvanceToNextToken();
    if (*fNextToken == '(') fNextToken++;
    if (!PL_strncasecmp(fNextToken, "\\Seen", 5))
      fSettablePermanentFlags |= kImapMsgSeenFlag;
    else if (!PL_strncasecmp(fNextToken, "\\Answered", 9))
      fSettablePermanentFlags |= kImapMsgAnsweredFlag;
    else if (!PL_strncasecmp(fNextToken, "\\Flagged", 8))
      fSettablePermanentFlags |= kImapMsgFlaggedFlag;
    else if (!PL_strncasecmp(fNextToken, "\\Deleted", 8))
      fSettablePermanentFlags |= kImapMsgDeletedFlag;
    else if (!PL_strncasecmp(fNextToken, "\\Draft", 6))
      fSettablePermanentFlags |= kImapMsgDraftFlag;
    else if (!PL_strncasecmp(fNextToken, "\\*", 2)) {
      // User defined and special keywords (tags) can be defined and set for
      // mailbox. Should only occur in PERMANENTFLAGS response.
      fSupportsUserDefinedFlags |= kImapMsgSupportUserFlag;
      fSupportsUserDefinedFlags |= kImapMsgSupportForwardedFlag;
      fSupportsUserDefinedFlags |= kImapMsgSupportMDNSentFlag;
    }
    // Treat special and built-in $LabelX's as user defined and include
    // $Junk/$NotJunk too.
    else if (!PL_strncasecmp(fNextToken, "$MDNSent", 8))
      fSupportsUserDefinedFlags |= kImapMsgSupportMDNSentFlag;
    else if (!PL_strncasecmp(fNextToken, "$Forwarded", 10))
      fSupportsUserDefinedFlags |= kImapMsgSupportForwardedFlag;
    else if (!PL_strncasecmp(fNextToken, "$Junk", 5))
      junkNotJunkFlags |= 1;
    else if (!PL_strncasecmp(fNextToken, "$NotJunk", 8))
      junkNotJunkFlags |= 2;
  } while (!fAtEndOfLine && ContinueParse());

  if (fFlagState) fFlagState->OrSupportedUserFlags(fSupportsUserDefinedFlags);

  if (calledForFlags) {
    // Set true if both "$Junk" and "$NotJunk" appear in FLAGS.
    fStdJunkNotJunkUseOk = (junkNotJunkFlags == 3);
  }
}
/*
  resp_text_code  ::= ("ALERT" / "PARSE" /
                              "PERMANENTFLAGS" SPACE "(" #(flag / "\*") ")" /
                              "READ-ONLY" / "READ-WRITE" / "TRYCREATE" /
                              "UIDVALIDITY" SPACE nz_number /
                              "UNSEEN" SPACE nz_number /
                              "HIGHESTMODSEQ" SPACE nz_number /
                              "NOMODSEQ" /
                              atom [SPACE 1*<any TEXT_CHAR except "]">] )
                      "]"


*/
void nsImapServerResponseParser::resp_text_code() {
  // this is a special case way of advancing the token
  // strtok won't break up "[ALERT]" into separate tokens
  if (strlen(fNextToken) > 1)
    fNextToken++;
  else
    AdvanceToNextToken();

  if (ContinueParse()) {
    if (!PL_strcasecmp(fNextToken, "ALERT]")) {
      char* alertMsg = fCurrentTokenPlaceHolder;  // advance past ALERT]
      if (alertMsg && *alertMsg &&
          (!fLastAlert || PL_strcmp(fNextToken, fLastAlert))) {
        fServerConnection.AlertUserEvent(alertMsg);
        PR_Free(fLastAlert);
        fLastAlert = PL_strdup(alertMsg);
      }
      AdvanceToNextToken();
    } else if (!PL_strcasecmp(fNextToken, "PARSE]")) {
      // do nothing for now
      AdvanceToNextToken();
    } else if (!PL_strcasecmp(fNextToken, "NETSCAPE]")) {
      skip_to_CRLF();
    } else if (!PL_strcasecmp(fNextToken, "PERMANENTFLAGS")) {
      uint32_t saveSettableFlags = fSettablePermanentFlags;
      fSupportsUserDefinedFlags = 0;  // assume no unless told
      fSettablePermanentFlags = 0;    // assume none, unless told otherwise.
      parse_folder_flags(false);
      // if the server tells us there are no permanent flags, we're
      // just going to pretend that the FLAGS response flags, if any, are
      // permanent in case the server is broken. This will allow us
      // to store delete and seen flag changes - if they're not permanent,
      // they're not permanent, but at least we'll try to set them.
      if (!fSettablePermanentFlags) fSettablePermanentFlags = saveSettableFlags;
      fGotPermanentFlags = true;
    } else if (!PL_strcasecmp(fNextToken, "READ-ONLY]")) {
      fCurrentFolderReadOnly = true;
      AdvanceToNextToken();
    } else if (!PL_strcasecmp(fNextToken, "READ-WRITE]")) {
      fCurrentFolderReadOnly = false;
      AdvanceToNextToken();
    } else if (!PL_strcasecmp(fNextToken, "TRYCREATE]")) {
      // do nothing for now
      AdvanceToNextToken();
    } else if (!PL_strcasecmp(fNextToken, "UIDVALIDITY")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        fFolderUIDValidity = strtoul(fNextToken, nullptr, 10);
        fHighestRecordedUID = 0;
        AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "UNSEEN")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        // Note: As a response code, "UNSEEN" is NOT the number of
        // unseen/unread messages. It is the lowest sequence number of the first
        // unseen/unread message in the mailbox.
        fSeqNumOfFirstUnseenMsg = strtoul(fNextToken, nullptr, 10);
        AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "UIDNEXT")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        fNextUID = strtoul(fNextToken, nullptr, 10);
        AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "APPENDUID")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        // ** jt -- the returned uidvalidity is the destination folder
        // uidvalidity; don't use it for current folder
        // fFolderUIDValidity = atoi(fNextToken);
        // fHighestRecordedUID = 0; ??? this should be wrong
        AdvanceToNextToken();
        if (ContinueParse()) {
          fCurrentResponseUID = strtoul(fNextToken, nullptr, 10);
          AdvanceToNextToken();
        }
      }
    } else if (!PL_strcasecmp(fNextToken, "COPYUID")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        // ** jt -- destination folder uidvalidity
        // fFolderUIDValidity = atoi(fNextToken);
        // original message set; ignore it
        AdvanceToNextToken();
        if (ContinueParse()) {
          // the resulting message set; should be in the form of
          // either uid or uid1:uid2
          AdvanceToNextToken();
          // clear copy response uid
          fServerConnection.SetCopyResponseUid(fNextToken);
        }
        if (ContinueParse()) AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "HIGHESTMODSEQ")) {
      AdvanceToNextToken();
      if (ContinueParse()) {
        fHighestModSeq = ParseUint64Str(fNextToken);
        fUseModSeq = true;
        AdvanceToNextToken();
      }
    } else if (!PL_strcasecmp(fNextToken, "NOMODSEQ]")) {
      fHighestModSeq = 0;
      fUseModSeq = false;
      skip_to_CRLF();
    } else if (!PL_strcasecmp(fNextToken, "CAPABILITY")) {
      capability_data();
    } else if (!PL_strcasecmp(fNextToken, "MYRIGHTS")) {
      myrights_data(true);
    } else  // just text
    {
      // do nothing but eat tokens until we see the ] or CRLF
      // we should see the ] but we don't want to go into an
      // endless loop if the CRLF is not there
      do {
        AdvanceToNextToken();
      } while (!PL_strcasestr(fNextToken, "]") && !fAtEndOfLine &&
               ContinueParse());
    }
  }
}

// RFC3501:  response-done = response-tagged / response-fatal
void nsImapServerResponseParser::response_done() {
  if (ContinueParse()) {
    if (!PL_strcmp(fCurrentCommandTag, fNextToken))
      response_tagged();
    else
      response_fatal();
  }
}

// RFC3501:  response-tagged = tag SP resp-cond-state CRLF
void nsImapServerResponseParser::response_tagged() {
  // eat the tag
  AdvanceToNextToken();
  if (ContinueParse()) {
    resp_cond_state(true);
    if (ContinueParse()) {
      if (!fAtEndOfLine)
        SetSyntaxError(true);
      else if (!fCurrentCommandFailed)
        ResetLexAnalyzer();
    }
  }
}

// RFC3501:  response-fatal = "*" SP resp-cond-bye CRLF
//                              ; Server closes connection immediately
void nsImapServerResponseParser::response_fatal() {
  // eat the "*"
  AdvanceToNextToken();
  if (ContinueParse()) resp_cond_bye();
}

// RFC3501:  resp-cond-bye = "BYE" SP resp-text
void nsImapServerResponseParser::resp_cond_bye() {
  SetConnected(false);
  fIMAPstate = kNonAuthenticated;
}

void nsImapServerResponseParser::msg_fetch_headers(const char* partNum) {
  msg_fetch_content(false, 0, MESSAGE_RFC822);
}

/* nstring         ::= string / nil
string          ::= quoted / literal
nil             ::= "NIL"

*/
void nsImapServerResponseParser::msg_fetch_content(bool chunk, int32_t origin,
                                                   const char* content_type) {
  // setup the stream for downloading this message.
  // Note: no longer concerned with body shell issues since now we only fetch
  // full message.
  if ((!chunk || (origin == 0)) && !GetDownloadingHeaders()) {
    if (NS_FAILED(BeginMessageDownload(content_type))) return;
  }

  if (PL_strcasecmp(fNextToken, "NIL")) {
    if (*fNextToken == '"')
      fLastChunk = msg_fetch_quoted();
    else
      fLastChunk = msg_fetch_literal(chunk, origin);
  } else
    AdvanceToNextToken();  // eat "NIL"

  if (fLastChunk) {
    // complete the message download
    if (ContinueParse()) {
      if (fReceivedHeaderOrSizeForUID == CurrentResponseUID()) {
        fServerConnection.NormalMessageEndDownload();
        fReceivedHeaderOrSizeForUID = nsMsgKey_None;
      } else
        fReceivedHeaderOrSizeForUID = CurrentResponseUID();
    } else
      fServerConnection.AbortMessageDownLoad();
  }
}

void nsImapServerResponseParser::mime_part_data() {
  char* checkOriginToken = PL_strdup(fNextToken);
  if (checkOriginToken) {
    uint32_t origin = 0;
    bool originFound = false;
    char* whereStart = PL_strchr(checkOriginToken, '<');
    if (whereStart) {
      char* whereEnd = PL_strchr(whereStart, '>');
      if (whereEnd) {
        *whereEnd = 0;
        whereStart++;
        origin = atoi(whereStart);
        originFound = true;
      }
    }
    PR_Free(checkOriginToken);
    AdvanceToNextToken();
    msg_fetch_content(originFound, origin,
                      MESSAGE_RFC822);  // keep content type as message/rfc822,
                                        // even though the
    // MIME part might not be, because then libmime will
    // still handle and decode it.
  } else
    HandleMemoryFailure();
}

/*
quoted          ::= <"> *QUOTED_CHAR <">

  QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> /
  "\" quoted_specials

    quoted_specials ::= <"> / "\"
*/

bool nsImapServerResponseParser::msg_fetch_quoted() {
  // *Should* never get a quoted string in response to a chunked download,
  // but the RFCs don't forbid it
  char* q = CreateQuoted();
  if (q) {
    numberOfCharsInThisChunk = PL_strlen(q);
    fServerConnection.HandleMessageDownLoadLine(q, false, q);
    PR_Free(q);
  } else
    numberOfCharsInThisChunk = 0;

  AdvanceToNextToken();
  bool lastChunk =
      ((fServerConnection.GetCurFetchSize() == 0) ||
       (numberOfCharsInThisChunk != fServerConnection.GetCurFetchSize()));
  return lastChunk;
}

/* msg_obsolete    ::= "COPY" / ("STORE" SPACE msg_fetch)
;; OBSOLETE untagged data responses */
void nsImapServerResponseParser::msg_obsolete() {
  if (!PL_strcasecmp(fNextToken, "COPY"))
    AdvanceToNextToken();
  else if (!PL_strcasecmp(fNextToken, "STORE")) {
    AdvanceToNextToken();
    if (ContinueParse()) msg_fetch();
  } else
    SetSyntaxError(true);
}

void nsImapServerResponseParser::capability_data() {
  int32_t endToken = -1;
  fCapabilityFlag = kCapabilityDefined | kHasAuthOldLoginCapability;
  do {
    AdvanceToNextToken();
    if (fNextToken) {
      nsCString token(fNextToken);
      endToken = token.FindChar(']');
      if (endToken >= 0) token.SetLength(endToken);

      if (token.Equals("AUTH=LOGIN", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasAuthLoginCapability;
      else if (token.Equals("AUTH=PLAIN", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasAuthPlainCapability;
      else if (token.Equals("AUTH=CRAM-MD5",
                            nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasCRAMCapability;
      else if (token.Equals("AUTH=NTLM", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasAuthNTLMCapability;
      else if (token.Equals("AUTH=GSSAPI", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasAuthGssApiCapability;
      else if (token.Equals("AUTH=MSN", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasAuthMSNCapability;
      else if (token.Equals("AUTH=EXTERNAL",
                            nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasAuthExternalCapability;
      else if (token.Equals("AUTH=XOAUTH2", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasXOAuth2Capability;
      else if (token.Equals("STARTTLS", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasStartTLSCapability;
      else if (token.Equals("LOGINDISABLED",
                            nsCaseInsensitiveCStringComparator))
        fCapabilityFlag &= ~kHasAuthOldLoginCapability;  // remove flag
      else if (token.Equals("XSENDER", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasXSenderCapability;
      else if (token.Equals("IMAP4", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kIMAP4Capability;
      else if (token.Equals("IMAP4rev1", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kIMAP4rev1Capability;
      else if (Substring(token, 0, 5)
                   .Equals("IMAP4", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kIMAP4other;
      else if (token.Equals("X-NO-ATOMIC-RENAME",
                            nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kNoHierarchyRename;
      else if (token.Equals("X-NON-HIERARCHICAL-RENAME",
                            nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kNoHierarchyRename;
      else if (token.Equals("NAMESPACE", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kNamespaceCapability;
      else if (token.Equals("ID", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasIDCapability;
      else if (token.Equals("ACL", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kACLCapability;
      else if (token.Equals("XSERVERINFO", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kXServerInfoCapability;
      else if (token.Equals("UIDPLUS", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kUidplusCapability;
      else if (token.Equals("LITERAL+", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kLiteralPlusCapability;
      else if (token.Equals("XAOL-OPTION", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kAOLImapCapability;
      else if (token.Equals("X-GM-EXT-1", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kGmailImapCapability;
      else if (token.Equals("QUOTA", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kQuotaCapability;
      else if (token.Equals("LANGUAGE", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasLanguageCapability;
      else if (token.Equals("IDLE", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasIdleCapability;
      else if (token.Equals("CONDSTORE", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasCondStoreCapability;
      else if (token.Equals("ENABLE", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasEnableCapability;
      else if (token.Equals("LIST-EXTENDED",
                            nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasListExtendedCapability;
      else if (token.Equals("XLIST", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasXListCapability;
      else if (token.Equals("SPECIAL-USE", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasSpecialUseCapability;
      else if (token.Equals("COMPRESS=DEFLATE",
                            nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasCompressDeflateCapability;
      else if (token.Equals("MOVE", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasMoveCapability;
      else if (token.Equals("HIGHESTMODSEQ",
                            nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasHighestModSeqCapability;
      else if (token.Equals("CLIENTID", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasClientIDCapability;
      else if (token.Equals("UTF8=ACCEPT",
                            nsCaseInsensitiveCStringComparator) ||
               token.Equals("UTF8=ONLY", nsCaseInsensitiveCStringComparator))
        fCapabilityFlag |= kHasUTF8AcceptCapability;
    }
  } while (fNextToken && endToken < 0 && !fAtEndOfLine && ContinueParse());

  nsImapProtocol* navCon = &fServerConnection;
  NS_ASSERTION(navCon,
               "null imap protocol connection while parsing capability "
               "response");  // we should always have this
  if (navCon) {
    navCon->CommitCapability();
    fServerConnection.SetCapabilityResponseOccurred();
  }
  skip_to_CRLF();
}

void nsImapServerResponseParser::xmailboxinfo_data() {
  AdvanceToNextToken();
  if (!fNextToken) return;

  char* mailboxName = CreateAstring();  // PL_strdup(fNextToken);
  if (mailboxName) {
    do {
      AdvanceToNextToken();
      if (fNextToken) {
        if (!PL_strcmp("MANAGEURL", fNextToken)) {
          AdvanceToNextToken();
          fFolderAdminUrl = CreateAstring();
        } else if (!PL_strcmp("POSTURL", fNextToken)) {
          AdvanceToNextToken();
          // ignore this for now...
        }
      }
    } while (fNextToken && !fAtEndOfLine && ContinueParse());
  }
}

void nsImapServerResponseParser::xserverinfo_data() {
  do {
    AdvanceToNextToken();
    if (!fNextToken) break;
    if (!PL_strcmp("MANAGEACCOUNTURL", fNextToken)) {
      AdvanceToNextToken();
      fMailAccountUrl.Adopt(CreateNilString());
    } else if (!PL_strcmp("MANAGELISTSURL", fNextToken)) {
      AdvanceToNextToken();
      fManageListsUrl.Adopt(CreateNilString());
    } else if (!PL_strcmp("MANAGEFILTERSURL", fNextToken)) {
      AdvanceToNextToken();
      fManageFiltersUrl.Adopt(CreateNilString());
    }
  } while (fNextToken && !fAtEndOfLine && ContinueParse());
}

void nsImapServerResponseParser::enable_data() {
  do {
    // eat each enable response;
    AdvanceToNextToken();
    if (!PL_strcasecmp("UTF8=ACCEPT", fNextToken)) fUtf8AcceptEnabled = true;
  } while (fNextToken && !fAtEndOfLine && ContinueParse());
}

void nsImapServerResponseParser::language_data() {
  // we may want to go out and store the language returned to us
  // by the language command in the host info session stuff.

  // for now, just eat the language....
  do {
    // eat each language returned to us
    AdvanceToNextToken();
  } while (fNextToken && !fAtEndOfLine && ContinueParse());
}

// cram/auth response data ::= "+" SPACE challenge CRLF
// the server expects more client data after issuing its challenge

void nsImapServerResponseParser::authChallengeResponse_data() {
  AdvanceToNextToken();
  fAuthChallenge = strdup(fNextToken);
  fWaitingForMoreClientInput = true;

  skip_to_CRLF();
}

void nsImapServerResponseParser::namespace_data() {
  EIMAPNamespaceType namespaceType = kPersonalNamespace;
  bool namespacesCommitted = false;
  const char* serverKey = fServerConnection.GetImapServerKey();
  while ((namespaceType != kUnknownNamespace) && ContinueParse()) {
    AdvanceToNextToken();
    while (fAtEndOfLine && ContinueParse()) AdvanceToNextToken();
    if (!PL_strcasecmp(fNextToken, "NIL")) {
      // No namespace for this type.
      // Don't add anything to the Namespace object.
    } else if (fNextToken[0] == '(') {
      // There may be multiple namespaces of the same type.
      // Go through each of them and add them to our Namespace object.

      fNextToken++;
      while (fNextToken[0] == '(' && ContinueParse()) {
        // we have another namespace for this namespace type
        fNextToken++;
        if (fNextToken[0] != '"') {
          SetSyntaxError(true);
        } else {
          char* namespacePrefix = CreateQuoted(false);

          AdvanceToNextToken();
          const char* quotedDelimiter = fNextToken;
          char namespaceDelimiter = '\0';

          if (quotedDelimiter[0] == '"') {
            quotedDelimiter++;
            namespaceDelimiter = quotedDelimiter[0];
          } else if (!PL_strncasecmp(quotedDelimiter, "NIL", 3)) {
            // NIL hierarchy delimiter.  Leave namespace delimiter nullptr.
          } else {
            // not quoted or NIL.
            SetSyntaxError(true);
          }
          if (ContinueParse()) {
            // Add code to parse the TRANSLATE attribute if it is present....
            // we'll also need to expand the name space code to take in the
            // translated prefix name.

            // Add it to a temporary list in the host.
            if (fHostSessionList) {
              nsImapNamespace* newNamespace = new nsImapNamespace(
                  namespaceType, namespacePrefix, namespaceDelimiter, false);
              fHostSessionList->AddNewNamespaceForHost(serverKey, newNamespace);
            }

            skip_to_close_paren();  // Ignore any extension data

            bool endOfThisNamespaceType = (fNextToken[0] == ')');
            if (!endOfThisNamespaceType &&
                fNextToken[0] !=
                    '(')  // no space between namespaces of the same type
            {
              SetSyntaxError(true);
            }
          }
          PR_Free(namespacePrefix);
        }
      }
    } else {
      SetSyntaxError(true);
    }
    switch (namespaceType) {
      case kPersonalNamespace:
        namespaceType = kOtherUsersNamespace;
        break;
      case kOtherUsersNamespace:
        namespaceType = kPublicNamespace;
        break;
      default:
        namespaceType = kUnknownNamespace;
        break;
    }
  }
  if (ContinueParse()) {
    nsImapProtocol* navCon = &fServerConnection;
    NS_ASSERTION(
        navCon,
        "null protocol connection while parsing namespace");  // we should
                                                              // always have
                                                              // this
    if (navCon) {
      navCon->CommitNamespacesForHostEvent();
      namespacesCommitted = true;
    }
  }
  skip_to_CRLF();

  if (!namespacesCommitted && fHostSessionList) {
    bool success;
    fHostSessionList->FlushUncommittedNamespacesForHost(serverKey, success);
  }
}

void nsImapServerResponseParser::myrights_data(bool unsolicited) {
  AdvanceToNextToken();
  if (ContinueParse() && !fAtEndOfLine) {
    char* mailboxName;
    // an unsolicited myrights response won't have the mailbox name in
    // the response, so we use the selected mailbox name.
    if (unsolicited) {
      mailboxName = strdup(fSelectedMailboxName);
    } else {
      mailboxName = CreateAstring();
      if (mailboxName) AdvanceToNextToken();
    }
    if (mailboxName) {
      if (ContinueParse()) {
        char* myrights = CreateAstring();
        if (myrights) {
          nsImapProtocol* navCon = &fServerConnection;
          NS_ASSERTION(
              navCon, "null connection parsing my rights");  // we should always
                                                             // have this
          if (navCon)
            navCon->AddFolderRightsForUser(mailboxName,
                                           nullptr /* means "me" */, myrights);
          PR_Free(myrights);
        } else {
          HandleMemoryFailure();
        }
        if (ContinueParse()) AdvanceToNextToken();
      }
      PR_Free(mailboxName);
    } else {
      HandleMemoryFailure();
    }
  } else {
    SetSyntaxError(true);
  }
}

void nsImapServerResponseParser::acl_data() {
  AdvanceToNextToken();
  if (ContinueParse() && !fAtEndOfLine) {
    char* mailboxName = CreateAstring();  // PL_strdup(fNextToken);
    if (mailboxName && ContinueParse()) {
      AdvanceToNextToken();
      while (ContinueParse() && !fAtEndOfLine) {
        char* userName = CreateAstring();  // PL_strdup(fNextToken);
        if (userName && ContinueParse()) {
          AdvanceToNextToken();
          if (ContinueParse()) {
            char* rights = CreateAstring();  // PL_strdup(fNextToken);
            if (rights) {
              fServerConnection.AddFolderRightsForUser(mailboxName, userName,
                                                       rights);
              PR_Free(rights);
            } else
              HandleMemoryFailure();

            if (ContinueParse()) AdvanceToNextToken();
          }
          PR_Free(userName);
        } else
          HandleMemoryFailure();
      }
      PR_Free(mailboxName);
    } else
      HandleMemoryFailure();
  }
}

// RFC2087:  quotaroot_response = "QUOTAROOT" SP astring *(SP astring)
//           quota_response = "QUOTA" SP astring SP quota_list
//           quota_list     = "(" [quota_resource *(SP quota_resource)] ")"
//           quota_resource = atom SP number SP number
// draft-melnikov-extra-quota-00 proposes some additions to RFC2087 and
// improves the documentation. We still only support RFC2087 capability QUOTA
// and command GETQUOTAROOT and its untagged QUOTAROOT and QUOTA responses.
void nsImapServerResponseParser::quota_data() {
  if (!PL_strcasecmp(fNextToken, "QUOTAROOT")) {
    // Ignore QUOTAROOT response (except to invalidate previously stored data).
    nsCString quotaroot;
    AdvanceToNextToken();
    while (ContinueParse() && !fAtEndOfLine) {
      quotaroot.Adopt(CreateAstring());
      AdvanceToNextToken();
    }
    // Invalidate any previously stored quota data. Updated QUOTA data follows.
    fServerConnection.UpdateFolderQuotaData(kInvalidateQuota, quotaroot, 0, 0);
  } else if (!PL_strcasecmp(fNextToken, "QUOTA")) {
    // Should have one QUOTA response per QUOTAROOT.
    uint64_t usage, limit;
    AdvanceToNextToken();
    if (ContinueParse()) {
      nsCString quotaroot;
      quotaroot.Adopt(CreateAstring());
      nsCString resource;
      AdvanceToNextToken();
      if (fNextToken) {
        if (fNextToken[0] == '(') fNextToken++;
        // Should have zero or more "resource|usage|limit" triplet per quotaroot
        // name. See draft-melnikov-extra-quota-00 for specific examples. Well
        // known resources are STORAGE (in Kbytes), number of MESSAGEs and
        // number of MAILBOXes. However, servers typically only set a quota on
        // STORAGE in KBytes. A mailbox can have multiple quotaroots but
        // typically only one and with a single resource.
        while (ContinueParse() && !fAtEndOfLine) {
          resource.Adopt(CreateAstring());
          AdvanceToNextToken();
          usage = atoll(fNextToken);
          AdvanceToNextToken();
          nsAutoCString limitToken(fNextToken);
          if (fNextToken[strlen(fNextToken) - 1] == ')')
            limitToken.SetLength(strlen(fNextToken) - 1);
          limit = atoll(limitToken.get());
          // Some servers don't define a quotaroot name which we displays as
          // blank.
          nsCString quotaRootResource(quotaroot);
          if (!quotaRootResource.IsEmpty()) {
            quotaRootResource.AppendLiteral(" / ");
          }
          quotaRootResource.Append(resource);
          fServerConnection.UpdateFolderQuotaData(
              kStoreQuota, quotaRootResource, usage, limit);
          AdvanceToNextToken();
        }
      }
    }
  } else {
    SetSyntaxError(true);
  }
}

void nsImapServerResponseParser::id_data() {
  AdvanceToNextToken();
  if (!PL_strcasecmp(fNextToken, "NIL"))
    AdvanceToNextToken();
  else
    fServerIdResponse.Adopt(CreateParenGroup());
  skip_to_CRLF();
}

bool nsImapServerResponseParser::GetDownloadingHeaders() {
  return fDownloadingHeaders;
}

void nsImapServerResponseParser::ResetCapabilityFlag() {}

/*
   literal ::= "{" number "}" CRLF *CHAR8
   Number represents the number of CHAR8 octets
 */

// Processes a message body, header or message part fetch response. Typically
// the full message, header or part are processed in one call (effectively, one
// chunk), and parameter `chunk` is false and `origin` (offset into the
// response) is 0. But under some conditions and larger messages, multiple calls
// will occur to process the message in multiple chunks and parameter `chunk`
// will be true and parameter `origin` will increase by the chunk size from
// initially 0 with each call. This function returns true if this is the last or
// only chunk. This signals the caller that the stream should be closed since
// the message response has been processed.
bool nsImapServerResponseParser::msg_fetch_literal(bool chunk, int32_t origin) {
  numberOfCharsInThisChunk = atoi(fNextToken + 1);
  // If we didn't request a specific size, or the server isn't returning exactly
  // as many octets as we requested, this must be the last or only chunk
  bool lastChunk = (!chunk || (numberOfCharsInThisChunk !=
                               fServerConnection.GetCurFetchSize()));

  // clang-format off
  if (lastChunk)
    MOZ_LOG(IMAP, mozilla::LogLevel::Debug,
            ("PARSER: msg_fetch_literal() chunking=%s, requested=%d, receiving=%d",
             chunk ? "true":"false", fServerConnection.GetCurFetchSize(),
             numberOfCharsInThisChunk));
  // clang-format on

  charsReadSoFar = 0;

  while (ContinueParse() && !fServerConnection.DeathSignalReceived() &&
         (charsReadSoFar < numberOfCharsInThisChunk)) {
    AdvanceToNextLine();
    if (ContinueParse()) {
      // When "\r\n" (CRLF) is split across two chunks, the '\n' at the
      // beginning of the next chunk might be set to an empty line consisting
      // only of "\r\n". This is observed while running unit tests with the imap
      // "fake" server. The unexpected '\r' is discarded here. However, with
      // several real world servers tested, e.g., Dovecot, Gmail, Outlook, Yahoo
      // etc., the leading
      // '\r' is not inserted so the beginning line of the next chunk remains
      // just '\n' and no discard is required.
      // In any case, this "orphan" line is ignored and not processed below.
      if (fNextChunkStartsWithNewline && (*fCurrentLine == '\r')) {
        // Cause fCurrentLine to point to '\n' which discards the '\r'.
        char* usableCurrentLine = PL_strdup(fCurrentLine + 1);
        PR_Free(fCurrentLine);
        fCurrentLine = usableCurrentLine;
      }

      // strlen() *would* fail on data containing \0, but the above
      // AdvanceToNextLine() in nsMsgLineStreamBuffer::ReadNextLine() we replace
      // '\0' with ' ' (blank) because who cares about binary transparency, and
      // anyway \0 in this context violates RFCs.
      charsReadSoFar += strlen(fCurrentLine);
      if (!fDownloadingHeaders && fCurrentCommandIsSingleMessageFetch) {
        fServerConnection.ProgressEventFunctionUsingName(
            "imapDownloadingMessage");
        if (fTotalDownloadSize > 0)
          fServerConnection.PercentProgressUpdateEvent(
              ""_ns, u""_ns, charsReadSoFar + origin, fTotalDownloadSize);
      }
      if (charsReadSoFar > numberOfCharsInThisChunk) {
        // This is the last line of a chunk. "Literal" here means actual email
        // data and its EOLs, without imap protocol elements and their EOLs. End
        // of line is defined by two characters \r\n (i.e., CRLF, 0xd,0xa)
        // specified by RFC822. Here is an example the most typical last good
        // line of a chunk: "1s8AA5i4AAvF4QAG6+sAAD0bAPsAAAAA1OAAC)\r\n", where
        // ")\r\n" are non-literals. This an example of the last "good" line of
        // a chunk that terminates with \r\n
        // "FxcA/wAAAALN2gADu80ACS0nAPpVVAD1wNAABF5YAPhAJgD31+QABAAAAP8oMQD+HBwA/umj\r\n"
        // followed by another line of non-literal data:
        // " UID 1004)\r\n". These two are concatenated into a single string
        // pointed to by fCurrentLine.  The extra "non-literal data" on the last
        // chunk line makes the charsReadSoFar greater than
        // numberOfCharsInThisChunk (the configured chunk size). A problem
        // occurs if the \r\n of the long line above is split between chunks and
        // \n is contained in the next chunk. For example, if last lines of
        // chunk X are:
        // "/gAOC/wA/QAAAAAAAAAA8wACCvz+AgIEAAD8/P4ABQUAAPoAAAD+AAEA/voHAAQGBQD/BAQA\r"
        // ")\r\n"
        // and the first two lines of chunk X+1 are:
        // "\n"
        // "APwAAAAAmZkA/wAAAAAREQD/AAAAAquVAAbk8QAHCBAAAPD0AAP5+wABRCoA+0BgAP0AAAAA\r\n"
        // The missing '\n' on the last line of chunk X must be added back and
        // the line consisting only of "\n" in chunk X+1 must be ignored in
        // order to produce the the correct output. This is needed to insure
        // that the signature verification of cryptographically signed emails
        // does not fail due to missing or extra EOL characters. Otherwise, the
        // extra or missing \n or \r  doesn't really matter.
        //
        // Special case observed only with the "fake" imap server used with TB
        // unit test.  When the "\r\n" at the end of a chunk is split as
        // described above, the \n at the beginning of the next chunk may
        // actually be "\r\n" like this example: Last lines of chunk X
        // "/gAOC/wA/QAAAAAAAAAA8wACCvz+AgIEAAD8/P4ABQUAAPoAAAD+AAEA/voHAAQGBQD/BAQA\r"
        // ")\r\n"
        // and the first two lines of chunk X+1:
        // "\r\n"   <-- The code changes this to just "\n" like it should be.
        // "APwAAAAAmZkA/wAAAAAREQD/AAAAAquVAAbk8QAHCBAAAPD0AAP5+wABRCoA+0BgAP0AAAAA\r\n"
        //
        // Implementation:
        // Obtain pointer to last literal in chunk X, e.g., 'C' in 1st example
        // above, or to the \n or \r in the other examples.
        char* displayEndOfLine =
            (fCurrentLine + strlen(fCurrentLine) -
             (charsReadSoFar - numberOfCharsInThisChunk + 1));
        // Save so original unmodified fCurrentLine is restored below.
        char saveit1 = displayEndOfLine[1];
        char saveit2 = 0;  // Keep compiler happy.
        // Determine if EOL is split such that Chunk X has the \r and chunk
        // X+1 has the \n.
        fNextChunkStartsWithNewline = (displayEndOfLine[0] == '\r');
        if (fNextChunkStartsWithNewline) {
          saveit2 = displayEndOfLine[2];
          // Add the missing newline and terminate the string.
          displayEndOfLine[1] = '\n';
          displayEndOfLine[2] = 0;
          // This is a good thing to log.
          MOZ_LOG(IMAP, mozilla::LogLevel::Info,
                  ("PARSER: CR/LF split at chunk boundary"));
        } else {
          // Typical case where EOLs are not split. Terminate the string.
          displayEndOfLine[1] = 0;
        }
        // Process this modified string pointed to by fCurrentLine.
        fServerConnection.HandleMessageDownLoadLine(fCurrentLine, !lastChunk);
        // Restore fCurrentLine's original content.
        displayEndOfLine[1] = saveit1;
        if (fNextChunkStartsWithNewline) displayEndOfLine[2] = saveit2;
      } else {
        // Not the last line of a chunk.
        bool processTheLine = true;
        if (fNextChunkStartsWithNewline && origin > 0) {
          // A split of the \r\n between chunks was detected. Ignore orphan \n
          // on line by itself which can occur on the first line of a 2nd or
          // later chunk. Line length should be 1 and the only character should
          // be \n. Note: If previous message ended with just \r, don't expect
          // the first chunk of a message (origin == 0) to begin with \n.
          // (Typically, there is only one chunk required for a message or
          // header response unless its size exceeds the chunking threshold.)
          if (strlen(fCurrentLine) > 1 || fCurrentLine[0] != '\n') {
            // In case expected orphan \n is not really there, go ahead and
            // process the line. This should theoretically not occur but rarely,
            // and for yet to be determined reasons, it does. Logging may help.
            NS_WARNING(
                "'\\n' is not the only character in this line as expected!");
            MOZ_LOG(IMAP, mozilla::LogLevel::Debug,
                    ("PARSER: expecting just '\\n' but line is = |%s|",
                     fCurrentLine));
          } else {
            // Discard the line containing only \n.
            processTheLine = false;
            MOZ_LOG(IMAP, mozilla::LogLevel::Debug,
                    ("PARSER: discarding lone '\\n'"));
          }
        }
        if (processTheLine) {
          fServerConnection.HandleMessageDownLoadLine(
              fCurrentLine,
              !lastChunk && (charsReadSoFar == numberOfCharsInThisChunk),
              fCurrentLine);
        }
        fNextChunkStartsWithNewline = false;
      }
    }
  }

  if (ContinueParse()) {
    if (charsReadSoFar > numberOfCharsInThisChunk) {
      // move the lexical analyzer state to the end of this message because this
      // message fetch ends in the middle of this line.
      AdvanceTokenizerStartingPoint(
          strlen(fCurrentLine) - (charsReadSoFar - numberOfCharsInThisChunk));
      AdvanceToNextToken();
    } else {
      skip_to_CRLF();
      AdvanceToNextToken();
    }
  } else {
    // Don't typically (maybe never?) see this.
    fNextChunkStartsWithNewline = false;
  }
  return lastChunk;
}

bool nsImapServerResponseParser::CurrentFolderReadOnly() {
  return fCurrentFolderReadOnly;
}

int32_t nsImapServerResponseParser::NumberOfMessages() {
  return fNumberOfExistingMessages;
}

int32_t nsImapServerResponseParser::NumberOfRecentMessages() {
  return fNumberOfRecentMessages;
}

int32_t nsImapServerResponseParser::FolderUID() { return fFolderUIDValidity; }

void nsImapServerResponseParser::SetCurrentResponseUID(uint32_t uid) {
  if (uid > 0) fCurrentResponseUID = uid;
}

uint32_t nsImapServerResponseParser::CurrentResponseUID() {
  return fCurrentResponseUID;
}

uint32_t nsImapServerResponseParser::HighestRecordedUID() {
  return fHighestRecordedUID;
}

void nsImapServerResponseParser::ResetHighestRecordedUID() {
  fHighestRecordedUID = 0;
}

bool nsImapServerResponseParser::IsNumericString(const char* string) {
  int i;
  for (i = 0; i < (int)PL_strlen(string); i++) {
    if (!isdigit(string[i])) {
      return false;
    }
  }

  return true;
}

// Capture the mailbox state for folder select/update and for status.
// If mailboxName is null, we've done imap SELECT; otherwise STATUS.
already_AddRefed<nsImapMailboxSpec>
nsImapServerResponseParser::CreateCurrentMailboxSpec(
    const char* mailboxName /* = nullptr */) {
  RefPtr<nsImapMailboxSpec> returnSpec = new nsImapMailboxSpec;
  const char* mailboxNameToConvert =
      (mailboxName) ? mailboxName : fSelectedMailboxName;
  if (mailboxNameToConvert) {
    const char* serverKey = fServerConnection.GetImapServerKey();
    nsImapNamespace* ns = nullptr;
    if (serverKey && fHostSessionList)
      fHostSessionList->GetNamespaceForMailboxForHost(
          serverKey, mailboxNameToConvert, ns);  // for
    // delimiter
    returnSpec->mHierarchySeparator = (ns) ? ns->GetDelimiter() : '/';
  }

  returnSpec->mFolderSelected = !mailboxName;
  returnSpec->mFolder_UIDVALIDITY = fFolderUIDValidity;
  returnSpec->mHighestModSeq = fHighestModSeq;
  // clang-format off
  returnSpec->mNumOfMessages =
      (mailboxName) ? fStatusExistingMessages : fNumberOfExistingMessages;
  returnSpec->mNumOfUnseenMessages =
      (mailboxName) ? fStatusUnseenMessages : -1;
  returnSpec->mNumOfRecentMessages =
      (mailboxName) ? fStatusRecentMessages : fNumberOfRecentMessages;
  returnSpec->mNextUID =
      (mailboxName) ? fStatusNextUID : fNextUID;
  // clang-format on

  returnSpec->mSupportedUserFlags = fSupportsUserDefinedFlags;

  returnSpec->mBoxFlags = kNoFlags;     // stub
  returnSpec->mOnlineVerified = false;  // Fabricated. Flags aren't verified.
  returnSpec->mAllocatedPathName.Assign(mailboxNameToConvert);
  returnSpec->mConnection = &fServerConnection;
  if (returnSpec->mConnection) {
    nsIURI* aUrl = nullptr;
    nsresult rv = NS_OK;
    returnSpec->mConnection->GetCurrentUrl()->QueryInterface(NS_GET_IID(nsIURI),
                                                             (void**)&aUrl);
    if (NS_SUCCEEDED(rv) && aUrl) aUrl->GetHost(returnSpec->mHostName);

    NS_IF_RELEASE(aUrl);
  } else
    returnSpec->mHostName.Truncate();

  if (fFlagState)
    returnSpec->mFlagState = fFlagState;  // copies flag state
  else
    returnSpec->mFlagState = nullptr;

  return returnSpec.forget();
}
// Reset the flag state.
void nsImapServerResponseParser::ResetFlagInfo() {
  if (fFlagState) fFlagState->Reset();
}

bool nsImapServerResponseParser::GetLastFetchChunkReceived() {
  return fLastChunk;
}

void nsImapServerResponseParser::ClearLastFetchChunkReceived() {
  fLastChunk = false;
}

int32_t nsImapServerResponseParser::GetNumBytesFetched() {
  return numberOfCharsInThisChunk;
}

void nsImapServerResponseParser::ClearNumBytesFetched() {
  numberOfCharsInThisChunk = 0;
}

void nsImapServerResponseParser::SetHostSessionList(
    nsIImapHostSessionList* aHostSessionList) {
  fHostSessionList = aHostSessionList;
}

void nsImapServerResponseParser::SetSyntaxError(bool error, const char* msg) {
  nsImapGenericParser::SetSyntaxError(error, msg);
  if (error) {
    if (!fCurrentLine) {
      HandleMemoryFailure();
      fServerConnection.Log("PARSER", ("Internal Syntax Error: %s: <no line>"),
                            msg);
    } else {
      if (!strcmp(fCurrentLine, CRLF))
        fServerConnection.Log("PARSER", "Internal Syntax Error: %s: <CRLF>",
                              msg);
      else {
        if (msg)
          fServerConnection.Log("PARSER", "Internal Syntax Error: %s:", msg);
        fServerConnection.Log("PARSER", "Internal Syntax Error on line: %s",
                              fCurrentLine);
      }
    }
  }
}

nsresult nsImapServerResponseParser::BeginMessageDownload(
    const char* content_type) {
  nsresult rv = fServerConnection.BeginMessageDownLoad(fSizeOfMostRecentMessage,
                                                       content_type);
  if (NS_FAILED(rv)) {
    skip_to_CRLF();
    fServerConnection.PseudoInterrupt(true);
    fServerConnection.AbortMessageDownLoad();
  }
  return rv;
}