/*
 * CDE - Common Desktop Environment
 *
 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
 *
 * These libraries and programs are free software; you can
 * redistribute them and/or modify them under the terms of the GNU
 * Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * These libraries and programs are distributed in the hope that
 * they will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with these libraries and programs; if not, write
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301 USA
 */
/*
 *+SNOTICE
 *
 *
 *	$TOG: RFCMIME.C /main/13 1998/07/24 16:09:00 mgreess $
 *
 *	RESTRICTED CONFIDENTIAL INFORMATION:
 *	
 *	The information in this document is subject to special
 *	restrictions in a confidential disclosure agreement bertween
 *	HP, IBM, Sun, USL, SCO and Univel.  Do not distribute this
 *	document outside HP, IBM, Sun, USL, SCO, or Univel wihtout
 *	Sun's specific written approval.  This documment and all copies
 *	and derivative works thereof must be returned or destroyed at
 *	Sun's request.
 *
 *	Copyright 1993, 1994, 1995 Sun Microsystems, Inc.  All rights reserved.
 *
 *+ENOTICE
 */

#ifndef I_HAVE_NO_IDENT
#endif

#include <EUSCompat.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>

#include <Dt/Dts.h>

#include "md5.h"
#include "RFCMIME.hh"
#include <DtMail/DtMailP.hh>
#include <DtMail/IO.hh>
#include "str_utils.h"

// For CHARSET
#include <limits.h>
static int converted = 0;

#if defined(POSIX_THREADS)
extern "C" int rand_r(unsigned int);
#define brand(a)	rand_r(a)
#else
#define brand(a) 	rand()
#endif

#define DIRECTION_STRING(dir) ((dir==CURRENT_TO_INTERNET) ? \
				"CURRENT_TO_INTERNET" : \
				"INTERNET_TO_CURRENT")

#define ENCODING_STRING(enc) ((enc==MIME_7BIT) ? "MIME_7BIT" : \
			      ((enc==MIME_8BIT) ? "MIME_8BIT" : \
			       ((enc==MIME_QPRINT) ? "MIME_QPRINT" : \
			       "MIME_BASE64")))

#define	NON_MAIL_SAFE(char) (((char >= 0) && (char <= 31) && (char != 9) && \
		(char != 0x0a)) || (char == 127))

inline unsigned int
base64size(const unsigned long len)
{
    unsigned long b_len = len + (len / 3);
    b_len += (b_len / 72 * 2) + 4;

    return((unsigned int) b_len);
}

void
RFCMIME::getMIMEType(DtMail::BodyPart * bp, char * mime_type, DtMailBoolean & is_text)
{
    // Get the Dt type name from the body part.
    //
    char * type = 0;
    DtMailEnv error;

    bp->getContents(error,
		    NULL,
		    NULL,
		    &type,
		    NULL,
		    NULL,
		    NULL);

    // It is possible there is *no* contents associated with this
    // body part - in that case, fake text/plain
    //
    if (error.isSet()) {
      strcpy(mime_type, "text/plain");
      return;
    }
    assert(type != NULL);
    
    // Look it up in the data typing system. Hopefully we will
    // get a db based mime name.
    //
    char * db_type = DtDtsDataTypeToAttributeValue(type,
						   DtDTS_DA_MIME_TYPE,
						   NULL);

    // See if we call this text. If so, then it will be text/plain,
    // if not then application/octet-stream
    //
    char * text_type = DtDtsDataTypeToAttributeValue(type,
						     DtDTS_DA_IS_TEXT,
						     NULL);

    if (db_type) {
	strcpy(mime_type, db_type);
    }
    else {
	if (text_type && strcasecmp(text_type, "true") == 0) {
	    strcpy(mime_type, "text/plain");
	}
	else {
	    strcpy(mime_type, "application/octet-stream");
	}
    }

    is_text = text_type ? DTM_TRUE : DTM_FALSE;

    free(type);
    if (db_type) {
	free(db_type);
    }
    if (text_type) {
	free(text_type);
    }

    return;
}

RFCMIME::RFCMIME(DtMail::Session * session)
: RFCFormat(session)
{
}

RFCMIME::~RFCMIME(void)
{
}


RFCMIME::Encoding
RFCMIME::getEncodingType(const char * body,
			 const unsigned int len,
			 DtMailBoolean strict_mime,
			 int *real8bit)
{
  // Our goal here is to produce the most readable, safe encoding.
  // We have a couple of parameters that will guide our
  // choices:
  //
  // 1) RFC822 allows lines to be a minimum of 1000 characters,
  //    but MIME encourages mailers to keep lines to <76 characters
  //    and use quoted-printable if necessary to achieve this.
  //
  // 2) The base64 encoding will grow the body size by 33%, and
  //    also render it unreadable by humans. We don't want to use
  //    it unless really necessary.
  //
  // Given the above 2 rules, we want to scan the body part and
  // select an encoding. The 3 choices will be decided by:
  //
  // 1) If the text is 7 bit clean, and all lines are <76 chars,
  //    then no encoding will be applied.
  //
  // 2) If the text is not 7 bit clean, or there are lines >76 chars,
  //    and the quoted-printable size is less than the base64 size,
  //    then quoted-printable will be done.
  //
  // 3) If 1 & 2 are not true, then base64 will be applied.
  //
  // If "strict_mime" is false we will only encode if the message:
  //    - is not 7 bit clean
  //    - if any non-printing characters non-spacing characers
  //
  
  if (body == NULL || len == 0) {
    return(MIME_7BIT);
  }
  
  const int base64_growth = base64size(len) - len;
  int qprint_growth = 0;
  DtMailBoolean seven_nonprinting = DTM_FALSE;
  DtMailBoolean eight_bit = DTM_FALSE;
  DtMailBoolean encode = DTM_FALSE;
  
  const char * last_nl = body;
  const char * cur;
  
  if (strncmp(body, "From ", 5) == 0) {
    qprint_growth += 2;
  }
  
  for (cur = body; cur < (body + len); cur++) {
    char curChar = *cur;
    
    if (curChar != (curChar & 0x7f)) {
      eight_bit = DTM_TRUE;
      encode = DTM_TRUE;
      qprint_growth += 2;
	  *real8bit = 1;
    }
    else if (curChar == '=') {
      // These characters don't force encoding, but will be 
      // encoded if we end up encoding.
      qprint_growth += 2;
    }
    else if ( ((curChar < ' ') || (curChar == 0x7f)) 
            && (curChar != 0x09) && (curChar != 0x0A) ) {
      // These characters force encoding
      //
      seven_nonprinting = DTM_TRUE;
      encode = DTM_TRUE;
      qprint_growth += 2;
    }

    if (curChar == '\n') {
#ifdef DEAD_WOOD
      DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
      
      if ((cur - last_nl) > 76) {
	encode = DTM_TRUE;
	qprint_growth += 2;
      }
      
      if ((cur != body && (*(cur - 1) == ' ' || *(cur - 1) == '\t'))) {
	encode = DTM_TRUE;
	qprint_growth += 2;
      }
      
      if ( ((cur + 6) < (body + len) )
	   && (strncmp((cur + 1), "From ", 5) == 0) ) {
	encode = DTM_TRUE;
	qprint_growth += 2;
      }
      
      last_nl = cur + 1;
    }
    
  }
  
  // Deal with buffers that don't end with a new line.
  //
  if ((cur - last_nl) > 76) {
    encode = DTM_TRUE;
    qprint_growth += 2;
  }
  
  Encoding enc = MIME_7BIT;
  
  if (!strict_mime && !eight_bit && !seven_nonprinting) {
    // If strict_mime is off we only encode if we have 8 bit data
    // of most of the non-printing 7-bit characters
    //
    enc = MIME_7BIT;
  }
  else if (encode) {
    // strict_mime is TRUE and we have reason to encode.
    if (qprint_growth > base64_growth) {
      enc = MIME_BASE64;
    }
    else {
      enc = MIME_QPRINT;
    }
  }
  
  return(enc);
}

