bincimap

operator-copy.cc (5906B)

---

 /* -*- Mode: c++; -*- */
 /*  --------------------------------------------------------------------
  *  Filename:
  *    operator-copy.cc
  *  
  *  Description:
  *    Implementation of the COPY command.
  *
  *  Authors:
  *    Andreas Aardal Hanssen <andreas-binc curly bincimap spot org>
  *
  *  Bugs:
  *
  *  ChangeLog:
  *
  *  --------------------------------------------------------------------
  *  Copyright 2002-2005 Andreas Aardal Hanssen
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
  *  --------------------------------------------------------------------
  */
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include <string>
 
 #include "depot.h"
 #include "io.h"
 #include "maildir.h"
 #include "operators.h"
 #include "recursivedescent.h"
 #include "session.h"
 #include "convert.h"
 
 using namespace ::std;
 using namespace Binc;
 
 //----------------------------------------------------------------------
 CopyOperator::CopyOperator(void)
 {
 }
 
 //----------------------------------------------------------------------
 CopyOperator::~CopyOperator(void)
 {
 }
 
 //----------------------------------------------------------------------
 const string CopyOperator::getName(void) const
 {
   return "COPY";
 }
 
 //----------------------------------------------------------------------
 int CopyOperator::getState(void) const
 {
   return Session::SELECTED;
 }
 
 //------------------------------------------------------------------------
 Operator::ProcessResult CopyOperator::process(Depot &depot,
 					      Request &command)
 {
   Session &session = Session::getInstance();
   IO &logger = IOFactory::getInstance().get(2);
 
   // Get the current mailbox
   Mailbox *srcMailbox = depot.getSelected();
 
   // Get the destination mailbox
   string dmailbox = command.getMailbox();
   Mailbox *destMailbox = depot.get(toCanonMailbox(dmailbox));
   if (destMailbox == 0) {
     session.setResponseCode("TRYCREATE");
     session.setLastError("invalid mailbox " + toImapString(dmailbox));
     return NO;
   }
 
   unsigned int mode = Mailbox::SKIP_EXPUNGED;
   mode |= command.getUidMode() ? Mailbox::UID_MODE : Mailbox::SQNR_MODE;
 
   // Copy each message in the sequence set to the destination mailbox.
   bool success = true;
   Mailbox::iterator i = srcMailbox->begin(command.bset, mode);
   for (; success && i != srcMailbox->end(); ++i) {
     Message &source = *i;
 
     if (srcMailbox->fastCopy(source, *destMailbox,
 			     depot.mailboxToFilename(toCanonMailbox(dmailbox))))
       continue;
 
     // Have the destination mailbox create a message for us.
     Message *dest 
       = destMailbox->createMessage(depot.mailboxToFilename(toCanonMailbox(dmailbox)),
 				   source.getInternalDate());
     if (!dest) {
       session.setLastError(destMailbox->getLastError());
       success = false;
       break;
     }
 
     // Set the flags and internal date.
     dest->setStdFlag(source.getStdFlags());
     dest->setInternalDate(source.getInternalDate());
 
     // Reset the read position to the beginning of the source message
     source.rewind();
 
     // Copy chunks from the source message over to the destination
     // message.
     string chunk;
     do {
       int readSize = source.readChunk(chunk);
 
       if (readSize == 0)
 	break;
       else if (readSize == -1) {
 	logger << "when reading from message "
 	       << i.getSqnr() << "/" << source.getUID()
 	       << " in \"" << srcMailbox->getName() << "\": "
 	       << source.getLastError() << endl;
 	success = false;
       } else if (!dest->appendChunk(chunk)) {
 	logger << "when writing to \""
 	       << dmailbox << "\": "
 	       << dest->getLastError() << endl;
 	success = false;
       }
     } while (success);
 
     dest->close();
   }
 
   if (!success && !destMailbox->rollBackNewMessages()) {
     session.setLastError("Failed to rollback after unsuccessful copy: "
 			 + destMailbox->getLastError());
     return NO;
   }
 
   if (success)
     if (!destMailbox->commitNewMessages(depot.mailboxToFilename(toCanonMailbox(dmailbox)))) {
       session.setLastError("Failed to commit after successful copy: "
 			   + destMailbox->getLastError());
       return NO;
     }
 
   if (!success)
     session.setLastError("The transaction was unrolled. Please "
 			 "contant your system administrator for "
 			 "more information.");
 
   return success ? OK : NO;
 }
 
 //------------------------------------------------------------------------
 Operator::ParseResult CopyOperator::parse(Request &c_in) const
 {
   Session &session = Session::getInstance();
 
   Operator::ParseResult res;
   if ((res = expectSPACE()) != ACCEPT) {
     session.setLastError("Expected SPACE after COPY");
     return res;
   }
 
   if ((res = expectSet(c_in.getSet())) != ACCEPT) {
     session.setLastError("Expected sequence set after COPY SPACE");
     return res;
   }
 
   if ((res = expectSPACE()) != ACCEPT) {
     session.setLastError("Expected SPACE after COPY SPACE set");
     return res;
   }
 
   string mailbox;
   if ((res = expectMailbox(mailbox)) != ACCEPT) {
     session.setLastError("Expected mailbox after COPY SPACE set SPACE");
     return res;
   }
 
   if ((res = expectCRLF()) != ACCEPT) {
     session.setLastError("Expected CRLF after COPY SPACE set SPACE mailbox");
     return res;
   }
 
   c_in.setMailbox(mailbox);
   c_in.setName("COPY");
 
   return ACCEPT;
 }