pop3.cxx

Go to the documentation of this file.

//
// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.
//
// Warning:  not all files in this directory structure are covered by the
// same copyright.  Some of them are part of the GNU source distribution
// and you must obey the GPL copyright for those files.


#include <pop3.h>
#include <libspopc.h>
#include <stdlib.h>
#include <stdio.h>
#include <cxxtls/strtool.h>
#include <vector>

using namespace cxxtls;

typedef StrTool::stringlist_t  stringlist;


struct POP3::Impl
{
   popsession *session_;
   int         status_;

   std::vector<POP3::Message*> messages_;
   std::vector<POP3::User*>    users_;

   char const* fetch_messages();

};

POP3::
POP3()
: impl_( new Impl )
{
  impl_->status_        = not_connected;
  impl_->session_       = 0;
}

POP3::
~POP3()
{
  if(impl_->status_ == connected)
  {
    disconnect();
  }

  size_t i;

  for(i=0; i < impl_->messages_.size(); ++i)
    delete impl_->messages_[i];

  for(i=0; i < impl_->users_.size(); ++i)
    delete impl_->users_[i];


  delete impl_;
}

char const *
POP3::
connect( string server,
         string user,
         string password
       )
{
  //
  //  Connect to the server and download all messages without deleting them
  //

  if(impl_->status_ == connected )
    return 0;

  char const *error = popbegin(server.c_str(),
                               user.c_str(),
                               password.c_str(),
                               &impl_->session_
                              );

  if(error)
    impl_->status_ = connect_failed;
  else
  {
    impl_->status_ = connected;

    error = impl_->fetch_messages();

  }

  return error;
}

void
POP3::
disconnect()
{
  if(impl_->status_ == connected)
  {
    popend(impl_->session_);
  }

  impl_->status_ = not_connected;

}

size_t
POP3::
messages() const
{
  return impl_->messages_.size();
}

int
POP3::
connect_status() const
{
  return impl_->status_;
}

char const *
POP3::message_header(size_t message_index, Header** h)
{

  if(message_index > messages())
    return "No such message";

  *h = &impl_->messages_[message_index]->header_;

  return 0;
}

char const *
POP3::message_body(size_t message_index, Body** b)
{

  if(message_index > messages())
    return "No such message";

  *b = &impl_->messages_[message_index]->body_;

  return 0;
}


static void cleanse_lines(std::list<std::string> &strings, bool handle_continuations=true)
{
  // remove trailing \r's and combine
  // lines beginning with tabs with their predecessors

  // Remove trailing \r's and concatenate lines beginning with tab to
  // their immediate predecessor -- unless told not to.

  {
    int line_count=0;

    stringlist::iterator first = strings.begin(),
                         last  = strings.end();
                
    while(first != last)
    {
       ++line_count;

       std::string& cur = *first;

       // remove trailing \r

       if(cur.size() && cur[cur.size()-1] == '\r')
       {
         cur.erase( cur.size()-1 );
       }


       if(handle_continuations &&
          line_count != 1      &&
          (cur[0] == '\t' || cur[0] == ' ')
         )
       {
         // this is a line continuation, append it to previous line
         // and delete it.

         stringlist::iterator prev = first;  --prev;

         (*prev) += ' ';
         (*prev) += cur;

         prev = first;

         ++first;

         strings.erase(prev);

       }
       else
       {
         ++first;
       }

    }

  }
}


char const *
POP3::Impl::
fetch_messages()
{
  // read all the messages from the server without deleting them.  Split the
  // headers, bodies, options, etc into sections for easy display.

  int i;

  int message_count = popnum(session_);

  for(i=0; i < message_count; ++i)
  {
    //
    //  Read the header for the named message, and if said message
    //  exists, read its body.  Removing trailing \r's from the records
    //  and concatenate lines beginning with tabs to their immediate
    //  predecessor.
    //
    char *msg = popgethead(session_, i+1);   // one based number

    if(msg)
    {
      POP3::Message *m = new POP3::Message;

      messages_.push_back(m);

      stringlist strings;

      StrTool::parse_lines(msg, &strings);

      m->header_.id_ = popmsguid(session_,i+1);

      free(msg);

      cleanse_lines(strings);

      // now split the lines of the header into the
      // fields in the header

      stringlist::iterator first = strings.begin(),
                           last  = strings.end();
                        
      while(first != last)
      {
        FileName cur = *first++;
        
        if(  cur.matches("[sS]ubject:*"))
        {
          cur.erase(0,8);
          m->header_.subject_ = cur;
        }
        else
        if(cur.matches("[dD]ate:*"))
        {
          cur.erase(0,6);
          m->header_.date_ = static_cast<std::string const &>(cur);
        }
        else
        if(cur.matches("[fF]rom:*"))
        {
          cur.erase(0,6);

          stringlist fromlist;

          StrTool::parse_words(cur, &fromlist);

          stringlist::iterator ufirst = fromlist.begin(),
                               ulast  = fromlist.end();


        
          while(ufirst != ulast)
          {
            string& u = *ufirst++;
        
            m->header_.from_.push_back(u);
          }

        }
        else
        if(cur.matches("[tT]o:*"))
        {
          cur.erase(0,4);
          stringlist fromlist;

          StrTool::parse_words(cur, &fromlist);

          stringlist::iterator ufirst = fromlist.begin(),
                               ulast  = fromlist.end();


        
          while(ufirst != ulast)
          {
            string& u = *ufirst++;
        
            m->header_.to_.push_back(u);
          }
        }
        else
        if(cur.matches("[Bb]cc:*"))
        {
          cur.erase(0,5);
          stringlist fromlist;

          StrTool::parse_words(cur, &fromlist);

          stringlist::iterator ufirst = fromlist.begin(),
                               ulast  = fromlist.end();


        
          while(ufirst != ulast)
          {
            string& u = *ufirst++;
        
            m->header_.bcc_.push_back(u);
          }
        }
        
      }

      // now split the body into lines

      msg = popgetmsg(session_, i+1);

      if(msg)
      {
        StrTool::parse_lines(msg, &m->body_.lines_);
        
        free(msg);
        
      }

      // now split the options out the body into the header
      // That is, find the first empty line after the beginning of the
      // body, potentially including the first line.  The empty line
      // terminates the options and begins the real data

      for(;;)
      {
        stringlist &body = m->body_.lines_;
        
        stringlist::iterator first = body.begin(),
                             last  = body.end();
                        
        if(first == last)
          break;
        
        string &first_line = body.front();
        
        if(first_line == "\r")
          break;
        
        m->header_.options_.push_back(first_line);

        body.erase( first );
      }

      // options have been deleted, the first line should be 0 length

      if(m->body_.lines_.begin() != m->body_.lines_.end())
      {
        if(m->body_.lines_.begin() != m->body_.lines_.end())
        {
          m->body_.lines_.erase( m->body_.lines_.begin() );
        }
      }

      cleanse_lines(m->header_.options_);
      cleanse_lines(m->body_.lines_, false);


    }
  }

  return 0;

}