--- a
+++ b/src/bincimapmime/mime-parsefull.cc
@@ -0,0 +1,666 @@
+/* -*- Mode: c++; -*- */
+/*  --------------------------------------------------------------------
+ *  Filename:
+ *    mime-parsefull.cc
+ *  
+ *  Description:
+ *    Implementation of main mime parser components
+ *  --------------------------------------------------------------------
+ *  Copyright 2002-2004 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 "mime.h"
+#include "mime-utils.h"
+#include "mime-inputsource.h"
+#include "convert.h"
+#include <string>
+#include <vector>
+#include <map>
+#include <exception>
+#include <iostream>
+
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <errno.h>
+
+Binc::MimeInputSource *mimeSource = 0;
+
+using namespace ::std;
+
+//------------------------------------------------------------------------
+void Binc::MimeDocument::parseFull(int fd) const
+{
+  if (allIsParsed)
+    return;
+
+  allIsParsed = true;
+
+  if (!mimeSource || mimeSource->getFileDescriptor() != fd) {
+    delete mimeSource;
+    mimeSource = new MimeInputSource(fd);
+  } else {
+    mimeSource->reset();
+  }
+
+  headerstartoffsetcrlf = 0;
+  headerlength = 0;
+  bodystartoffsetcrlf = 0;
+  bodylength = 0;
+  size = 0;
+  messagerfc822 = false;
+  multipart = false;
+
+  int bsize = 0;
+  string bound;
+  MimePart::parseFull(bound, bsize);
+
+  // eat any trailing junk to get the correct size
+  char c;
+  while (mimeSource->getChar(&c));
+
+  size = mimeSource->getOffset();
+}
+
+//------------------------------------------------------------------------
+static bool parseOneHeaderLine(Binc::Header *header, unsigned int *nlines)
+{
+  using namespace ::Binc;
+  char c;
+  bool eof = false;
+  char cqueue[4];
+  string name;
+  string content;
+
+  while (mimeSource->getChar(&c)) {
+    // If we encounter a \r before we got to the first ':', then
+    // rewind back to the start of the line and assume we're at the
+    // start of the body.
+    if (c == '\r') {
+      for (int i = 0; i < (int) name.length() + 1; ++i)
+	mimeSource->ungetChar();
+      return false;
+    }
+
+    // A colon marks the end of the header name
+    if (c == ':') break;
+
+    // Otherwise add to the header name
+    name += c;
+  }
+
+  cqueue[0] = '\0';
+  cqueue[1] = '\0';
+  cqueue[2] = '\0';
+  cqueue[3] = '\0';
+
+  // Read until the end of the header.
+  bool endOfHeaders = false;
+  while (!endOfHeaders) {
+    if (!mimeSource->getChar(&c)) {
+      eof = true;
+      break;
+    }
+
+    if (c == '\n') ++*nlines;
+
+    for (int i = 0; i < 3; ++i)
+      cqueue[i] = cqueue[i + 1];
+    cqueue[3] = c;
+
+    if (strncmp(cqueue, "\r\n\r\n", 4) == 0) {
+      endOfHeaders = true;
+      break;
+    }
+
+    // If the last character was a newline, and the first now is not
+    // whitespace, then rewind one character and store the current
+    // key,value pair.
+    if (cqueue[2] == '\n' && c != ' ' && c != '\t') {
+      if (content.length() > 2)
+	content.resize(content.length() - 2);
+
+      trim(content);
+      header->add(name, content);
+
+      if (c != '\r') {
+	mimeSource->ungetChar();
+	if (c == '\n') --*nlines;
+	return true;
+      }
+	
+      mimeSource->getChar(&c);
+      return false;
+    }
+
+    content += c;
+  }
+
+  if (name != "") {
+    if (content.length() > 2)
+      content.resize(content.length() - 2);
+    header->add(name, content);
+  }
+
+  return !(eof || endOfHeaders);
+}
+
+//------------------------------------------------------------------------
+static void parseHeader(Binc::Header *header, unsigned int *nlines)
+{
+  while (parseOneHeaderLine(header, nlines))
+  { }
+}
+
+//------------------------------------------------------------------------
+static void analyzeHeader(Binc::Header *header, bool *multipart,
+			  bool *messagerfc822, string *subtype,
+			  string *boundary)
+{
+  using namespace ::Binc;
+
+  // Do simple parsing of headers to determine the
+  // type of message (multipart,messagerfc822 etc)
+  HeaderItem ctype;
+  if (header->getFirstHeader("content-type", ctype)) {
+    vector<string> types;
+    split(ctype.getValue(), ";", types);
+
+    if (types.size() > 0) {
+      // first element should describe content type
+      string tmp = types[0];
+      trim(tmp);
+      vector<string> v;
+      split(tmp, "/", v);
+      string key, value;
+
+      key = (v.size() > 0) ? v[0] : "text";
+      value = (v.size() > 1) ? v[1] : "plain";
+      lowercase(key);
+
+      if (key == "multipart") {
+	*multipart = true;
+	lowercase(value);
+	*subtype = value;
+      } else if (key == "message") {
+	lowercase(value);
+	if (value == "rfc822")
+	  *messagerfc822 = true;
+      }
+    }
+
+    for (vector<string>::const_iterator i = types.begin();
+	 i != types.end(); ++i) {
+      string element = *i;
+      trim(element);
+
+      if (element.find("=") != string::npos) {
+	string::size_type pos = element.find('=');
+	string key = element.substr(0, pos);
+	string value = element.substr(pos + 1);
+	
+	lowercase(key);
+	trim(key);
+
+	if (key == "boundary") {
+	  trim(value, " \"");
+	  *boundary = value;
+	}
+      }
+    }
+  }
+}
+
+static void parseMessageRFC822(vector<Binc::MimePart> *members,
+			       bool *foundendofpart,
+			       unsigned int *bodylength,
+			       unsigned int *nbodylines,
+			       const string &toboundary)
+{
+  using namespace ::Binc;
+
+  // message rfc822 means a completely enclosed mime document. we
+  // call the parser recursively, and pass on the boundary string
+  // that we got. when parse() finds this boundary, it returns 0. if
+  // it finds the end boundary (boundary + "--"), it returns != 0.
+  MimePart m;
+
+  unsigned int bodystartoffsetcrlf = mimeSource->getOffset();
+    
+  // parsefull returns the number of bytes that need to be removed
+  // from the body because of the terminating boundary string.
+  int bsize = 0;
+  if (m.parseFull(toboundary, bsize))
+    *foundendofpart = true;
+
+  // make sure bodylength doesn't overflow    
+  *bodylength = mimeSource->getOffset();
+  if (*bodylength >= bodystartoffsetcrlf) {
+    *bodylength -= bodystartoffsetcrlf;
+    if (*bodylength >= (unsigned int) bsize) {
+      *bodylength -= (unsigned int) bsize;
+    } else {
+      *bodylength = 0;
+    }
+  } else {
+    *bodylength = 0;
+  }
+
+  *nbodylines += m.getNofLines();
+
+  members->push_back(m);
+}
+
+static bool skipUntilBoundary(const string &delimiter,
+			      unsigned int *nlines, bool *eof)
+{
+  int endpos = delimiter.length();
+  char *delimiterqueue = 0;
+  int delimiterpos = 0;
+  const char *delimiterStr = delimiter.c_str();
+  if (delimiter != "") {
+    delimiterqueue = new char[endpos];
+    memset(delimiterqueue, 0, endpos);
+  }
+
+  // first, skip to the first delimiter string. Anything between the
+  // header and the first delimiter string is simply ignored (it's
+  // usually a text message intended for non-mime clients)
+  char c;
+
+  bool foundBoundary = false;
+  for (;;) {    
+    if (!mimeSource->getChar(&c)) {
+      *eof = true;
+      break;
+    }
+
+    if (c == '\n')
+      ++*nlines;
+
+    // if there is no delimiter, we just read until the end of the
+    // file.
+    if (!delimiterqueue)
+      continue;
+
+    delimiterqueue[delimiterpos++ % endpos] = c;
+
+    if (compareStringToQueue(delimiterStr, delimiterqueue,
+			     delimiterpos, endpos)) {
+      foundBoundary = true;
+      break;
+    }
+  }
+
+  delete [] delimiterqueue;
+  delimiterqueue = 0;
+
+  return foundBoundary;
+}
+
+
+static void parseMultipart(const string &boundary,
+			   const string &toboundary,
+			   bool *eof,
+			   unsigned int *nlines,
+			   int *boundarysize,
+			   bool *foundendofpart,
+			   unsigned int *bodylength,
+			   vector<Binc::MimePart> *members)
+{
+  using namespace ::Binc;
+  unsigned int bodystartoffsetcrlf = mimeSource->getOffset();
+
+  // multipart parsing starts with skipping to the first
+  // boundary. then we call parse() for all parts. the last parse()
+  // command will return a code indicating that it found the last
+  // boundary of this multipart. Note that the first boundary does
+  // not have to start with CRLF.
+  string delimiter = "--" + boundary;
+
+  skipUntilBoundary(delimiter, nlines, eof);
+
+  if (!eof)
+    *boundarysize = delimiter.size();
+
+  // Read two more characters. This may be CRLF, it may be "--" and
+  // it may be any other two characters.
+  char a;
+  if (!mimeSource->getChar(&a))
+    *eof = true;
+
+  if (a == '\n')
+    ++*nlines; 
+
+  char b;
+  if (!mimeSource->getChar(&b))
+    *eof = true;
+    
+  if (b == '\n')
+    ++*nlines;
+    
+  // If we find two dashes after the boundary, then this is the end
+  // of boundary marker.
+  if (!*eof) {
+    if (a == '-' && b == '-') {
+      *foundendofpart = true;
+      *boundarysize += 2;
+	
+      if (!mimeSource->getChar(&a))
+	*eof = true;
+	
+      if (a == '\n')
+	++*nlines; 
+	
+      if (!mimeSource->getChar(&b))
+	*eof = true;
+	
+      if (b == '\n')
+	++*nlines;
+    }
+
+    if (a == '\r' && b == '\n') {
+      // This exception is to handle a special case where the
+      // delimiter of one part is not followed by CRLF, but
+      // immediately followed by a CRLF prefixed delimiter.
+      if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b))
+	*eof = true; 
+      else if (a == '-' && b == '-') {
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+      } else {
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+      }
+
+      *boundarysize += 2;
+    } else {
+      mimeSource->ungetChar();
+      mimeSource->ungetChar();
+    }
+  }
+
+  // read all mime parts.
+  if (!*foundendofpart && !*eof) {
+    bool quit = false;
+    do {
+      MimePart m;
+
+      // If parseFull returns != 0, then it encountered the multipart's
+      // final boundary.
+      int bsize = 0;
+      if (m.parseFull(boundary, bsize)) {
+	quit = true;
+	*boundarysize = bsize;
+      }
+
+      members->push_back(m);
+
+    } while (!quit);
+  }
+
+  if (!*foundendofpart && !*eof) {
+    // multipart parsing starts with skipping to the first
+    // boundary. then we call parse() for all parts. the last parse()
+    // command will return a code indicating that it found the last
+    // boundary of this multipart. Note that the first boundary does
+    // not have to start with CRLF.
+    string delimiter = "\r\n--" + toboundary;
+
+    skipUntilBoundary(delimiter, nlines, eof);
+
+    if (!*eof)
+      *boundarysize = delimiter.size();
+
+    // Read two more characters. This may be CRLF, it may be "--" and
+    // it may be any other two characters.
+    char a = '\0';
+    if (!mimeSource->getChar(&a))
+      *eof = true;
+
+    if (a == '\n')
+      ++*nlines; 
+
+    char b = '\0';
+    if (!mimeSource->getChar(&b))
+      *eof = true;
+    
+    if (b == '\n')
+      ++*nlines;
+    
+    // If we find two dashes after the boundary, then this is the end
+    // of boundary marker.
+    if (!*eof) {
+      if (a == '-' && b == '-') {
+	*foundendofpart = true;
+	*boundarysize += 2;
+	
+	if (!mimeSource->getChar(&a))
+	  *eof = true;
+	
+	if (a == '\n')
+	  ++*nlines; 
+	
+	if (!mimeSource->getChar(&b))
+	  *eof = true;
+	
+	if (b == '\n')
+	  ++*nlines;
+      }
+
+      if (a == '\r' && b == '\n') {
+	// This exception is to handle a special case where the
+	// delimiter of one part is not followed by CRLF, but
+	// immediately followed by a CRLF prefixed delimiter.
+	if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b))
+	  *eof = true; 
+	else if (a == '-' && b == '-') {
+	  mimeSource->ungetChar();
+	  mimeSource->ungetChar();
+	  mimeSource->ungetChar();
+	  mimeSource->ungetChar();
+	} else {
+	  mimeSource->ungetChar();
+	  mimeSource->ungetChar();
+	}
+
+	*boundarysize += 2;
+      } else {
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+      }
+    }
+  }
+
+  // make sure bodylength doesn't overflow    
+  *bodylength = mimeSource->getOffset();
+  if (*bodylength >= bodystartoffsetcrlf) {
+    *bodylength -= bodystartoffsetcrlf;
+    if (*bodylength >= (unsigned int) *boundarysize) {
+      *bodylength -= (unsigned int) *boundarysize;
+    } else {
+      *bodylength = 0;
+    }
+  } else {
+    *bodylength = 0;
+  }
+}
+
+static void parseSinglePart(const string &toboundary,
+			    int *boundarysize,
+			    unsigned int *nbodylines,
+			    unsigned int *nlines,
+			    bool *eof, bool *foundendofpart,
+			    unsigned int *bodylength)
+{
+  using namespace ::Binc;
+  unsigned int bodystartoffsetcrlf = mimeSource->getOffset();
+
+  // If toboundary is empty, then we read until the end of the
+  // file. Otherwise we will read until we encounter toboundary.
+  string _toboundary; 
+  if (toboundary != "") {
+    _toboundary = "\r\n--";
+    _toboundary += toboundary;
+  }
+
+  //  if (skipUntilBoundary(_toboundary, nlines, eof))
+  //    *boundarysize = _toboundary.length();
+
+  char *boundaryqueue = 0;
+  int endpos = _toboundary.length();
+  if (toboundary != "") {
+    boundaryqueue = new char[endpos];
+    memset(boundaryqueue, 0, endpos);
+  }
+  int boundarypos = 0;
+
+  *boundarysize = 0;
+
+  const char *_toboundaryStr = _toboundary.c_str();
+  string line;
+  bool toboundaryIsEmpty = (toboundary == "");
+  char c;
+  while (mimeSource->getChar(&c)) {
+    if (c == '\n') { ++*nbodylines; ++*nlines; }
+
+    if (toboundaryIsEmpty)
+      continue;
+
+    // find boundary
+    boundaryqueue[boundarypos++ % endpos] = c;
+      
+    if (compareStringToQueue(_toboundaryStr, boundaryqueue,
+			     boundarypos, endpos)) {
+      *boundarysize = _toboundary.length();
+      break;
+    }
+  }
+
+  delete [] boundaryqueue;
+
+  if (toboundary != "") {
+    char a;
+    if (!mimeSource->getChar(&a))
+      *eof = true;
+
+    if (a == '\n')
+      ++*nlines;
+    char b;
+    if (!mimeSource->getChar(&b))
+      *eof = true;
+
+    if (b == '\n') 
+      ++*nlines;
+
+    if (a == '-' && b == '-') {
+      *boundarysize += 2;
+      *foundendofpart = true;
+      if (!mimeSource->getChar(&a))
+	*eof = true;
+
+      if (a == '\n')
+	++*nlines;
+
+      if (!mimeSource->getChar(&b))
+	*eof = true;
+	  
+      if (b == '\n')
+	++*nlines;
+    }
+
+    if (a == '\r' && b == '\n') {
+      // This exception is to handle a special case where the
+      // delimiter of one part is not followed by CRLF, but
+      // immediately followed by a CRLF prefixed delimiter.
+      if (!mimeSource->getChar(&a) || !mimeSource->getChar(&b))
+	*eof = true; 
+      else if (a == '-' && b == '-') {
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+      } else {
+	mimeSource->ungetChar();
+	mimeSource->ungetChar();
+      }
+
+      *boundarysize += 2;
+    } else {
+      mimeSource->ungetChar();
+      mimeSource->ungetChar();
+    }
+  }
+
+  // make sure bodylength doesn't overflow    
+  *bodylength = mimeSource->getOffset();
+  if (*bodylength >= bodystartoffsetcrlf) {
+    *bodylength -= bodystartoffsetcrlf;
+    if (*bodylength >= (unsigned int) *boundarysize) {
+      *bodylength -= (unsigned int) *boundarysize;
+    } else {
+      *bodylength = 0;
+    }
+  } else {
+    *bodylength = 0;
+  }
+
+}
+
+//------------------------------------------------------------------------
+int Binc::MimePart::parseFull(const string &toboundary,
+			      int &boundarysize) const
+{
+  headerstartoffsetcrlf = mimeSource->getOffset();
+
+  // Parse the header of this mime part.
+  parseHeader(&h, &nlines);
+
+  // Headerlength includes the seperating CRLF. Body starts after the
+  // CRLF.
+  headerlength = mimeSource->getOffset() - headerstartoffsetcrlf;
+  bodystartoffsetcrlf = mimeSource->getOffset();
+  bodylength = 0;
+
+  // Determine the type of mime part by looking at fields in the
+  // header.
+  analyzeHeader(&h, &multipart, &messagerfc822, &subtype, &boundary);
+
+  bool eof = false;
+  bool foundendofpart = false;
+
+  if (messagerfc822) {
+    parseMessageRFC822(&members, &foundendofpart, &bodylength,
+		       &nbodylines, toboundary);
+
+  } else if (multipart) {
+    parseMultipart(boundary, toboundary, &eof, &nlines, &boundarysize,
+		   &foundendofpart, &bodylength,
+		   &members);
+  } else {
+    parseSinglePart(toboundary, &boundarysize, &nbodylines, &nlines,
+		    &eof, &foundendofpart, &bodylength);
+  }
+
+  return (eof || foundendofpart) ? 1 : 0;
+}