#ifdef NEVER
// This was the original routine, but it did not handle
// strictmime correctly as it was too eager to encode.  I'm
// leaving it here for now since this is touchy code.
RFCMIME::Encoding
RFCMIME::getEncodingType(const char * body,
			 const unsigned int len,
			 DtMailBoolean strict_mime)
{
    // Our goal here is to produce the most readable, safe encoding.
    // We have a couple of parameters that will guide our
    // choices:
    //
    // 1) RFC822 allows lines to be a minimum of 1000 characters,
    //    but MIME encourages mailers to keep lines to <76 characters
    //    and use quoted-printable if necessary to achieve this.
    //
    // 2) The base64 encoding will grow the body size by 33%, and
    //    also render it unreadable by humans. We don't want to use
    //    it unless really necessary.
    //
    // Given the above 2 rules, we want to scan the body part and
    // select an encoding. The 3 choices will be decided by:
    //
    // 1) If the text is 7 bit clean, and all lines are <76 chars,
    //    then no encoding will be applied.
    //
    // 2) If the text is not 7 bit clean, or there are lines >76 chars,
    //    and the quoted-printable size is less than the base64 size,
    //    then quoted-printable will be done.
    //
    // 3) If 1 & 2 are not true, then base64 will be applied.
    //

    if (body == NULL || len == 0) {
	return(MIME_7BIT);
    }

    const int base64_growth = base64size(len) - len;
    int qprint_growth = 0;
    DtMailBoolean eight_bit = DTM_FALSE;
    DtMailBoolean base64 = DTM_FALSE;

    const char * last_nl = body;

    if (strncmp(body, "From ", 5) == 0) {
	qprint_growth += 2;
    }

    for (const char * cur = body; cur < (body + len); cur++) {
	if (*cur != (*cur & 0x7f) || *cur == '=' || *cur == 0) {
	    eight_bit = DTM_TRUE;
	    qprint_growth += 2;
	}

	if (*cur == '\n') {
#ifdef DEAD_WOOD
	    DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
	    
	    if (strict_mime && ((cur - last_nl) > 76)) {
		qprint_growth += 2;
	    }

	    if (strict_mime && 
		(cur != body && (*(cur - 1) == ' ' || *(cur - 1) == '\t'))) {
		qprint_growth += 2;
	    }

	    if ((cur + 6) < (body + len) && strncmp((cur + 1), "From ", 5) == 0) {
		qprint_growth += 2;
	    }

	    last_nl = cur + 1;
	}

	if (qprint_growth > base64_growth) {
	    base64 = DTM_TRUE;
	    break;
	}
    }

    // Deal with buffers that don't end with a new line.
    //
    if (strict_mime && ((cur - last_nl) > 76)) {
	qprint_growth += 2;
    }

    Encoding enc = MIME_7BIT;

    if (base64 == DTM_TRUE) {
	enc = MIME_BASE64;
    }
    else if (eight_bit == DTM_TRUE || qprint_growth > 0) {
	enc = MIME_QPRINT;
    }

    return(enc);
}
#endif

RFCMIME::Encoding
RFCMIME::getClearEncoding(const char * bp, const unsigned int bp_len, int *real8bit)
{
    // Return the appropriate "non-encoding". If we have 8 bit data,
    // then return 8bit. If not, then this is a 7bit encoding.
    //
    for (const char * cur = bp; cur < (bp + bp_len); cur++) {
	if (*cur != (*cur & 0x7f)) {
		*real8bit = 1;
	    return(MIME_8BIT);
	}
    }

    return(MIME_7BIT);
}

