/*
* Copyright (C) 2000 Helix Code Inc.
*
* Authors: Michael Zucchi <notzed@helixcode.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library 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 Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "camel-mime-filter-bestenc.h"
static void camel_mime_filter_bestenc_class_init (CamelMimeFilterBestencClass *klass);
static void camel_mime_filter_bestenc_init (CamelMimeFilter *obj);
static CamelMimeFilterClass *camel_mime_filter_bestenc_parent;
CamelType
camel_mime_filter_bestenc_get_type (void)
{
static CamelType type = CAMEL_INVALID_TYPE;
if (type == CAMEL_INVALID_TYPE) {
type = camel_type_register (camel_mime_filter_get_type (), "CamelMimeFilterBestenc",
sizeof (CamelMimeFilterBestenc),
sizeof (CamelMimeFilterBestencClass),
(CamelObjectClassInitFunc) camel_mime_filter_bestenc_class_init,
NULL,
(CamelObjectInitFunc) camel_mime_filter_bestenc_init,
NULL);
}
return type;
}
static void
reset(CamelMimeFilter *mf)
{
CamelMimeFilterBestenc *f = (CamelMimeFilterBestenc *)mf;
f->count0 = 0;
f->count8 = 0;
f->countline = 0;
f->total = 0;
f->lastc = ~0;
f->crlfnoorder = FALSE;
camel_charset_init(&f->charset);
}
static void
filter(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, size_t *outlen, size_t *outprespace)
{
CamelMimeFilterBestenc *f = (CamelMimeFilterBestenc *)mf;
register unsigned char *p, *pend;
f->total += len;
if (f->flags & CAMEL_BESTENC_GET_ENCODING) {
register unsigned int /* hopefully reg's are assinged in the order they appear? */
c,
lastc=f->lastc,
countline=f->countline,
count0=f->count0,
count8 = f->count8;
/* See rfc2045 section 2 for definitions of 7bit/8bit/binary */
p = in;
pend = p + len;
while (p<pend) {
c = *p++;
/* check for 8 bit characters */
if (c & 0x80)
count8++;
/* check for nul's */
if (c == 0)
count0++;
/* check for wild '\r's in a unix format stream */
if (c == '\r' && (f->flags & CAMEL_BESTENC_LF_IS_CRLF)) {
f->crlfnoorder = TRUE;
}
/* check for end of line */
if (c == '\n') {
/* check for wild '\n's in canonical format stream */
if (lastc == '\r' || (f->flags & CAMEL_BESTENC_LF_IS_CRLF)) {
if (countline > f->maxline)
f->maxline = countline;
countline = 0;
} else {
f->crlfnoorder = TRUE;
}
} else {
countline++;
}
lastc = c;
}
f->count8 = count8;
f->count0 = count0;
f->countline = countline;
f->lastc = lastc;
}
if (f->flags & CAMEL_BESTENC_GET_CHARSET)
camel_charset_step(&f->charset, in, len);
*out = in;
*outlen = len;
*outprespace = prespace;
}
static void
complete(CamelMimeFilter *mf, char *in, size_t len, size_t prespace, char **out, size_t *outlen, size_t *outprespace)
{
CamelMimeFilterBestenc *f = (CamelMimeFilterBestenc *)mf;
filter(mf, in, len, prespace, out, outlen, outprespace);
if (f->countline > f->maxline)
f->maxline = f->countline;
f->countline = 0;
}
static void
camel_mime_filter_bestenc_class_init (CamelMimeFilterBestencClass *klass)
{
CamelMimeFilterClass *filter_class = (CamelMimeFilterClass *) klass;
camel_mime_filter_bestenc_parent = (CamelMimeFilterClass *)(camel_type_get_global_classfuncs (camel_mime_filter_get_type ()));
filter_class->reset = reset;
filter_class->filter = filter;
filter_class->complete = complete;
}
static void
camel_mime_filter_bestenc_init (CamelMimeFilter *f)
{
reset(f);
}
/**
* camel_mime_filter_bestenc_new:
* @flags: A bitmask of data required.
*
* Create a new CamelMimeFilterBestenc object.
*
* Return value:
**/
CamelMimeFilterBestenc *
camel_mime_filter_bestenc_new (unsigned int flags)
{
CamelMimeFilterBestenc *new = (CamelMimeFilterBestenc *)camel_object_new(camel_mime_filter_bestenc_get_type());
new->flags = flags;
return new;
}
/**
* camel_mime_filter_bestenc_get_best_encoding:
* @f:
* @required: maximum level of output encoding allowed.
*
* Return the best encoding, given specific constraints, that can be used to
* encode a stream of bytes.
*
* Return value:
**/
CamelMimePartEncodingType
camel_mime_filter_bestenc_get_best_encoding(CamelMimeFilterBestenc *f, CamelBestencEncoding required)
{
CamelMimePartEncodingType bestenc;
#if 0
printf("count0 = %d, count8 = %d, total = %d\n", f->count0, f->count8, f->total);
printf("maxline = %d, crlfnoorder = %s\n", f->maxline, f->crlfnoorder?"TRUE":"FALSE");
printf(" %d%% require encoding?\n", (f->count0+f->count8)*100 / f->total);
#endif
/* if we need to encode, see how we do it */
if (required == CAMEL_BESTENC_BINARY)
bestenc = CAMEL_MIME_PART_ENCODING_BINARY;
else if (f->count8 + f->count0 >= (f->total*17/100))
bestenc = CAMEL_MIME_PART_ENCODING_BASE64;
else
bestenc = CAMEL_MIME_PART_ENCODING_QUOTEDPRINTABLE;
/* if we have nocrlf order, or long lines, we need to encode always */
if (f->crlfnoorder || f->maxline >= 998)
return bestenc;
/* if we have no 8 bit chars or nul's, we can just use 7 bit */
if (f->count8 + f->count0 == 0)
return CAMEL_MIME_PART_ENCODING_7BIT;
/* otherwise, we see if we can use 8 bit, or not */
switch(required) {
case CAMEL_BESTENC_7BIT:
return bestenc;
case CAMEL_BESTENC_8BIT:
case CAMEL_BESTENC_BINARY:
if (f->count0 == 0)
return CAMEL_MIME_PART_ENCODING_8BIT;
else
return bestenc;
}
return CAMEL_MIME_PART_ENCODING_DEFAULT;
}
/**
* camel_mime_filter_bestenc_get_best_charset:
* @f:
*
* Gets the best charset that can be used to contain this content.
*
* Return value:
**/
const char *
camel_mime_filter_bestenc_get_best_charset(CamelMimeFilterBestenc *f)
{
return camel_charset_best_name(&f->charset);
}
/**
* camel_mime_filter_bestenc_set_flags:
* @f:
* @flags:
*
* Set the flags for subsequent operations.
**/
void
camel_mime_filter_bestenc_set_flags(CamelMimeFilterBestenc *f, unsigned int flags)
{
f->flags = flags;
}
