Open Source Projects Europe

 */

 */

#ifdef HAVE_CONFIG_H

#ifdef HAVE_CONFIG_H

#include <config.h>

#include <config.h>

#endif

#endif

#include <string>

#include <string>

#include <vector>

#include <vector>

#include <map>

#include <map>

#include <exception>

#include <exception>

#include <iostream>

#include <iostream>

#ifndef NO_NAMESPACES

#ifndef NO_NAMESPACES

using namespace ::std;

using namespace ::std;

#endif /* NO_NAMESPACES */

#endif /* NO_NAMESPACES */

#ifdef MPF

#ifdef MPF

#define MPFDEB(X) fprintf X

#define MPFDEB(X) fprintf X

#else

#else

#define MPFDEB(X)

#define MPFDEB(X)

#endif

#endif

//------------------------------------------------------------------------

//------------------------------------------------------------------------

void Binc::MimeDocument::parseFull(int fd)

{

{

  if (allIsParsed)

  if (allIsParsed)

    return;

    return;

  allIsParsed = true;

  allIsParsed = true;

  headerstartoffsetcrlf = 0;

  headerstartoffsetcrlf = 0;

  headerlength = 0;

  headerlength = 0;

  bodystartoffsetcrlf = 0;

  bodystartoffsetcrlf = 0;

  bodylength = 0;

  bodylength = 0;

  messagerfc822 = false;

  messagerfc822 = false;

  multipart = false;

  multipart = false;

  int bsize = 0;

  int bsize = 0;

  string bound;

  string bound;

  doParseFull(bound, bsize);

  // eat any trailing junk to get the correct size

  // eat any trailing junk to get the correct size

  char c;

  char c;

  while (mimeSource->getChar(&c));

  size = mimeSource->getOffset();

}

}

void Binc::MimeDocument::parseFull(istream& s)

{

{

  if (allIsParsed)

  if (allIsParsed)

    return;

    return;

  allIsParsed = true;

  allIsParsed = true;

  delete mimeSource;

  mimeSource = new MimeInputSourceStream(s);

  headerstartoffsetcrlf = 0;

  headerstartoffsetcrlf = 0;

  headerlength = 0;

  headerlength = 0;

  bodystartoffsetcrlf = 0;

  bodystartoffsetcrlf = 0;

  bodylength = 0;

  bodylength = 0;

  messagerfc822 = false;

  messagerfc822 = false;

  multipart = false;

  multipart = false;

  int bsize = 0;

  int bsize = 0;

  string bound;

  string bound;

  doParseFull(bound, bsize);

  // eat any trailing junk to get the correct size

  // eat any trailing junk to get the correct size

  char c;

  char c;

  while (mimeSource->getChar(&c));

  size = mimeSource->getOffset();

}

}

//------------------------------------------------------------------------

//------------------------------------------------------------------------

{

{

  using namespace ::Binc;

  using namespace ::Binc;

  char c;

  char c;

  bool eof = false;

  bool eof = false;

  char cqueue[4];

  char cqueue[4];

  return !(eof || endOfHeaders);

  return !(eof || endOfHeaders);

}

}

//------------------------------------------------------------------------

//------------------------------------------------------------------------

{

{

  while (parseOneHeaderLine(header, nlines))

  while (parseOneHeaderLine(header, nlines))

  { }

  { }

}

}

//------------------------------------------------------------------------

//------------------------------------------------------------------------

              bool *messagerfc822, string *subtype,

              string *boundary)

{

{

  using namespace ::Binc;

  using namespace ::Binc;

  // Do simple parsing of headers to determine the

  // Do simple parsing of headers to determine the

  // type of message (multipart,messagerfc822 etc)

  // type of message (multipart,messagerfc822 etc)

      }

      }

    }

    }

  }

  }

}

}