void
RFCMIME::writeContentHeaders(Buffer & hdr_buf,
			     const char * type, const char * name,
			     const Encoding enc,
			     const char * digest,
			     DtMailBoolean show_as_attachment,
			     int is2022ASCII )
{
    hdr_buf.appendData("Content-Type: ", 14);
    hdr_buf.appendData(type, strlen(type));

    if (strcasecmp(type, "text/plain") == 0) {
	char default_charset[64];
	if (!is2022ASCII && !converted) {
	  strcpy(default_charset, "us-ascii");
	} else {
	  getCharSet(default_charset);
	}

	int len = strlen(default_charset);

	hdr_buf.appendData("; charset=", 10);

	hdr_buf.appendData(default_charset, len);
    }

    crlf(hdr_buf);

    hdr_buf.appendData("Content-Transfer-Encoding: ", 27);

    // For CHARSET
	// If codeset conversion was done and strict mime mode is off,
	// then transfer encoding should not be done and therefore, should
	// set transfer encoding value to "binary".
	DtMailEnv error;
    DtMail::MailRc * mail_rc = _session->mailRc(error);

    DtMailBoolean strict_mime = DTM_FALSE;
    const char * rc_value;
    mail_rc->getValue(error, "strictmime", &rc_value);
    if (error.isNotSet()) {
	strict_mime = DTM_TRUE;
    }
    error.clear();
	// Read code below to see why and how strict_mime is used.
	// End of For CHARSET

    switch (enc) {
      case MIME_7BIT:
	hdr_buf.appendData("7bit", 4);
	crlf(hdr_buf);
	break;

      case MIME_8BIT:
      default: // Assume the worst.
	hdr_buf.appendData("8bit", 4);
	crlf(hdr_buf);
	break;

      case MIME_QPRINT:
	if (converted && !strict_mime) {
	hdr_buf.appendData("binary", 6);
	} else {
	hdr_buf.appendData("quoted-printable", 16);
	}
	crlf(hdr_buf);
	break;

      case MIME_BASE64:
	if (converted && !strict_mime) {
	hdr_buf.appendData("binary", 6);
	} else {
	hdr_buf.appendData("base64", 6);
	}
	crlf(hdr_buf);
	break;
    }

    hdr_buf.appendData("Content-MD5: ", 13);
    writeBase64(hdr_buf, digest, 16);

    if (name) {
	// Determine real length of the file name for the body part.
	// Make sure we don't have any trailing crlf to confuse things.
	//
	int nlen = strlen(name);
	if (name[nlen - 1] == '\n') {
	    nlen -= 1;
	}

	if (name[nlen - 1] == '\r') {
	    nlen -= 1;
	}

	char * tempName = strdup(name);
	assert(tempName != NULL);

#if 0
	// Now make sure that the name is "unix friendly"; convert
	// any meta-characters into something innocuous
	//
	for (int i = 0; i < nlen; i++)
	  if (tempName[i] < ' ')
	    tempName[i] = '-';		// all control characters are unfriendly
	  else
	    switch(tempName[i]) {
	    case '~':
	      if (i > 0)		// ~ at beginning of a line is special
		break;
	    case '?':
	    case '*':
	    case '/':
	    case ' ':
	    case '{':
	    case '}':
	    case '[':
	    case ']':
	      tempName[i] = '-';	// "-" in unix and dos in innocuous
	      break;
	    default:
	      break;
	    }
#endif
	
	// According to RFC1806, the Content-Disposition header field
	// Should be used to specify filenames.  However, the content
	// disposition field is also used to specify how a body part
	// is presented, inline or attachment.  The CDE mailer always
	// presents the first bp inline and all others as attachments.
	// 
	hdr_buf.appendData("Content-Disposition: ", 21);
	if (show_as_attachment)
	  hdr_buf.appendData("attachment; ", 12);
	else
	  hdr_buf.appendData("inline; ", 8);
	hdr_buf.appendData("filename=", 9);
	rfc1522cpy(hdr_buf, tempName);

	// Output Header: Content-Description: <body-part-name>
	// This is in keeping with the current undefined nature
	// of file names for body parts in RFC 1521 and is
	// compatible with OpenWindows mailtool.
	//
	hdr_buf.appendData("Content-Description: ", 21);
	rfc1522cpy(hdr_buf, tempName);

        // The next crlf() is not needed because it is taken care of in 
        // rfc1522cpy().  This additional call to crlf() causes attachments
        // to be typed incorrectly.  For example, a shell script will be typed
        // as a text file.
//	crlf(hdr_buf);

#if 0
    // THE FOLLOWING IS IFDEF'ED OUT BECAUSE (from MIMEBodyPart.C)
	// CDE DtMail currently sends out and recognizes "X-Content-Name" on MIME
	// compliant entities and uses that information as the "file name" for an
	// attachment. This is essentially a non-standard header field as per RFC
	// 1521:
	//
	//     "X-" fields may be created for experimental or private purposes,
	//     with the recognition that the information they contain may be
	//     lost at some gateways.
	//
	// Output Header: X-Content-Name: <body-part-name>
	// This is only to maintain compatibility with older
	// versions of DtMail that used this field only.
	// WE SHOULD REMOVE THIS AFTER THE OFFICIAL CDE RELEASE.
	//
	hdr_buf.appendData("X-Content-Name: ", 16);
	hdr_buf.appendData(tempName, nlen);
	crlf(hdr_buf);
#endif

	free(tempName);		// done with tempName
    }
}

//
// Base64 Alphabet (65-character subset of US-ASCII as per RFC1521)
//

static const char base64_chars[] = 
{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a',
 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0',
 '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
};

inline unsigned char
base64inv(const char cur)
{
    switch (cur) {
      case '+':
	return(62);

      case '/':
	return(63);

      default:
	break;
    }

    if ((cur - '0') < 10) {
	return(cur - '0' + 52);
    }

    if ((cur - 'A') < 26) {
	return(cur - 'A');
    }

    if ((cur - 'a') < 26) {
	return(cur - 'a' + 26);
    }

    return(0);
}

//
// RFCMIME::readBase64 -- decode base 64 text into clear text
// Arguments:
//  char * buf		-- buffer into which clear text is to be placed
//  int & off		-- offset into buffer when placing clear text
//			-- incremented as bytes are placed into buffer
//  char *bp		-- buffer from which base 64 text is retrieved
//  const unsigned long len -- number of bytes of base 64 text at bp
// Returns:
//  <void>
// Description:
//  Given a pointer/length to base 64 text, decode the base 64 text into
//  ordinary clear text. The decoding process proceeds from left to right
//  (buffer forward) decoding groups of 4-byte encoded octets into groups
//  of 3-byte clear text triplets. The last octet may contain padding as
//  necessary to represent a data stream that is not a multiple of 24 bits.
//

void
RFCMIME::readBase64(char * buf, int & off, const char * bp, const unsigned long len)
{
    // Make local copy of base 64 text length
    //
    unsigned long main_len = len;

    // Strip trailing white space from base 64 text so we can find the magic '=' 
    // characters at the end which indicate if padding has been used to pad the
    // last octet in the data stream
    //
    while (isspace(bp[main_len - 1])) {
	main_len -= 1;
    }

    // Check to see if the last byte of the final octet in the base 64 text has
    // the magic '=' character - if it does, bump down the base 64 text stream 
    // count by 1 octet and leave decoding of the last octet until after all
    // unpadded octets have been decoded
    //
    if (bp[main_len - 1] == '=') {
	// We have normal base64 padding, which consists of one or two '=' characters
        // at the end of the stream. Ignore it for now and process at the very end.
	//
        main_len -= 4;	// backup over last 4-byte encoding containing padding
    }

    // Main octet decoding loop. We are assured that main_len is mod 4, so
    // we can zip through decoding full octets
    //
    for (const char * cur = bp; cur < (bp + main_len - 3); cur += 4) {
	while (*cur == ' ') {
	    cur += 1;
	}

	if (*cur == '\r') {
	    cur += 1;
	}
	if (*cur == '\n') {
	    cur += 1;
	}
	unsigned char b1 = base64inv(*cur);

	if (*(cur + 1) == '\r') {
	    cur += 1;
	}
	if (*(cur + 1) == '\n') {
	    cur += 1;
	}
	unsigned char b2 = base64inv(*(cur + 1));

	if (*(cur + 2) == '\r') {
	    cur += 1;
	}
	if (*(cur + 2) == '\n') {
	    cur += 1;
	}
	unsigned char b3 = base64inv(*(cur + 2));

	if (*(cur + 3) == '\r') {
	    cur += 1;
	}
	if (*(cur + 3) == '\n') {
	    cur += 1;
	}
	unsigned char b4 = base64inv(*(cur + 3));

	buf[off++] = (char)((unsigned char)(b1 << 2) & 0xfc) | ((unsigned char)(b2 >> 4) & 0x3);
	buf[off++] = (char)((unsigned char)(b2 & 0xf) << 4) | ((unsigned char)(b3 >> 2) & 0xf);
	buf[off++] = (char)((unsigned char)(b3 & 0x3) << 6) | ((unsigned char)(b4 & 0x3f));
    }

    // Throw away any white space left in base 64 text, just in case.
    //
    while (main_len < len && isspace(bp[main_len])) {
	main_len += 1;
    }

    // If end of stream was padded, there will be additional data not yet processed
    // from the stream. Since encoding is three bytes clear to four bytes encoded,
    // padding means there are one or two bytes at most remaining to be decoded from
    // the last octet.
    //
    if (main_len != len) {
	unsigned char b1 = base64inv(bp[main_len]);
	unsigned char b2 = base64inv(bp[main_len + 1]);
	unsigned char b3 = 0;
	if (bp[main_len + 2] != '=') {
	    b3 = base64inv(bp[main_len + 2]);
	}

	buf[off++] = (char)((unsigned char)(b1 << 2) & 0xfc) | ((unsigned char)(b2 >> 4) & 0x3);
	if (bp[main_len + 2] != '=') {
	    buf[off++] = (char)((unsigned char)(b2 & 0xf) << 4) | ((unsigned char)(b3 >> 2) & 0xf);
	}
    }

    return;
}

void
RFCMIME::writeBase64(Buffer & buf, const char * bp, const unsigned long len)
{
    if (bp == NULL || len == 0) {
	crlf(buf);
	return;
    }

    // The length has to be a multiple of 3. We will need to pad
    // any extra. Let's just work on the main body and save the
    // fractional stuff for the end.
    //
    unsigned long main_len = len - (len % 3);
    const unsigned char * ubp = (const unsigned char *)bp;

    char line[80];

    unsigned int enc_char;

    int lf = 0;

    int block;
    for (block = 0; block < main_len; block += 3) {
	enc_char = (ubp[block] >> 2) & 0x3f;
	line[lf++] = base64_chars[enc_char];

	enc_char = ((ubp[block] & 0x3) << 4) | ((ubp[block+1] >> 4) & 0xf);
	line[lf++] = base64_chars[enc_char];

	enc_char = ((ubp[block+1] & 0xf) << 2) | ((ubp[block + 2] >> 6) & 0x3);
	line[lf++] = base64_chars[enc_char];

	enc_char = ubp[block + 2] & 0x3f;
	line[lf++] = base64_chars[enc_char];

	if (lf == 72) {
	    buf.appendData(line, lf);
#ifdef DEAD_WOOD
	    DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
	    crlf(buf);
	    lf = 0;
	}
    }

    if (lf > 0) {
	buf.appendData(line, lf);
    }

    if (((lf + 4) % 72) == 0) {
	crlf(buf);
    }

    switch(len % 3) {
      case 1:
	enc_char = (ubp[block] >> 2) & 0x3f ;
	buf.appendData(&base64_chars[enc_char], 1);

	enc_char = ((ubp[block] & 0x3) << 4);
	buf.appendData(&base64_chars[enc_char], 1);

	buf.appendData("==", 2);
	break;

      case 2:
	enc_char = (ubp[block] >> 2) & 0x3f;
	buf.appendData(&base64_chars[enc_char], 1);

	enc_char = ((ubp[block] & 0x3) << 4) | ((ubp[block+1] >> 4) & 0xf);
	buf.appendData(&base64_chars[enc_char], 1);

	enc_char = ((ubp[block + 1] & 0xf) << 2);
	buf.appendData(&base64_chars[enc_char], 1);

	buf.appendData("=", 1);
    }

    crlf(buf);
}

// Function: RFCMIME::readTextEnriched - convert enriched to plain text
// Description:
//  This function converts a buffer containing enriched text into a buffer
//  containing the plain text translation of the enriched text
// Method:
//  This algorithm was adapted from the example simple enriched-to-plain
//  text translator contained in RFC 1563, Appendix A.
//
void
RFCMIME::readTextEnriched(char * buf, int & off, const char * bp, const unsigned long bp_len)
{
  char c, i, paramct=0, newlinect=0, nofill=0;
  char token[256], *p;
  
  const char *ebp = bp+bp_len;
  for (const char * cur = bp; cur < ebp; cur++) {
    c = *cur;
    if (c == '<') {
      if (newlinect == 1)
	buf[off++] = ' ';
      newlinect = 0;
      c = *(++cur);
      if (c == '<') {
	if (paramct <= 0)
	  buf[off++] = c;
      }
      else {
	for (i=0, p=token; (c = *cur) && (cur < ebp) && (c != '>'); i++, cur++) {
	  if (i < sizeof(token)-1)
	    *p++ = isupper(c) ? tolower(c) : c;
	}
	*p = '\0';
	if (cur >= ebp)
	  break;
	if (strcmp(token, "param") == 0)
	  paramct++;
	else if (strcmp(token, "nofill") == 0)
	  nofill++;
	else if (strcmp(token, "/param") == 0)
	  paramct--;
	else if (strcmp(token, "/nofill") == 0)
	  nofill--;
      }
    } else {
      if (paramct > 0)
	; /* ignore params */
      else if ((c == '\n') && (nofill <= 0)) {
	if (++newlinect > 1)
	  buf[off++] = c;
      } else {
	if (newlinect == 1)
	  buf[off++] = ' ';
	newlinect = 0;
	buf[off++] = c;
      }
    }
  }
  buf[off++] = '\n';
  
  return;
}

void
RFCMIME::readQPrint(
		char *buf, int &off,
		const char *bp, const unsigned long bp_len)
{
    for (const char * cur = bp; cur < (bp + bp_len); cur++) {
	if (*cur == '=') {
	    if (*(cur + 1) == '\n') {
		cur += 1;
		continue;
	    }
	    else if (*(cur + 1) == '\r' && *(cur + 2) == '\n') {
		cur += 2;
		continue;
	    }
	    else {
		if (isxdigit(*(cur + 1)) && isxdigit(*(cur + 2))) {
		    char hex[3];
		    hex[0] = *(cur + 1);
		    hex[1] = *(cur + 2);
		    hex[2] = 0;

		    buf[off++] = (char) strtol(hex, NULL, 16);
		    cur += 2;
		    continue;
		}
	    }
	}

	buf[off++] = *cur;
    }

    return;
}