{

{

  using namespace ::Binc;

  using namespace ::Binc;

  // message rfc822 means a completely enclosed mime document. we

  // message rfc822 means a completely enclosed mime document. we

  // call the parser recursively, and pass on the boundary string

  // call the parser recursively, and pass on the boundary string

  unsigned int bodystartoffsetcrlf = mimeSource->getOffset();

  unsigned int bodystartoffsetcrlf = mimeSource->getOffset();

  // parsefull returns the number of bytes that need to be removed

  // parsefull returns the number of bytes that need to be removed

  // from the body because of the terminating boundary string.

  // from the body because of the terminating boundary string.

  int bsize = 0;

  int bsize = 0;

  if (m.doParseFull(toboundary, bsize))

    *foundendofpart = true;

    *foundendofpart = true;

  // make sure bodylength doesn't overflow    

  // make sure bodylength doesn't overflow    

  *bodylength = mimeSource->getOffset();

  *bodylength = mimeSource->getOffset();

  if (*bodylength >= bodystartoffsetcrlf) {

  if (*bodylength >= bodystartoffsetcrlf) {

  *nbodylines += m.getNofLines();

  *nbodylines += m.getNofLines();

  members->push_back(m);

  members->push_back(m);

}

}

                  unsigned int *nlines, bool *eof)

{

{

  int endpos = delimiter.length();

  int endpos = delimiter.length();

  char *delimiterqueue = 0;

  char *delimiterqueue = 0;

  int delimiterpos = 0;

  int delimiterpos = 0;

  const char *delimiterStr = delimiter.c_str();

  const char *delimiterStr = delimiter.c_str();

// JFD: Things we do after finding a boundary (something like CRLF--somestring)

// JFD: Things we do after finding a boundary (something like CRLF--somestring)

// Need to see if this is a final one (with an additional -- at the end),

// Need to see if this is a final one (with an additional -- at the end),

// and need to check if it is immediately followed by another boundary 

// and need to check if it is immediately followed by another boundary 

// (in this case, we give up our final CRLF in its favour)

// (in this case, we give up our final CRLF in its favour)

                      unsigned int *nlines,

                      int *boundarysize,

                      bool *foundendofpart)

{

{

    // Read two more characters. This may be CRLF, it may be "--" and

    // Read two more characters. This may be CRLF, it may be "--" and

    // it may be any other two characters.

    // it may be any other two characters.

    char a = '\0';

    char a = '\0';

    if (!mimeSource->getChar(&a))

    if (!mimeSource->getChar(&a))

      mimeSource->ungetChar();

      mimeSource->ungetChar();

      mimeSource->ungetChar();

      mimeSource->ungetChar();

    }

    }

}

}

               const string &toboundary,

               bool *eof,

               unsigned int *nlines,

               int *boundarysize,

               bool *foundendofpart,

               unsigned int *bodylength,

               vector<Binc::MimePart> *members)

{

{

  MPFDEB((stderr, "BINC: ParseMultipart: boundary [%s], toboundary[%s]\n", 

  MPFDEB((stderr, "BINC: ParseMultipart: boundary [%s], toboundary[%s]\n", 

      boundary.c_str(),

      boundary.c_str(),

      toboundary.c_str()));

      toboundary.c_str()));

  using namespace ::Binc;

  using namespace ::Binc;

      MimePart m;

      MimePart m;

      // If parseFull returns != 0, then it encountered the multipart's

      // If parseFull returns != 0, then it encountered the multipart's

      // final boundary.

      // final boundary.

      int bsize = 0;

      int bsize = 0;

      if (m.doParseFull(boundary, bsize)) {

    quit = true;

    quit = true;

    *boundarysize = bsize;

    *boundarysize = bsize;

      }

      }

      members->push_back(m);

      members->push_back(m);

    *bodylength = 0;

    *bodylength = 0;

  }

  }

  MPFDEB((stderr, "BINC: ParseMultipart return\n"));

  MPFDEB((stderr, "BINC: ParseMultipart return\n"));

}

}

                int *boundarysize,

                int *boundarysize,

                unsigned int *nbodylines,

                unsigned int *nbodylines,

                unsigned int *nlines,

                unsigned int *nlines,

                bool *eof, bool *foundendofpart,

                bool *eof, bool *foundendofpart,

                unsigned int *bodylength)

                unsigned int *bodylength)

  MPFDEB((stderr, "BINC: parseSimple ret: bodylength %d, boundarysize %d\n",

  MPFDEB((stderr, "BINC: parseSimple ret: bodylength %d, boundarysize %d\n",

      *bodylength, *boundarysize));

      *bodylength, *boundarysize));

}

}

//------------------------------------------------------------------------

//------------------------------------------------------------------------

int Binc::MimePart::doParseFull(const string &toboundary,

{

{

  MPFDEB((stderr, "BINC: doParsefull, toboundary[%s]\n", toboundary.c_str()));

  MPFDEB((stderr, "BINC: doParsefull, toboundary[%s]\n", toboundary.c_str()));

  headerstartoffsetcrlf = mimeSource->getOffset();

  headerstartoffsetcrlf = mimeSource->getOffset();

  // Parse the header of this mime part.

  // Parse the header of this mime part.

  parseHeader(&h, &nlines);

  parseHeader(&h, &nlines);

  // Headerlength includes the seperating CRLF. Body starts after the

  // Headerlength includes the seperating CRLF. Body starts after the

  // CRLF.

  // CRLF.

  headerlength = mimeSource->getOffset() - headerstartoffsetcrlf;

  headerlength = mimeSource->getOffset() - headerstartoffsetcrlf;

  bodystartoffsetcrlf = mimeSource->getOffset();

  bodystartoffsetcrlf = mimeSource->getOffset();

  bodylength = 0;

  bodylength = 0;

  // Determine the type of mime part by looking at fields in the

  // Determine the type of mime part by looking at fields in the

  // header.

  // header.

  analyzeHeader(&h, &multipart, &messagerfc822, &subtype, &boundary);

  analyzeHeader(&h, &multipart, &messagerfc822, &subtype, &boundary);