void
RFCMIME::writeQPrint(Buffer & buf, const char * bp, const unsigned long bp_len)
{
  if (bp == NULL || bp_len == 0) {
    crlf(buf);
    return;
  }
  
  int last_nl = 0;
  int off = 0;
  
  // A line buffer for improving formatting performance. Note that
  // QP requires all lines to be < 72 characters plus CRLF. So, a
  // fixed size 80 character buffer is safe.
  //
  char tmp[20];			// temp for constructing "octets"
  char line_buf[80];
  
  // There are probably more elegant ways to deal with a message that
  // begins with "From ", but we will simply due it this more simplistic
  // way.
  //
  const char * start;
  if (strncmp(bp, "From ", 5) == 0) {
    memcpy(&line_buf[off], "=46", 3);
    start = bp + 1;
    off += 3;
  }
  else {
    start = bp;
  }
  
  // This loop will apply the encodings, following the rules identified
  // in RFC1521 (though not necessarily in the order presented.
  //
  const char *cur;
  for (cur = start; cur < (bp + bp_len); cur++) {
    
    // Rule #5: Part 1! We will try to break at white space
    // if possible, but it may not be possible. In any case,
    // we want to force the lines to be less than 76 characters.
    //
    if (off > 72) {
      line_buf[off++] = '=';
      buf.appendData(line_buf, off);
      crlf(buf);
      last_nl = 0;
      off = 0;
    }
    
    // Rule #1: Any octet, except those indicating a line break
    // according to the newline convention mabe represented by
    // an = followed by a two digit hexadecimal representation
    // of the octet's value. We will represent any non-7bit
    // data this way, but let the rest slide. We do wrap "="
    // just to be safe.
    //
    if (*cur != (*cur & 0x7f) || *cur == '=' || NON_MAIL_SAFE(*cur)) {
      sprintf(tmp, "=%02X", (int)(unsigned char)*cur);
      memcpy(&line_buf[off], tmp, 3);
      off += 3;
      continue;
    }
    
    // Rule #2: Octets with decimal values of 33 through 60
    // inclusive and 62 through 126, inclusive, MAY be represented
    // as the ASCII characters which correspond to those octets.
    //
    if ((*cur >= 33 && *cur <= 60) ||
	(*cur >= 62 && *cur <= 126)) {
      line_buf[off++] = *cur;
      continue;
    }
    
    // Rule #5: The q-p encoding REQUIRES that encoded lines be
    // no more than 76 characters long. If longer, an equal sign
    // as the last character n the line indicates a soft line break.
    //
    // This is tricky if you want to leave it reasonably readable
    // (why else do this?). We only want to break on white space.
    // At each white gap, we need to count forward to the next
    // white gap and see if we exceed the 76 character limit.
    // We will cheat a few characters to allow us some room
    // for arithmetic.
    //
    if (*cur == ' ' || *cur == '\t') {
      // Find the end of this clump of white space.
      //
      const char *nw;
      for (nw = cur; nw < (bp + bp_len) && *nw && *nw != '\n'; nw++) {
	if (!isspace((unsigned char)*nw)) {
	  break;
	}
      }
      
      // Find the end of the next non-white region.
      //
      const char *white;
      for (white = nw;
	   white < (bp + bp_len) && *white && !isspace((unsigned char)*white);
	   white++) {
	continue;
      }
      
      int line_len = (off - last_nl) + (white - cur);
      if (line_len > 72) {
	// Need a soft line break. Lets put it after the
	// current clump of white space. We will break
	// at 72 characters, even if we arent at the end
	// of the white space. This prevents buffer overruns.
	//
	for (const char *cp_w = cur; cp_w < nw; cp_w++) {
	  line_buf[off++] = *cp_w;
	  if (off > 72) {
	    line_buf[off++] = '=';
	    buf.appendData(line_buf, off);
#ifdef DEAD_WOOD
	    DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
	    crlf(buf);
	    off = 0;
	    last_nl = 0;
	  }
	}
	
	// There is an edge case that we may have written the last
	// white space character in the for loop above. This will
	// prevent us from spitting an extra continuation line.
	//
	if (off) {
	  line_buf[off++] = '=';
	  buf.appendData(line_buf, off);
#ifdef DEAD_WOOD
	  DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
	  crlf(buf);
	  last_nl = 0;
	  off = 0;
	}
	
	// If we created a "From " at the front we need to wrap
	// it to protect from parsers.
	//
	if ((nw + 5) < (bp + bp_len) && strncmp(nw, "From ", 5) == 0) {
	  memcpy(&line_buf[off], "=46", 3);
	  off += 3;
	  cur = nw;
	}
	else {
	  cur = nw - 1;
	}
      }
      else {
	line_buf[off++] = *cur;
      }
      
      continue;
    }
    
    // Rule 3: Octets with values of 9 and 32 MAY be represented
    // as ASCII TAB and SPACE but MUST NOT be represented at the
    // end of an encoded line. We solve this be encoding the last
    // white space before a new line (except a new line) using
    // Rule #1.
    //
    if (*cur == '\n') {
      if (cur == start) {
	crlf(buf);
      }
      else {
	last_nl = off + 1;
	
	char prev = *(cur - 1);
	if ((prev == ' ' || prev == '\t') && prev != '\n') {
	  off = off ? off - 1 : off;
	  
	  char tmpbuf[20];
	  sprintf(tmpbuf, "=%02X", *(cur - 1));
	  memcpy(&line_buf[off], tmpbuf, 3);
	  off += 3;
	}
	
	buf.appendData(line_buf, off);
#ifdef DEAD_WOOD
	DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
	last_nl = 0;
	off = 0;
	
	if (*(cur - 1) == '\r') {
	  buf.appendData(cur, 1);
	}
	else {
	  crlf(buf);
	}
      }
      // We need to munge a line that starts with "From " to it
      // protect from parsers. The simplest way is to encode the
      // "F" using rule #1.
      //
      if ((cur + 5) < (bp + bp_len) && strncmp((cur + 1), "From ", 5) == 0) {
	memcpy(&line_buf[off], "=46", 3);
	off += 3;
	cur += 1;
      }
      continue;
    }

    // if we have gotten this far, we could not figure out *what* to
    // do with the "octet" at *cur - in this case, apply Rule #1
    // (General 8-bit representation)
    //
    sprintf(tmp, "=%02X", (int)(unsigned char)*cur);
    memcpy(&line_buf[off], tmp, 3);
    off += 3;

  }	// end of big "for" loop
  
  if (off > 0) {
    buf.appendData(line_buf, off);
  }
  
  if (*(cur - 1) != '\n') {
    crlf(buf);
  }
}

void
RFCMIME::writePlainText(Buffer & buf, const char * bp, const unsigned long len)
{
    // It may seem silly, but we do need to make sure every line ends with
    // a CRLF pair. Most buffers will end with only LF.
    //
    if (bp == NULL || len == 0) {
	crlf(buf);
	return;
    }

    const char * line_start = bp;
    const char * cur;
    for (cur = bp; cur < (bp + len); cur++) {
	if (*cur == '\n') {
	    const char * real_end = cur;

	    if (cur != bp && *(cur - 1) == '\r') {
		real_end -= 1;
	    }

	    buf.appendData(line_start, real_end - line_start);
#ifdef DEAD_WOOD
	    DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
	    line_start = cur + 1;
	    crlf(buf);
	}
    }

    if (line_start < cur) {
	buf.appendData(line_start, cur - line_start);
    }

    // The body should end with a CRLF.
    //
    if (*(cur - 1) != '\n') {
	crlf(buf);
    }
}

void
RFCMIME::md5PlainText(const char * bp, const unsigned long len, unsigned char * digest)
{
    // We need to compute the md5 signature based on a message that has
    // the CRLF line terminator. Most of our buffers don't so we will need
    // to scan the body and do some magic. The approach will be to sum
    // one line at a time. If the buffer doesn't have CRLF we will do that
    // independently.
    //

    MD5_CTX context;
    MD5Init(&context);
    unsigned char * local_crlf = (unsigned char *)"\r\n";

    const char * last = bp;
    const char * cur;
    for (cur = bp; cur < (bp + len); cur++) {
	if (*cur == '\n') {
#ifdef DEAD_WOOD
	    DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
	    if (cur == bp || *(cur - 1) == '\r') {
		MD5Update(&context, (unsigned char *)last,
			  cur - last + 1);
	    }
	    else {
		MD5Update(&context, (unsigned char *)last,
			  cur - last);
		MD5Update(&context, local_crlf, 2);
	    }
	    last = cur + 1;
	}
    }

    if (bp[len - 1] != '\n') {
	// Need to sum the trailing fraction with a CRLF.
	MD5Update(&context, (unsigned char *)last,
		  cur - last);
	MD5Update(&context, local_crlf, 2);
    }

    MD5Final(digest, &context);
}

void
RFCMIME::formatBodies(DtMailEnv & error,
		      DtMail::Message & msg,
		      DtMailBoolean include_content_length,
		      char ** extra_headers,
		      Buffer & buf)
{
// For CHARSET
    char *from_cs = NULL, *to_cs = NULL;
	int eightbit = 0;

	// This is a static global variable that determines charset and whether
	// transfer encoding should be done.  Must (re)set this variable at
	// beginning of formatBodies().
	// When MT safe is implemented, must re-work this.
    converted = 0;

    error.clear();

    BufferMemory hdr_buf(1024);

    // We always put the Mime-Version on MIME messages, regardless
    // of content.
    //
    hdr_buf.appendData("Mime-Version: 1.0", 17);
    crlf(hdr_buf);

    // We need to figure out what the content type will
    // be. If we have multiple message body parts, then
    // it is multipart/mixed. Otherwise we have to retrieve
    // the MIME type for the typing database and also identify
    // the charset and encoding.
    //
    int body_count = msg.getBodyCount(error);
    srand((u_int)time(0));

    char boundary[256];
    sprintf(boundary, "%x_%x-%x_%x-%x_%x", rand(), rand(), rand(),
	    rand(), rand(), rand());

    DtMail::MailRc * mail_rc = _session->mailRc(error);

    DtMailBoolean strict_mime = DTM_FALSE;
    const char * rc_value;
    error.clear();
    mail_rc->getValue(error, "strictmime", &rc_value);
    if (error.isNotSet()) {
	strict_mime = DTM_TRUE;
    }
    error.clear();

    char default_charset[64];
    getCharSet(default_charset);

    if (body_count <= 1) {
	DtMail::BodyPart * bp = msg.getFirstBodyPart(error);
	char mime_type[64];
	DtMailBoolean is_text;
	getMIMEType(bp, mime_type, is_text);

	unsigned long bp_len;
	char * bp_contents=NULL, * name=NULL;
  	const void *tmp_ptr;
	error.clear();
	bp->getContents(error, &tmp_ptr, &bp_len, NULL, &name, NULL, NULL);
	// We don't want to change the contents of the msg.
	if (bp_len > 0) {
        	bp_contents = (char*)malloc((unsigned int)bp_len);
		memcpy(bp_contents, (char*)tmp_ptr, (size_t)bp_len);
	}

	Encoding enc;
	if (strncasecmp(mime_type, "message/", 8) == 0) {
	    enc = getClearEncoding(
				(char *)bp_contents, (unsigned int) bp_len,
				&eightbit);
	}
	else {
	    enc = getEncodingType(
				(char *)bp_contents, (unsigned int) bp_len,
				strict_mime, &eightbit);
	}

// For CHARSET
    	if (bp_contents && (is_text == DTM_TRUE) && eightbit ) {
		from_cs = NULL;
    		from_cs = _session->locToConvName();
		to_cs = NULL;
		to_cs = _session->targetConvName();
		converted = _session->csConvert(
				(char **)&bp_contents, bp_len, 1,
	            		from_cs, to_cs);
		if ( from_cs )
		  free( from_cs );
		if ( to_cs )
		  free( to_cs );
    	}
// End of For CHARSET

	// Do md5 check summing.
	//
	unsigned char digest[16];
	memset(digest, 0, sizeof(digest));

	if (bp_contents && bp_len > 0) {
	    if (is_text == DTM_TRUE) {
		md5PlainText((char *)bp_contents, bp_len, digest);
	    }
	    else {
		MD5_CTX context;
		MD5Init(&context);
		MD5Update(
			&context,
			(unsigned char *)bp_contents,
			(unsigned int) bp_len);
		MD5Final(digest, &context);
#ifdef DEAD_WOOD
		DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
	    }
	}

	writeContentHeaders(hdr_buf, mime_type, NULL, enc,
			    (char *)digest, DTM_FALSE, eightbit);

	if (name)
	    free(name);

	crlf(buf);

	switch (enc) {
	  case MIME_7BIT:
	  case MIME_8BIT:
	  default:
	    // Just copy the bits.
	    writePlainText(buf, (char *)bp_contents, bp_len);
	    break;

	  case MIME_BASE64:
		if (converted && !strict_mime) {
		    	writePlainText(buf, (char *)bp_contents, bp_len);
		    	converted = 0;
		} else {
		   	writeBase64(buf, (char *)bp_contents, bp_len);
		}
	    break;

	  case MIME_QPRINT:
	    if (converted && !strict_mime) {
	    	writePlainText(buf, (char *)bp_contents, bp_len);
		converted = 0;
	    } else {
	   	writeQPrint(buf, (char *)bp_contents, bp_len);
	    }
	    break;
	}
	if (bp_contents)
		free(bp_contents);
    }
    else {
	char *content_type = new char[100];

	sprintf(content_type, "Content-Type: multipart/mixed;boundary=%s",
		boundary);

	int len = strlen(content_type);
	hdr_buf.appendData(content_type, len);
	crlf(hdr_buf);
	delete [] content_type;

	crlf(buf);
	
	int bdry_len = strlen(boundary);
	int cur_body = 0;
	DtMailBoolean show_as_attachment = DTM_FALSE;

	for (DtMail::BodyPart * bp = msg.getFirstBodyPart(error);
	     bp && !error.isSet();
	     bp = msg.getNextBodyPart(error, bp), cur_body += 1) {

	    // Skip this body part if it is deleted.
	    if (bp->flagIsSet(error, DtMailBodyPartDeletePending))
		continue;

	    // Put out the boundary.
	    //
	    buf.appendData("--", 2);
	    buf.appendData(boundary, bdry_len);
	    crlf(buf);

	    char mime_type[64];
	    DtMailBoolean is_text;
	    getMIMEType(bp, mime_type, is_text);
	    
	    unsigned long bp_len;
	    char* bp_contents=NULL, *name=NULL;
	    const void *tmp_ptr;
		char *type = NULL;
	    bp->getContents(error, &tmp_ptr, &bp_len, &type, &name, NULL, NULL);
	    if (bp_len > 0) {
	    	bp_contents = (char*)malloc((unsigned int)bp_len);
	   	memcpy(bp_contents, (char*)tmp_ptr, (size_t)bp_len);
	    }

	    Encoding enc;
	    if (strncasecmp(mime_type, "message/", 8) == 0) {
		enc = getClearEncoding(
				(char *)bp_contents, (unsigned int) bp_len,
				&eightbit);
	    }
	    else {
		enc = getEncodingType(
				(char *)bp_contents, (unsigned int) bp_len,
				strict_mime, &eightbit);
	    }

// For CHARSET
	    if (bp_contents && (is_text == DTM_TRUE) && eightbit ) {
		from_cs = NULL;
       	   	from_cs = _session->locToConvName();
		to_cs = NULL;
	   		to_cs = _session->targetConvName();
	   		converted = _session->csConvert((char **)&bp_contents, 
			bp_len, 1, from_cs, to_cs);
		if ( from_cs )
		  free( from_cs );
		if ( to_cs )
		  free( to_cs );
	    }
// End of For CHARSET

	    unsigned char digest[16];
	    memset(digest, 0, sizeof(digest));

	    if (bp_contents && bp_len > 0) {
		if (is_text == DTM_TRUE) {
		    md5PlainText((char *)bp_contents, bp_len, digest);
		}
		else {
		    MD5_CTX context;
		    MD5Init(&context);
		    MD5Update(
			&context,
			(unsigned char *)bp_contents,
			(unsigned int) bp_len);
		    MD5Final(digest, &context);
#ifdef DEAD_WOOD
		    DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
		}
	    }

	    if (cur_body == 0) {
		show_as_attachment = DTM_FALSE;
		if (name) {
		    free(name);
		    name = NULL;
		}
	    }
	    else
		show_as_attachment = DTM_TRUE;

	    writeContentHeaders(buf, mime_type, name, enc,
				(char *)digest, show_as_attachment, eightbit);

		owCompat(buf, type, name, bp_contents, bp_len);
		if (type) {
		   free(type);   // allocated by getContent above
		}

	    if (name)
		free(name);

	    crlf(buf);
	    
	    switch (enc) {
	      case MIME_7BIT:
	      case MIME_8BIT:
	      default:
		// Just copy the bits.
		writePlainText(buf, (char *)bp_contents, bp_len);
		break;
		
	      case MIME_BASE64:
        	if (converted && !strict_mime) {
			writePlainText(buf, (char *)bp_contents, bp_len);
			converted = 0;
		} else {
			writeBase64(buf, (char *)bp_contents, bp_len);
		}
		break;
		
	      case MIME_QPRINT:
        	if (converted && !strict_mime) {
			writePlainText(buf, (char *)bp_contents, bp_len);
			converted = 0;
		} else {
			writeQPrint(buf, (char *)bp_contents, bp_len);
		}
		break;
	    }
	    if (bp_contents)
		free(bp_contents);
	}

	// Put out the last boundary.
	buf.appendData("--", 2);
	buf.appendData(boundary, bdry_len);
	buf.appendData("--", 2);
	crlf(buf);
    }

    error.clear();

    if (include_content_length) {
	hdr_buf.appendData("Content-Length: ", 16);
	char tmpbuf[20];
	sprintf(tmpbuf, "%d", buf.getSize());
	hdr_buf.appendData(tmpbuf, strlen(tmpbuf));
	crlf(hdr_buf);
    }

    *extra_headers = (char*) malloc((size_t) hdr_buf.getSize() + 1);

    BufReader * rdr = hdr_buf.getReader();

    rdr->getData(*extra_headers, hdr_buf.getSize());
    (*extra_headers)[hdr_buf.getSize()] = 0;

    delete rdr;
    return;
}

static const char * block_headers[] = {
    "Mime-Version",
    "Content-Type",
    "Content-Length",
    "Content-MD5",
    "X-Sun-Charset",
    NULL
};

void
RFCMIME::formatHeaders(DtMailEnv & error,
		       DtMail::Message & msg,
		       DtMailBoolean include_unix_from,
		       const char * extra_headers,
		       Buffer & buf)
{
    error.clear();

    // We can use the parent comment RFC header formatter with our list
    // of headers to suppress.
    //
    writeHeaders(error, msg, include_unix_from, extra_headers, block_headers, buf);
}

// This routine is same as getEncodingType except for certain rules
// not applicable to header fields.
RFCMIME::Encoding
RFCMIME::getHdrEncodingType(const char * body,
			 const unsigned int len,
			 DtMailBoolean strict_mime,
			 const char * charset)
{
  if (body == NULL || len == 0) {
    return(MIME_7BIT);
  }
  
  const int base64_growth = base64size(len) - len;
  int qprint_growth = 0;
  DtMailBoolean seven_nonprinting = DTM_FALSE;
  DtMailBoolean eight_bit = DTM_FALSE;
  DtMailBoolean encode = DTM_FALSE;
  
  const char * last_nl = body;
  const char * cur;
  for (cur = body; cur < (body + len); cur++) {
    char curChar = *cur;
    
    if (curChar != (curChar & 0x7f)) {
      eight_bit = DTM_TRUE;
      encode = DTM_TRUE;
      qprint_growth += 2;
    }
    else if (curChar == '=') {
      // These characters don't force encoding, but will be 
      // encoded if we end up encoding.
      qprint_growth += 2;
    }
    else if ( ((curChar < ' ') || (curChar == 0x7f)) 
            && (curChar != 0x09) && (curChar != 0x0A) ) {
      // These characters force encoding
      //
      seven_nonprinting = DTM_TRUE;
      encode = DTM_TRUE;
      qprint_growth += 2;
    }
    
    if (curChar == '\n') {
#ifdef DEAD_WOOD
      DtMailProcessClientEvents();
#endif /* DEAD_WOOD */
     
      if ((cur - last_nl) > 76) {
	encode = DTM_TRUE;
	qprint_growth += 2;
      }
      
      if ((cur != body && (*(cur - 1) == ' ' || *(cur - 1) == '\t'))) {
	encode = DTM_TRUE;
	qprint_growth += 2;
      }
      
      if ( ((cur + 6) < (body + len) )
	   && (strncmp((cur + 1), "From ", 5) == 0) ) {
	encode = DTM_TRUE;
	qprint_growth += 2;
      }
      
      last_nl = cur + 1;
    }
    
  }
  
  // Deal with buffers that don't end with a new line.
  //
  if ((cur - last_nl) > 76) {
    encode = DTM_TRUE;
    qprint_growth += 2;
  }
  
  Encoding enc = MIME_7BIT;
  
  if (!strict_mime && !eight_bit && !seven_nonprinting) {
    // If strict_mime is off we only encode if we have 8 bit data
    // of most of the non-printing 7-bit characters
    //
    enc = MIME_7BIT;
  }
  else if (encode) {
    //
    // Strict_mime is TRUE and we have reason to encode.
    // Choose base64 if the charset is ISO-2022-JP (as per RFC 1468).
    // Otherwise, choose the most compact encoding.
    //
    if (strncasecmp(charset, "iso-2022-jp", strlen(charset)) == 0)
      enc = MIME_BASE64;
    else if (qprint_growth > base64_growth)
      enc = MIME_BASE64;
    else
      enc = MIME_QPRINT;
  }
  
  return(enc);
}

static inline int
mbisspace(int c)
{
    return((c & 0x7f) == c && isspace(c));
}

void
RFCMIME::rfc1522cpy(Buffer & buf, const char * value)
{
	Encoding enc;
	DtMailBoolean eight_bit = DTM_FALSE;
	DtMailBoolean strict_mime = DTM_FALSE;
	DtMailEnv error;
	DtMail::MailRc *mail_rc = _session->mailRc(error);
	const char *rc_value;
	char charset[64];
	char *from_cs = NULL, *to_cs = NULL, *convertbuf = NULL;
	int convert = 0;
	int word_len = 0, mb_ret = 0, cs_len = 0;
	unsigned long tmpcount = 0;


	getCharSet(charset);
	cs_len = strlen(charset);

    error.clear();
    mail_rc->getValue(error, "strictmime", &rc_value);
	if (error.isNotSet()) {
	  strict_mime = DTM_TRUE;
	}

    // We are going to encode 8 bit data, one word at a time. This may
    // not be the best possible algorithm, but it will get the correct
    // information in the header.
    //
    for (const char * cur = value; *cur; cur++) {

	// Skip over spaces
	if (mbisspace(*cur)) {
	    buf.appendData(cur, 1);
	    continue;
	}

        // Get a group of characters (encoded-word).
        // Ensure encoded-word is not more than 75 bytes - including charset,
	// encoding, encoded-text, and delimiters as per RFC 1522.
	// Encoded-word = "=?charset?encoding?encoded-text?="
	// 7 is "=?" and "?=" and two ? and Q or B for the encoding.
        word_len = cs_len + 7;

	const char *scan_c;
	for (scan_c = cur;
	     *scan_c && !mbisspace(*scan_c) && word_len <= 75;
		 scan_c++, word_len++) {
	    if (*scan_c != (*scan_c & 0x7f)) {
		// Here, we've come across a non 7bit byte.
		// Use mblen to get entire character.
		// If the number of bytes for the entire character can fit within
		// this group of text, then advance scan_c pointer, increase word_len,
		// and mark this group as eight_bit so encoding is performed.
		mb_ret = mblen(scan_c, MB_LEN_MAX);
		if ( (mb_ret >= 0) && (word_len + mb_ret <= 75) ) {
		  scan_c += mb_ret;
		  word_len += mb_ret;
		  eight_bit = DTM_TRUE;
		  // When for loop continues, scan_c and word_len get incremented by 1
		  scan_c -= 1;
		  word_len -= 1;
		}
	    mb_ret = 0;
		}
	}

	if (eight_bit == DTM_FALSE) {
	    // Simple! Copy the chars to the output.
	    buf.appendData(cur, scan_c - cur);
	    cur = scan_c - 1;
	}
	else {
	    // We have a word here. It has 8 bit data, so we will put
	    // it out as RFC1522 chunk.
	    //
	    BufferMemory tmp(1024);

	    buf.appendData("=?", 2);
	    buf.appendData(charset, strlen(charset));

	    // Do codeset conversion
	    convert = 0;
	    tmpcount = (unsigned long) (scan_c - cur);
	    convertbuf = (char*)calloc((unsigned int) tmpcount+1, sizeof(char));
	    memcpy(convertbuf, cur, (size_t)tmpcount);
	    from_cs = _session->locToConvName();
	    to_cs = _session->targetConvName();
	    convert = _session->csConvert(
					(char **)&convertbuf,
					tmpcount, 1,
	            			from_cs, to_cs);
	    if ( from_cs ) free( from_cs );
	    if ( to_cs ) free( to_cs );

	    if (convert)
	      enc = getHdrEncodingType(
					convertbuf,
					(unsigned int) tmpcount,
					strict_mime, charset);
	    else
	      enc = getHdrEncodingType(cur, scan_c-cur, strict_mime, charset);
	    
	    // Do transfer encoding
	    switch (enc) {
	    case MIME_BASE64:
		buf.appendData("?b?", 3);
		if (convert) {
		    writeBase64(tmp, convertbuf, tmpcount);
		} else {
		    writeBase64(tmp, cur, scan_c - cur);
		}
		break;
	    case MIME_QPRINT:
		buf.appendData("?q?", 3);
		if (convert) {
		    writeQPrint(tmp, convertbuf, tmpcount);
		} else {
		    writeQPrint(tmp, cur, scan_c - cur);
		}
		break;
	    }

	    char * cp_buf = new char[tmp.getSize()];
	    BufReader * reader = tmp.getReader();

	    reader->getData(cp_buf, tmp.getSize());
	    delete reader;

	    char *tw;
	    for (tw = &cp_buf[tmp.getSize() - 1];
		 tw > cp_buf && isspace((unsigned char)*tw); tw--) {
		continue;
	    }

	    tw += 1;
	    *tw = 0;

	    buf.appendData(cp_buf, strlen(cp_buf));
	    delete [] cp_buf;

	    buf.appendData("?=", 2);

	    cur = scan_c - 1;

	    eight_bit = DTM_FALSE;
	}
    }

    crlf(buf);
}

// For OW Mailtool compatibility so that MIME mail with attachment(s) sent
// via dtmail will have OW Mailtool understandable message header identifying 
// attachment type so that OW Mailtool can display the correct attachment icon
// and invoke the correct double-click operation.
// RFCMIME::owCompat()
// Given the attribute type, get the attribute's SUNV3_TYPE, if SUNV3_TYPE
// exists, put out X-Sun-Data-Type header and SUNV3_TYPE value.
// If no type is given or there is no SUNV3_TYPE for the given attribute,
// then re-type content.
void
RFCMIME::owCompat(Buffer & buf,
         char *type,
         char *name,
         char *bp_contents,
         unsigned long bp_len)
{
    char *v3type = NULL;

    if (type) {
	   v3type = (char *)DtDtsDataTypeToAttributeValue(type,
						 "SUNV3_TYPE",
						 NULL);
	}
	if (!type || !v3type)
	{
	   char *buf_type;
	   buf_type = DtDtsBufferToDataType(bp_contents, (int) bp_len, name);
	   if (buf_type)
	   {
	       v3type = (char *)DtDtsDataTypeToAttributeValue(
							buf_type,
							"SUNV3_TYPE",
							NULL);
	       DtDtsFreeDataType(buf_type);
	   }
	}

	if (v3type) {
	   buf.appendData("X-Sun-Data-Type: ", 17);
	   buf.appendData(v3type, strlen(v3type));
	   crlf(buf);
	   DtDtsFreeAttributeValue(v3type);
	}
}