/*

  *  Copyright (C) 2013-2019 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
  *  Copyright (C) 2007-2013 Sourcefire, Inc.

  *
  *  Authors: Nigel Horne

  *
  *  This program is free software; you can redistribute it and/or modify

  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.

  *
  *  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., 51 Franklin Street, Fifth Floor, Boston,
  *  MA 02110-1301, USA.

  *
  * TODO: Optimise messageExport, decodeLine, messageIsEncoding

  */

 
 #if HAVE_CONFIG_H
 #include "clamav-config.h"
 #endif

 
 #ifdef CL_THREAD_SAFE

 #ifndef _REENTRANT
 #define _REENTRANT /* for Solaris 2.8 */

 #endif

 #endif

 #ifdef C_DARWIN

 #include <sys/types.h>
 #endif
 #include <stdlib.h>
 #include <string.h>

 #ifdef HAVE_STRINGS_H

 #include <strings.h>

 #endif

 #include <assert.h>
 #include <ctype.h>
 #include <stdio.h>
 

 #ifdef CL_THREAD_SAFE

 #include <pthread.h>
 #endif
 

 #include "others.h"
 #include "str.h"
 #include "filetypes.h"
 

 #include "mbox.h"

 #include "clamav.h"

 #include "json_api.h"

 #ifndef isblank

 #define isblank(c) (((c) == ' ') || ((c) == '\t'))

 #endif
 

 #define RFC2045LENGTH 76 /* maximum number of characters on a line */

 #ifdef HAVE_STDBOOL_H

 #include <stdbool.h>
 #else

 #ifdef FALSE
 typedef unsigned char bool;

 #else

 typedef enum { FALSE = 0,
                TRUE  = 1 } bool;

 #endif
 #endif

 static int messageHasArgument(const message *m, const char *variable);
 static void messageIsEncoding(message *m);

 static unsigned char *decode(message *m, const char *in, unsigned char *out, unsigned char (*decoder)(char), bool isFast);

 static void sanitiseBase64(char *s);
 #ifdef __GNUC__
 static unsigned char hex(char c) __attribute__((const));
 static unsigned char base64(char c) __attribute__((const));
 static unsigned char uudecode(char c) __attribute__((const));

 #else

 static unsigned char hex(char c);
 static unsigned char base64(char c);
 static unsigned char uudecode(char c);

 #endif

 static const char *messageGetArgument(const message *m, int arg);
 static void *messageExport(message *m, const char *dir, void *(*create)(void), void (*destroy)(void *), void (*setFilename)(void *, const char *, const char *), void (*addData)(void *, const unsigned char *, size_t), void *(*exportText)(text *, void *, int), void (*setCTX)(void *, cli_ctx *), int destroy_text);
 static int usefulArg(const char *arg);
 static void messageDedup(message *m);
 static char *rfc2231(const char *in);
 static int simil(const char *str1, const char *str2);

 
 /*

  * These maps are ordered in decreasing likelihood of their appearance

  * in an e-mail. Probably these should be in a table...

  */

 static const struct encoding_map {
     const char *string;
     encoding_type type;
 } encoding_map[] = {/* rfc2045 */
                     {"7bit", NOENCODING},
                     {"text/plain", NOENCODING},
                     {"quoted-printable", QUOTEDPRINTABLE}, /* rfc2045 */
                     {"base64", BASE64},                    /* rfc2045 */
                     {"8bit", EIGHTBIT},
                     {"binary", BINARY},
                     {"x-uuencode", UUENCODE}, /* uuencode(5) */
                     {"x-yencode", YENCODE},
                     {"x-binhex", BINHEX},
                     {"us-ascii", NOENCODING}, /* incorrect */
                     {"x-uue", UUENCODE},      /* incorrect */
                     {"uuencode", UUENCODE},   /* incorrect */
                     {NULL, NOENCODING}};
 
 static const struct mime_map {
     const char *string;
     mime_type type;

 } mime_map[] = {

     {"text", TEXT},
     {"multipart", MULTIPART},
     {"application", APPLICATION},
     {"audio", AUDIO},
     {"image", IMAGE},
     {"message", MESSAGE},
     {"video", VIDEO},
     {NULL, TEXT}};

 /*
  * See RFC2045, section 6.8, table 1
  */

 static const unsigned char base64Table[256] = {

     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
     52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0, 255, 255,
     255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
     255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
     41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255};

 message *
 messageCreate(void)
 {

     message *m = (message *)cli_calloc(1, sizeof(message));

     if (m)
         m->mimeType = NOMIME;

     return m;

 }
 

 void messageDestroy(message *m)

 {

     assert(m != NULL);

     messageReset(m);

     free(m);

 }
 

 void messageReset(message *m)

 {

     int i;

     assert(m != NULL);

     if (m->mimeSubtype)
         free(m->mimeSubtype);

     if (m->mimeDispositionType)
         free(m->mimeDispositionType);

     if (m->mimeArguments) {
         for (i = 0; i < m->numberOfArguments; i++)
             free(m->mimeArguments[i]);
         free(m->mimeArguments);
     }

     if (m->body_first)
         textDestroy(m->body_first);

     assert(m->base64chars == 0);

     if (m->encodingTypes) {
         assert(m->numberOfEncTypes > 0);
         free(m->encodingTypes);
     }

 #if HAVE_JSON

     if (m->jobj)
         cli_json_delobj(m->jobj);

 #endif
 

     memset(m, '\0', sizeof(message));
     m->mimeType = NOMIME;

 }
 

 /*

  * Handle the Content-Type header. The syntax is in RFC1341.

  * Return success (1) or failure (0). Failure only happens when it's an
  * unknown type and we've already received a known type, or we've received an
  * empty type. If we receive an unknown type by itself we default to application

  */

 int messageSetMimeType(message *mess, const char *type)

 {

 #ifdef CL_THREAD_SAFE
     static pthread_mutex_t mime_mutex = PTHREAD_MUTEX_INITIALIZER;

 #endif

     const struct mime_map *m;
     int typeval;
     static table_t *mime_table;
 
     assert(mess != NULL);
     if (type == NULL) {
         cli_dbgmsg("Empty content-type field\n");
         return 0;
     }

     cli_dbgmsg("messageSetMimeType: '%s'\n", type);

     /* Ignore leading spaces */
     while (!isalpha(*type))
         if (*type++ == '\0')
             return 0;

 #ifdef CL_THREAD_SAFE
     pthread_mutex_lock(&mime_mutex);

 #endif

     if (mime_table == NULL) {
         mime_table = tableCreate();
         if (mime_table == NULL) {
 #ifdef CL_THREAD_SAFE
             pthread_mutex_unlock(&mime_mutex);

 #endif

             return 0;
         }
 
         for (m = mime_map; m->string; m++)
             if (!tableInsert(mime_table, m->string, m->type)) {
                 tableDestroy(mime_table);
                 mime_table = NULL;
 #ifdef CL_THREAD_SAFE
                 pthread_mutex_unlock(&mime_mutex);

 #endif

                 return 0;
             }
     }
 #ifdef CL_THREAD_SAFE
     pthread_mutex_unlock(&mime_mutex);

 #endif

     typeval = tableFind(mime_table, type);

     if (typeval != -1) {
         mess->mimeType = (mime_type)typeval;
         return 1;
     }
     if (mess->mimeType == NOMIME) {
         if (strncasecmp(type, "x-", 2) == 0)
             mess->mimeType = MEXTENSION;
         else {
             /*

 			 * Force scanning of strange messages
 			 */

             if (strcasecmp(type, "plain") == 0) {
                 cli_dbgmsg("Incorrect MIME type: `plain', set to Text\n");
                 mess->mimeType = TEXT;
             } else {
                 /*

 				 * Don't handle broken e-mail probably sending
 				 *	Content-Type: plain/text
 				 * instead of
 				 *	Content-Type: text/plain
 				 * as an attachment
 				 */

                 int highestSimil = 0, t = -1;
                 const char *closest = NULL;
 
                 for (m = mime_map; m->string; m++) {
                     const int s = simil(m->string, type);
 
                     if (s > highestSimil) {
                         highestSimil = s;
                         closest      = m->string;
                         t            = m->type;
                     }
                 }
                 if (highestSimil >= 50) {
                     cli_dbgmsg("Unknown MIME type \"%s\" - guessing as %s (%d%% certainty)\n",
                                type, closest,
                                highestSimil);
                     mess->mimeType = (mime_type)t;
                 } else {
                     cli_dbgmsg("Unknown MIME type: `%s', set to Application - if you believe this file contains a virus, submit it to www.clamav.net\n", type);
                     mess->mimeType = APPLICATION;
                 }
             }
         }
         return 1;
     }
     return 0;

 }
 
 mime_type
 messageGetMimeType(const message *m)
 {

     assert(m != NULL);

     return m->mimeType;

 }
 

 void messageSetMimeSubtype(message *m, const char *subtype)

 {

     assert(m != NULL);

     if (subtype == NULL) {
         /*

 		 * Handle broken content-type lines, e.g.
 		 *	Content-Type: text/
 		 */

         cli_dbgmsg("Empty content subtype\n");
         subtype = "";
     }

     if (m->mimeSubtype)
         free(m->mimeSubtype);

     m->mimeSubtype = cli_strdup(subtype);

 }
 
 const char *
 messageGetMimeSubtype(const message *m)
 {

     return (m->mimeSubtype) ? m->mimeSubtype : "";

 }
 

 void messageSetDispositionType(message *m, const char *disptype)

 {

     assert(m != NULL);

     if (m->mimeDispositionType)
         free(m->mimeDispositionType);
     if (disptype == NULL) {
         m->mimeDispositionType = NULL;
         return;
     }

     /*

 	 * It's broken for there to be an entry such as "Content-Disposition:"
 	 * However some spam and viruses are rather broken, it's a sign
 	 * that something is wrong if we get that - maybe we should force a
 	 * scan of this part
 	 */

     while (*disptype && isspace((int)*disptype))
         disptype++;
     if (*disptype) {
         m->mimeDispositionType = cli_strdup(disptype);
         if (m->mimeDispositionType)
             strstrip(m->mimeDispositionType);
     } else
         m->mimeDispositionType = NULL;

 }
 
 const char *
 messageGetDispositionType(const message *m)
 {

     return (m->mimeDispositionType) ? m->mimeDispositionType : "";

 }
 
 /*
  * TODO:
  *	Arguments are held on a per message basis, they should be held on
  * a per section basis. Otherwise what happens if two sections have two
  * different values for charset? Probably doesn't matter for the use this
  * code will be given, but will need fixing if this code is used elsewhere
  */

 void messageAddArgument(message *m, const char *arg)

 {

     int offset;
     char *p;

     assert(m != NULL);

     if (arg == NULL)
         return; /* Note: this is not an error condition */

     while (isspace(*arg))
         arg++;

     if (*arg == '\0')
         /* Empty argument? Probably a broken mail client... */
         return;

     cli_dbgmsg("messageAddArgument, arg='%s'\n", arg);

     if (!usefulArg(arg))
         return;

     for (offset = 0; offset < m->numberOfArguments; offset++)
         if (m->mimeArguments[offset] == NULL)
             break;
         else if (strcasecmp(arg, m->mimeArguments[offset]) == 0)
             return; /* already in there */

     if (offset == m->numberOfArguments) {
         char **q;

         m->numberOfArguments++;
         q = (char **)cli_realloc(m->mimeArguments, m->numberOfArguments * sizeof(char *));
         if (q == NULL) {
             m->numberOfArguments--;
             return;
         }
         m->mimeArguments = q;
     }

     p = m->mimeArguments[offset] = rfc2231(arg);
     if (!p) {
         /* problem inside rfc2231() */
         cli_dbgmsg("messageAddArgument, error from rfc2231()\n");
         return;
     }

     if (strchr(p, '=') == NULL) {
         if (strncmp(p, "filename", 8) == 0) {
             /*

 			 * FIXME: Bounce message handling is corrupting the in
 			 * core copies of headers
 			 */

             if (strlen(p) > 8) {
                 cli_dbgmsg("Possible data corruption fixed\n");
                 p[8] = '=';
             } else {
                 cli_dbgmsg("Possible data corruption not fixed\n");
             }
         } else {
             if (*p)
                 cli_dbgmsg("messageAddArgument, '%s' contains no '='\n", p);
             free(m->mimeArguments[offset]);
             m->mimeArguments[offset] = NULL;
             return;
         }
     }
 
     /*

 	 * This is terribly broken from an RFC point of view but is useful
 	 * for catching viruses which have a filename but no type of
 	 * mime. By pretending defaulting to an application rather than
 	 * to nomime we can ensure they're saved and scanned
 	 */

     if ((strncasecmp(p, "filename=", 9) == 0) || (strncasecmp(p, "name=", 5) == 0))
         if (messageGetMimeType(m) == NOMIME) {
             cli_dbgmsg("Force mime encoding to application\n");
             messageSetMimeType(m, "application");
         }

 }
 
 /*
  * Add in all the arguments.
  * Cope with:
  *	name="foo bar.doc"
  *	charset=foo name=bar
  */

 void messageAddArguments(message *m, const char *s)

 {

     const char *string = s;

     cli_dbgmsg("Add arguments '%s'\n", string);

     assert(string != NULL);

     while (*string) {
         const char *key, *cptr;
         char *data, *field;
         size_t datasz = 0;

         if (isspace(*string & 0xff) || (*string == ';')) {
             string++;
             continue;
         }

         key = string;

         data = strchr(string, '=');

         /*

 		 * Some spam breaks RFC2045 by using ':' instead of '='

 		 * e.g.:
 		 *	Content-Type: text/html; charset:ISO-8859-1
 		 * should be:
 		 *	Content-type: text/html; charset=ISO-8859-1
 		 *
 		 * We give up with lines that are completely broken because
 		 * we don't have ESP and don't know what was meant to be there.
 		 * It's unlikely to really be a problem.
 		 */

         if (data == NULL)
             data = strchr(string, ':');

         if (data == NULL) {
             /*

 			 * Completely broken, give up
 			 */

             cli_dbgmsg("Can't parse header \"%s\"\n", s);
             return;
         }

         string = &data[1];

         /*

 		 * Handle white space to the right of the equals sign

 		 * This breaks RFC2045 which has:

 		 *	parameter := attribute "=" value
 		 *	attribute := token   ; case-insensitive
 		 *	token  :=  1*<any (ASCII) CHAR except SPACE, CTLs,
 		 *		or tspecials>
 		 * But too many MUAs ignore this

 		 */

         while (isspace(*string) && (*string != '\0'))
             string++;

         cptr = string;

         if (*string)
             string++;

         if (*cptr == '"') {
             char *ptr, *kcopy;

             /*

 			 * The field is in quotes, so look for the
 			 * closing quotes
 			 */

             kcopy = cli_strdup(key);

             if (kcopy == NULL)
                 return;

             ptr = strchr(kcopy, '=');
             if (ptr == NULL) {
                 ptr = strchr(kcopy, ':');

                 if (ptr == NULL) {
                     cli_dbgmsg("Can't parse header \"%s\"\n", s);

                     free(kcopy);

                     return;
                 }
             }
 

             *ptr = '\0';

             string = strchr(++cptr, '"');

             if (string == NULL) {
                 cli_dbgmsg("Unbalanced quote character in \"%s\"\n", s);
                 string = "";
             } else
                 string++;

             if (!usefulArg(kcopy)) {
                 free(kcopy);
                 continue;
             }

             data = cli_strdup(cptr);

             if (!data) {
                 cli_dbgmsg("Can't parse header \"%s\" - if you believe this file contains a missed virus, report it to bugs@clamav.net\n", s);

                 free(kcopy);

                 return;
             }

             ptr = strchr(data, '"');

             if (ptr == NULL) {
                 /*

 				 * Weird e-mail header such as:
 				 * Content-Type: application/octet-stream; name="
 				 * "
 				 * Content-Transfer-Encoding: base64
 				 * Content-Disposition: attachment; filename="
 				 * "
 				 *

 				 * Use the end of line as data.

 				 */

             } else
                 *ptr = '\0';

             datasz = strlen(kcopy) + strlen(data) + 2;

             field  = cli_realloc(kcopy, strlen(kcopy) + strlen(data) + 2);
             if (field) {

                 cli_strlcat(field, "=", datasz);
                 cli_strlcat(field, data, datasz);

             } else {
                 free(kcopy);

             }

             free(data);
         } else {
             size_t len;

             if (*cptr == '\0') {
                 cli_dbgmsg("Ignoring empty field in \"%s\"\n", s);
                 return;
             }

             /*

 			 * The field is not in quotes, so look for the closing
 			 * white space
 			 */

             while ((*string != '\0') && !isspace(*string))
                 string++;
 
             len   = (size_t)string - (size_t)key + 1;
             field = cli_malloc(len);
 
             if (field) {
                 memcpy(field, key, len - 1);
                 field[len - 1] = '\0';
             }
         }
         if (field) {
             messageAddArgument(m, field);
             free(field);
         }
     }

 }
 
 static const char *
 messageGetArgument(const message *m, int arg)
 {

     assert(m != NULL);
     assert(arg >= 0);
     assert(arg < m->numberOfArguments);

     return (m->mimeArguments[arg]) ? m->mimeArguments[arg] : "";

 }
 
 /*
  * Find a MIME variable from the header and return a COPY to the value of that
  * variable. The caller must free the copy
  */

 char *

 messageFindArgument(const message *m, const char *variable)
 {

     int i;
     size_t len;

     assert(m != NULL);
     assert(variable != NULL);

     len = strlen(variable);

     for (i = 0; i < m->numberOfArguments; i++) {
         const char *ptr;

         ptr = messageGetArgument(m, i);
         if ((ptr == NULL) || (*ptr == '\0'))
             continue;
 #ifdef CL_DEBUG
         cli_dbgmsg("messageFindArgument: compare %lu bytes of %s with %s\n",
                    (unsigned long)len, variable, ptr);

 #endif

         if (strncasecmp(ptr, variable, len) == 0) {
             ptr = &ptr[len];
             while (isspace(*ptr))
                 ptr++;
             if (*ptr != '=') {
                 cli_dbgmsg("messageFindArgument: no '=' sign found in MIME header '%s' (%s)\n", variable, messageGetArgument(m, i));
                 return NULL;
             }
             ptr++;
             if ((strlen(ptr) > 1) && (*ptr == '"') && (strchr(&ptr[1], '"') != NULL)) {
                 /* Remove any quote characters */
                 char *ret = cli_strdup(++ptr);
                 char *p;
 
                 if (ret == NULL)
                     return NULL;
 
                 /*

 				 * fix un-quoting of boundary strings from
 				 * header, occurs if boundary was given as
 				 *	'boundary="_Test_";'
 				 *
 				 * At least two quotes in string, assume
 				 * quoted argument
 				 * end string at next quote
 				 */

                 if ((p = strchr(ret, '"')) != NULL) {
                     ret[strlen(ret) - 1] = '\0';
                     *p                   = '\0';
                 }
                 return ret;
             }
             return cli_strdup(ptr);
         }
     }
     return NULL;

 }
 

 char *
 messageGetFilename(const message *m)
 {

     char *filename = (char *)messageFindArgument(m, "filename");

     if (filename)
         return filename;

     return (char *)messageFindArgument(m, "name");

 }
 

 /* Returns true or false */
 static int
 messageHasArgument(const message *m, const char *variable)
 {

     int i;
     size_t len;

     assert(m != NULL);
     assert(variable != NULL);

     len = strlen(variable);

     for (i = 0; i < m->numberOfArguments; i++) {
         const char *ptr;

         ptr = messageGetArgument(m, i);
         if ((ptr == NULL) || (*ptr == '\0'))
             continue;
 #ifdef CL_DEBUG
         cli_dbgmsg("messageHasArgument: compare %lu bytes of %s with %s\n",
                    (unsigned long)len, variable, ptr);

 #endif

         if (strncasecmp(ptr, variable, len) == 0) {
             ptr = &ptr[len];
             while (isspace(*ptr))
                 ptr++;
             if (*ptr != '=') {
                 cli_dbgmsg("messageHasArgument: no '=' sign found in MIME header '%s' (%s)\n", variable, messageGetArgument(m, i));
                 return 0;
             }
             return 1;
         }
     }
     return 0;

 }
 

 int messageHasFilename(const message *m)

 {

     return messageHasArgument(m, "filename") || messageHasArgument(m, "file");

 }
 

 void messageSetEncoding(message *m, const char *enctype)

 {

     const struct encoding_map *e;
     int i;
     char *type;

     assert(m != NULL);
     assert(enctype != NULL);

     /*m->encodingType = EEXTENSION;*/

     while (isblank(*enctype))
         enctype++;

     cli_dbgmsg("messageSetEncoding: '%s'\n", enctype);

     if (strcasecmp(enctype, "8 bit") == 0) {
         cli_dbgmsg("Broken content-transfer-encoding: '8 bit' changed to '8bit'\n");
         enctype = "8bit";
     }

     /*

 	 * Iterate through
 	 *	Content-Transfer-Encoding: base64 binary
 	 * cli_strtok's fieldno counts from 0
 	 */

     i = 0;
     while ((type = cli_strtok(enctype, i++, " \t")) != NULL) {
         int highestSimil    = 0;
         const char *closest = NULL;

         for (e = encoding_map; e->string; e++) {
             int sim;
             const char lowertype = tolower(type[0]);

             if ((lowertype != tolower(e->string[0])) && (lowertype != 'x'))
                 /*

 				 * simil is expensive, I'm yet to encounter only
 				 * one example of a missent encoding when the
 				 * first character was wrong, so lets assume no
 				 * match to save the call.
 				 *
 				 * That example was quoted-printable sent as
 				 * X-quoted-printable.
 				 */

                 continue;

             if (strcmp(e->string, "uuencode") == 0)
                 /*

 				 * No need to test here - fast track visa will have
 				 * handled uuencoded files
 				 */

                 continue;

             sim = simil(type, e->string);

             if (sim == 100) {
                 int j;
                 encoding_type *et;

                 for (j = 0; j < m->numberOfEncTypes; j++)
                     if (m->encodingTypes[j] == e->type)
                         break;

                 if (j < m->numberOfEncTypes) {
                     cli_dbgmsg("Ignoring duplicate encoding mechanism '%s'\n",
                                type);
                     break;
                 }

                 et = (encoding_type *)cli_realloc(m->encodingTypes, (m->numberOfEncTypes + 1) * sizeof(encoding_type));
                 if (et == NULL)
                     break;

                 m->encodingTypes                        = et;
                 m->encodingTypes[m->numberOfEncTypes++] = e->type;

                 cli_dbgmsg("Encoding type %d is \"%s\"\n", m->numberOfEncTypes, type);
                 break;
             } else if (sim > highestSimil) {
                 closest      = e->string;
                 highestSimil = sim;
             }
         }

         if (e->string == NULL) {
             /*

 			 * The stated encoding type is illegal, so we
 			 * use a best guess of what it should be.
 			 *

 			 * 50% is arbitrary. For example 7bi will match as

 			 * 66% certain to be 7bit

 			 */

             if (highestSimil >= 50) {
                 cli_dbgmsg("Unknown encoding type \"%s\" - guessing as %s (%u%% certainty)\n",
                            type, closest, highestSimil);
                 messageSetEncoding(m, closest);
             } else {
                 cli_dbgmsg("Unknown encoding type \"%s\" - if you believe this file contains a virus, submit it to www.clamav.net\n", type);
                 /*

 				 * Err on the side of safety, enable all
 				 * decoding modules
 				 */

                 messageSetEncoding(m, "base64");
                 messageSetEncoding(m, "quoted-printable");
             }
         }

         free(type);
     }

 }
 
 encoding_type
 messageGetEncoding(const message *m)
 {

     assert(m != NULL);

     if (m->numberOfEncTypes == 0)
         return NOENCODING;
     return m->encodingTypes[0];

 }
 

 int messageAddLine(message *m, line_t *line)

 {

     assert(m != NULL);

     if (m->body_first == NULL)
         m->body_last = m->body_first = (text *)cli_malloc(sizeof(text));
     else {
         m->body_last->t_next = (text *)cli_malloc(sizeof(text));
         m->body_last         = m->body_last->t_next;
     }

     if (m->body_last == NULL) {

         cli_errmsg("messageAddLine: out of memory for m->body_last\n");

         return -1;

     }

     m->body_last->t_next = NULL;

     if (line && lineGetData(line)) {
         m->body_last->t_line = lineLink(line);

         messageIsEncoding(m);
     } else
         m->body_last->t_line = NULL;

     return 1;

 }
 

 /*

  * Add the given line to the end of the given message

  * If needed a copy of the given line is taken which the caller must free

  * Line must not be terminated by a \n

  */

 int messageAddStr(message *m, const char *data)

 {

     line_t *repeat = NULL;

     assert(m != NULL);

     if (data) {
         if (*data == '\0')
             data = NULL;
         else {
             /*

 			 * If it's only white space, just store one space to
 			 * save memory. You must store something since it may
 			 * be a header line
 			 */

             int iswhite = 1;
             const char *p;
 
             for (p = data; *p; p++)
                 if (((*p) & 0x80) || !isspace(*p)) {
                     iswhite = 0;
                     break;
                 }
             if (iswhite) {
                 /*cli_dbgmsg("messageAddStr: empty line: '%s'\n", data);*/
                 data = " ";
             }
         }
     }
 
     if (m->body_first == NULL)
         m->body_last = m->body_first = (text *)cli_malloc(sizeof(text));
     else {
         assert(m->body_last != NULL);
         if ((data == NULL) && (m->body_last->t_line == NULL))
             /*

 			 * Although this would save time and RAM, some
 			 * phish signatures have been built which need the
 			 * blank lines
 			 */

             if (messageGetMimeType(m) != TEXT)
                 /* don't save two blank lines in succession */
                 return 1;
 
         m->body_last->t_next = (text *)cli_malloc(sizeof(text));
         if (m->body_last->t_next == NULL) {
             messageDedup(m);
             m->body_last->t_next = (text *)cli_malloc(sizeof(text));
             if (m->body_last->t_next == NULL) {
                 cli_errmsg("messageAddStr: out of memory\n");
                 return -1;
             }
         }

         if (data && m->body_last->t_line && (strcmp(data, lineGetData(m->body_last->t_line)) == 0))
             repeat = m->body_last->t_line;
         m->body_last = m->body_last->t_next;
     }
 
     if (m->body_last == NULL) {
         cli_errmsg("messageAddStr: out of memory\n");
         return -1;
     }
 
     m->body_last->t_next = NULL;
 
     if (data && *data) {
         if (repeat)
             m->body_last->t_line = lineLink(repeat);
         else {
             m->body_last->t_line = lineCreate(data);
 
             if (m->body_last->t_line == NULL) {
                 messageDedup(m);
                 m->body_last->t_line = lineCreate(data);
 
                 if (m->body_last->t_line == NULL) {
                     cli_errmsg("messageAddStr: out of memory\n");
                     return -1;
                 }
             }
             /* cli_chomp(m->body_last->t_text); */
             messageIsEncoding(m);
         }
     } else
         m->body_last->t_line = NULL;
 
     return 1;

 }
 

 /*

  * Add the given line to the start of the given message
  * A copy of the given line is taken which the caller must free
  * Line must not be terminated by a \n
  */

 int messageAddStrAtTop(message *m, const char *data)

 {

     text *oldfirst;

     assert(m != NULL);

     if (m->body_first == NULL)
         return messageAddLine(m, lineCreate(data));

     oldfirst      = m->body_first;
     m->body_first = (text *)cli_malloc(sizeof(text));
     if (m->body_first == NULL) {
         m->body_first = oldfirst;
         return -1;
     }

     m->body_first->t_next = oldfirst;
     m->body_first->t_line = lineCreate((data) ? data : "");

     if (m->body_first->t_line == NULL) {
         cli_errmsg("messageAddStrAtTop: out of memory\n");
         return -1;
     }
     return 1;

 }
 
 /*

  * Put the contents of the given text at the end of the current object.
  * Can be used either to move a text object into a message, or to move a
  * message's text into another message only moving from a given offset.
  * The given text emptied; it can be used again if needed, though be warned that
  * it will have an empty line at the start.
  * Returns 0 for failure, 1 for success
  */

 int messageMoveText(message *m, text *t, message *old_message)

 {

     int rc;

     if (m->body_first == NULL) {
         if (old_message) {
             text *u;
             /*

 			 * t is within old_message which is about to be
 			 * destroyed
 			 */

             assert(old_message->body_first != NULL);
 
             m->body_first = t;
             for (u = old_message->body_first; u != t;) {
                 text *next;
 
                 if (u->t_line) {
                     lineUnlink(u->t_line);
                     u->t_line = NULL;
                 }
                 next = u->t_next;

                 free(u);
                 u = next;
 
                 if (u == NULL) {
                     cli_dbgmsg("messageMoveText sanity check: t not within old_message\n");
                     return -1;
                 }
             }
             assert(old_message->body_last->t_next == NULL);
 
             m->body_last            = old_message->body_last;
             old_message->body_first = old_message->body_last = NULL;
 
             /* Do any pointers need to be reset? */
             if ((old_message->bounce == NULL) &&
                 (old_message->encoding == NULL) &&
                 (old_message->binhex == NULL) &&
                 (old_message->yenc == NULL))
                 return 0;
 
             m->body_last = m->body_first;
             rc           = 0;
         } else {
             m->body_last = m->body_first = textMove(NULL, t);
             if (m->body_first == NULL)
                 return -1;
             else
                 rc = 0;
         }
     } else {
         m->body_last = textMove(m->body_last, t);
         if (m->body_last == NULL) {
             rc           = -1;
             m->body_last = m->body_first;
         } else
             rc = 0;
     }
 
     while (m->body_last->t_next) {
         m->body_last = m->body_last->t_next;
         if (m->body_last->t_line)
             messageIsEncoding(m);
     }
 
     return rc;

 }
 
 /*

  * See if the last line marks the start of a non MIME inclusion that
  * will need to be scanned
  */
 static void
 messageIsEncoding(message *m)
 {

     static const char encoding[] = "Content-Transfer-Encoding";
     static const char binhex[]   = "(This file must be converted with BinHex 4.0)";
     const char *line             = lineGetData(m->body_last->t_line);

     /*if(m->ctx == NULL)

 		cli_dbgmsg("messageIsEncoding, ctx == NULL\n");*/
 

     if ((m->encoding == NULL) &&
         (strncasecmp(line, encoding, sizeof(encoding) - 1) == 0) &&
         (strstr(line, "7bit") == NULL))
         m->encoding = m->body_last;
     else if ((m->bounce == NULL) && m->ctx &&
              (strncasecmp(line, "Received: ", 10) == 0) &&
              (cli_filetype((const unsigned char *)line, strlen(line), m->ctx->engine) == CL_TYPE_MAIL))
         m->bounce = m->body_last;
     /* Not needed with fast track visa technology */
     /*else if((m->uuencode == NULL) && isuuencodebegin(line))

 		m->uuencode = m->body_last;*/

     else if ((m->binhex == NULL) &&
              strstr(line, "BinHex") &&
              (simil(line, binhex) > 90))
         /*

 			 * Look for close matches for BinHex, but
 			 * simil() is expensive so only do it if it's
 			 * likely to be found
 			 */

         m->binhex = m->body_last;
     else if ((m->yenc == NULL) && (strncmp(line, "=ybegin line=", 13) == 0))
         m->yenc = m->body_last;

 }
 
 /*

  * Returns a pointer to the body of the message. Note that it does NOT return
  * a copy of the data
  */

 text *
 messageGetBody(message *m)

 {

     assert(m != NULL);
     return m->body_first;

 }
 
 /*

  * Export a message using the given export routines

  *
  * TODO: It really should export into an array, one
  * for each encoding algorithm. However, what it does is it returns the
  * last item that was exported. That's sufficient for now.

  */

 static void *

 messageExport(message *m, const char *dir, void *(*create)(void), void (*destroy)(void *), void (*setFilename)(void *, const char *, const char *), void (*addData)(void *, const unsigned char *, size_t), void *(*exportText)(text *, void *, int), void (*setCTX)(void *, cli_ctx *), int destroy_text)

 {

     void *ret;
     text *t_line;
     char *filename;
     int i;

     assert(m != NULL);

     if (messageGetBody(m) == NULL)
         return NULL;

     ret = (*create)();

     if (ret == NULL)
         return NULL;

     cli_dbgmsg("messageExport: numberOfEncTypes == %d\n", m->numberOfEncTypes);

     if (m->numberOfEncTypes == 0) {
         /*

 		 * Fast copy
 		 */

         cli_dbgmsg("messageExport: Entering fast copy mode\n");

 #if 0

 		filename = messageGetFilename(m);
 
 		if(filename == NULL) {
 			cli_dbgmsg("Unencoded attachment sent with no filename\n");
 			messageAddArgument(m, "name=attachment");
 		} else if((strcmp(filename, "textportion") != 0) && (strcmp(filename, "mixedtextportion") != 0))
 			/*
 			 * Some virus attachments don't say how they've
 			 * been encoded. We assume base64
 			 */
 			messageSetEncoding(m, "base64");
 #else

         filename = (char *)messageFindArgument(m, "filename");
         if (filename == NULL) {
             filename = (char *)messageFindArgument(m, "name");
 
             if (filename == NULL) {
                 cli_dbgmsg("Unencoded attachment sent with no filename\n");
                 messageAddArgument(m, "name=attachment");
             } else
                 /*

 				 * Some virus attachments don't say how they've

 				 * been encoded. We assume base64.
 				 * RFC says encoding should be 7-bit.

 				 */

                 messageSetEncoding(m, "7-bit");
         }

 #endif

         (*setFilename)(ret, dir, (filename && *filename) ? filename : "attachment");

         if (filename)
             free((char *)filename);

         if (m->numberOfEncTypes == 0)
             return exportText(messageGetBody(m), ret, destroy_text);
     }

     if (setCTX && m->ctx)
         (*setCTX)(ret, m->ctx);

     for (i = 0; i < m->numberOfEncTypes; i++) {
         encoding_type enctype = m->encodingTypes[i];
         size_t size;

         if (i > 0) {
             void *newret;

             newret = (*create)();
             if (newret == NULL) {
                 cli_dbgmsg("Not all decoding algorithms were run\n");
                 return ret;
             }
             (*destroy)(ret);
             ret = newret;
         }
         cli_dbgmsg("messageExport: enctype %d is %d\n", i, (int)enctype);
         /*

 		 * Find the filename to decode

 		 */

         if (((enctype == YENCODE) || (i == 0)) && yEncBegin(m)) {
             const char *f;

             /*

 			 * TODO: handle multipart yEnc encoded files
 			 */

             t_line = yEncBegin(m);
             f      = lineGetData(t_line->t_line);
 
             if ((filename = strstr(f, " name=")) != NULL) {
                 filename = cli_strdup(&filename[6]);
                 if (filename) {
                     cli_chomp(filename);
                     strstrip(filename);
                     cli_dbgmsg("Set yEnc filename to \"%s\"\n", filename);
                 }
             }
 
             (*setFilename)(ret, dir, (filename && *filename) ? filename : "attachment");
             if (filename) {
                 free((char *)filename);
                 filename = NULL;
             }
             t_line  = t_line->t_next;
             enctype = YENCODE;
             m->yenc = NULL;
         } else {
             if (enctype == UUENCODE) {
                 /*

 				 * The body will have been stripped out by the
 				 * fast track visa system. Treat as plain/text,
 				 * which means we'll still scan for funnies
 				 * outside of the uuencoded portion.

 				 */

                 cli_dbgmsg("messageExport: treat uuencode as text/plain\n");
                 enctype = m->encodingTypes[i] = NOENCODING;
             }
             filename = messageGetFilename(m);
 
             if (filename == NULL) {
                 cli_dbgmsg("Attachment sent with no filename\n");
                 messageAddArgument(m, "name=attachment");
             } else if (enctype == NOENCODING)
                 /*

 				 * Some virus attachments don't say how
 				 * they've been encoded. We assume
 				 * base64.
 				 *
 				 * FIXME: don't do this if it's a fall
 				 * through from uuencode
 				 */

                 messageSetEncoding(m, "base64");

             (*setFilename)(ret, dir, (filename && *filename) ? filename : "attachment");

             t_line = messageGetBody(m);
         }

         if (filename)
             free((char *)filename);

         /*

 		 * t_line should now point to the first (encoded) line of the
 		 * message

 		 */

         if (t_line == NULL) {
             cli_dbgmsg("Empty attachment not saved\n");
             (*destroy)(ret);
             return NULL;
         }

         if (enctype == NOENCODING) {
             /*

 			 * Fast copy

 			 */

             if (i == m->numberOfEncTypes - 1) {
                 /* last one */
                 (void)exportText(t_line, ret, destroy_text);
                 break;
             }
             (void)exportText(t_line, ret, 0);
             continue;
         }

         size = 0;
         do {
             unsigned char smallbuf[1024];
             unsigned char *uptr, *data;
             const char *line = lineGetData(t_line->t_line);
             unsigned char *bigbuf;
             size_t datasize;
 
             if (enctype == YENCODE) {
                 if (line == NULL)
                     continue;
                 if (strncmp(line, "=yend ", 6) == 0)
                     break;
             }
 
             /*

 			 * Add two bytes for '\n' and '\0'
 			 */

             datasize = (line) ? strlen(line) + 2 : 0;
 
             if (datasize >= sizeof(smallbuf))
                 data = bigbuf = (unsigned char *)cli_malloc(datasize);
             else {
                 bigbuf   = NULL;
                 data     = smallbuf;
                 datasize = sizeof(smallbuf);
             }

             uptr = decodeLine(m, enctype, line, data, datasize);
             if (uptr == NULL) {
                 if (data == bigbuf)
                     free(data);
                 break;
             }
 
             if (uptr != data) {
                 assert((size_t)(uptr - data) < datasize);
                 (*addData)(ret, data, (size_t)(uptr - data));
                 size += (size_t)(uptr - data);
             }
 
             if (data == bigbuf)
                 free(data);
 
             /*

 			 * According to RFC2045, '=' is used to pad out

 			 * the last byte and should be used as evidence
 			 * of the end of the data. Some mail clients
 			 * annoyingly then put plain text after the '='
 			 * byte and viruses exploit this bug. Sigh
 			 */

             /*if(enctype == BASE64)

 				if(strchr(line, '='))
 					break;*/

             if (line && destroy_text && (i == m->numberOfEncTypes - 1)) {
                 lineUnlink(t_line->t_line);
                 t_line->t_line = NULL;
             }
         } while ((t_line = t_line->t_next) != NULL);
 
         cli_dbgmsg("Exported %lu bytes using enctype %d\n",
                    (unsigned long)size, (int)enctype);
 
         /* Verify we have nothing left to flush out */
         if (m->base64chars) {
             unsigned char data[4];
             unsigned char *ptr;
 
             ptr = base64Flush(m, data);
             if (ptr)
                 (*addData)(ret, data, (size_t)(ptr - data));
         }
     }
 
     return ret;

 }
 

 unsigned char *
 base64Flush(message *m, unsigned char *buf)
 {

     cli_dbgmsg("%d trailing bytes to export\n", m->base64chars);

     if (m->base64chars) {
         unsigned char *ret = decode(m, NULL, buf, base64, FALSE);

         m->base64chars = 0;

         return ret;
     }
     return NULL;

 }
 

 int messageSavePartial(message *m, const char *dir, const char *md5id, unsigned part)
 {

     char fullname[1024];
     fileblob *fb;
     unsigned long time_val;
 
     cli_dbgmsg("messageSavePartial\n");
     time_val = time(NULL);
     snprintf(fullname, 1024, "%s" PATHSEP "clamav-partial-%lu_%s-%u", dir, time_val, md5id, part);
 
     fb = messageExport(m, fullname,
                        (void *(*)(void))fileblobCreate,
                        (void (*)(void *))fileblobDestroy,
                        (void (*)(void *, const char *, const char *))fileblobPartialSet,
                        (void (*)(void *, const unsigned char *, size_t))fileblobAddData,
                        (void *(*)(text *, void *, int))textToFileblob,
                        (void (*)(void *, cli_ctx *))fileblobSetCTX,
                        0);
     if (!fb)
         return CL_EFORMAT;
     fileblobDestroy(fb);
     return CL_SUCCESS;

 }
 

 /*
  * Decode and transfer the contents of the message into a fileblob
  * The caller must free the returned fileblob
  */
 fileblob *

 messageToFileblob(message *m, const char *dir, int destroy)

 {

     fileblob *fb;
 
     cli_dbgmsg("messageToFileblob\n");
     fb = messageExport(m, dir,
                        (void *(*)(void))fileblobCreate,
                        (void (*)(void *))fileblobDestroy,
                        (void (*)(void *, const char *, const char *))fileblobSetFilename,
                        (void (*)(void *, const unsigned char *, size_t))fileblobAddData,
                        (void *(*)(text *, void *, int))textToFileblob,
                        (void (*)(void *, cli_ctx *))fileblobSetCTX,
                        destroy);
     if (destroy && m->body_first) {
         textDestroy(m->body_first);
         m->body_first = m->body_last = NULL;
     }
     return fb;

 }
 
 /*

  * Decode and transfer the contents of the message into a closed blob

  * The caller must free the returned blob
  */
 blob *

 messageToBlob(message *m, int destroy)

 {

     blob *b;
 
     cli_dbgmsg("messageToBlob\n");
 
     b = messageExport(m, NULL,
                       (void *(*)(void))blobCreate,
                       (void (*)(void *))blobDestroy,
                       (void (*)(void *, const char *, const char *))blobSetFilename,
                       (void (*)(void *, const unsigned char *, size_t))blobAddData,
                       (void *(*)(text *, void *, int))textToBlob,
                       (void (*)(void *, cli_ctx *))NULL,
                       destroy);
 
     if (destroy && m->body_first) {
         textDestroy(m->body_first);
         m->body_first = m->body_last = NULL;
     }
     return b;

 }
 
 /*
  * Decode and transfer the contents of the message into a text area

  * The caller must free the returned text

  */
 text *

 messageToText(message *m)

 {

     int i;
     text *first = NULL, *last = NULL;
     const text *t_line;

     assert(m != NULL);

     if (m->numberOfEncTypes == 0) {
         /*

 		 * Fast copy
 		 */

         for (t_line = messageGetBody(m); t_line; t_line = t_line->t_next) {
             if (first == NULL)
                 first = last = cli_malloc(sizeof(text));
             else {
                 last->t_next = cli_malloc(sizeof(text));
                 last         = last->t_next;
             }
 
             if (last == NULL) {
                 if (first)
                     textDestroy(first);
                 return NULL;
             }
             if (t_line->t_line)
                 last->t_line = lineLink(t_line->t_line);
             else
                 last->t_line = NULL; /* empty line */
         }
         if (last)
             last->t_next = NULL;
 
         return first;
     }
     /*

 	 * Scan over the data a number of times once for each claimed encoding
 	 * type
 	 */

     for (i = 0; i < m->numberOfEncTypes; i++) {
         const encoding_type enctype = m->encodingTypes[i];

         cli_dbgmsg("messageToText: export transfer method %d = %d\n",
                    i, (int)enctype);

         switch (enctype) {
             case NOENCODING:
             case BINARY:
             case EIGHTBIT:
                 /*

 				 * Fast copy
 				 */

                 for (t_line = messageGetBody(m); t_line; t_line = t_line->t_next) {
                     if (first == NULL)
                         first = last = cli_malloc(sizeof(text));
                     else if (last) {
                         last->t_next = cli_malloc(sizeof(text));
                         last         = last->t_next;
                     }
 
                     if (last == NULL) {
                         if (first) {
                             textDestroy(first);
                         }
                         return NULL;
                     }
                     if (t_line->t_line)
                         last->t_line = lineLink(t_line->t_line);
                     else
                         last->t_line = NULL; /* empty line */
                 }
                 continue;
             case UUENCODE:
                 cli_warnmsg("messageToText: Unexpected attempt to handle uuencoded file\n");
                 if (first) {
                     if (last)
                         last->t_next = NULL;
                     textDestroy(first);
                 }
                 return NULL;
             case YENCODE:
                 t_line = yEncBegin(m);
 
                 if (t_line == NULL) {
                     /*cli_warnmsg("YENCODED attachment is missing begin statement\n");*/
                     if (first) {
                         if (last)
                             last->t_next = NULL;
                         textDestroy(first);
                     }
                     return NULL;
                 }
                 t_line = t_line->t_next;
             default:
                 if ((i == 0) && binhexBegin(m))
                     cli_warnmsg("Binhex messages not supported yet.\n");
                 t_line = messageGetBody(m);
         }
 
         for (; t_line; t_line = t_line->t_next) {
             unsigned char data[1024];
             unsigned char *uptr;
             const char *line = lineGetData(t_line->t_line);
 
             if (enctype == BASE64)
                 /*

 				 * ignore blanks - breaks RFC which is
 				 * probably the point!
 				 */

                 if (line == NULL)
                     continue;

             assert((line == NULL) || (strlen(line) <= sizeof(data)));

             uptr = decodeLine(m, enctype, line, data, sizeof(data));

             if (uptr == NULL)
                 break;

             assert(uptr <= &data[sizeof(data)]);

             if (first == NULL)
                 first = last = cli_malloc(sizeof(text));
             else if (last) {
                 last->t_next = cli_malloc(sizeof(text));
                 last         = last->t_next;
             }

             if (last == NULL)
                 break;

             /*

 			 * If the decoded line is the same as the encoded
 			 * there's no need to take a copy, just link it.
 			 * Note that the comparison is done without the
 			 * trailing newline that the decoding routine may have
 			 * added - that's why there's a strncmp rather than a
 			 * strcmp - that'd be bad for MIME decoders, but is OK
 			 * for AV software
 			 */

             if ((data[0] == '\n') || (data[0] == '\0'))
                 last->t_line = NULL;
             else if (line && (strncmp((const char *)data, line, strlen(line)) == 0)) {
 #ifdef CL_DEBUG
                 cli_dbgmsg("messageToText: decoded line is the same(%s)\n", data);

 #endif

                 last->t_line = lineLink(t_line->t_line);
             } else
                 last->t_line = lineCreate((char *)data);

             if (line && enctype == BASE64)
                 if (strchr(line, '='))
                     break;
         }
         if (m->base64chars) {
             unsigned char data[4];
 
             memset(data, '\0', sizeof(data));
             if (decode(m, NULL, data, base64, FALSE) && data[0]) {
                 if (first == NULL)
                     first = last = cli_malloc(sizeof(text));
                 else if (last) {
                     last->t_next = cli_malloc(sizeof(text));
                     last         = last->t_next;
                 }
 
                 if (last != NULL)
                     last->t_line = lineCreate((char *)data);
             }
             m->base64chars = 0;
         }
     }
 
     if (last)
         last->t_next = NULL;
 
     return first;

 }
 

 text *
 yEncBegin(message *m)

 {

     return m->yenc;

 }
 

 /*

  * Scan to find the BINHEX message (if any)
  */

 #if 0

 const text *
 binhexBegin(message *m)

 {
 	const text *t_line;
 
 	for(t_line = messageGetBody(m); t_line; t_line = t_line->t_next)
 		if(strcasecmp(t_line->t_text, "(This file must be converted with BinHex 4.0)") == 0)
 			return t_line;
 
 	return NULL;
 }

 #else

 text *
 binhexBegin(message *m)

 {

     return m->binhex;

 }
 #endif

 
 /*

  * Scan to find a bounce message. There is no standard for these, not
  * even a convention, so don't expect this to be foolproof
  */

 #if 0

 text *
 bounceBegin(message *m)

 {
 	const text *t_line;

 	for(t_line = messageGetBody(m); t_line; t_line = t_line->t_next)

 		if(cli_filetype(t_line->t_text, strlen(t_line->t_text)) == CL_TYPE_MAIL)

 			return t_line;

 
 	return NULL;
 }

 #else

 text *
 bounceBegin(message *m)

 {

     return m->bounce;

 }
 #endif
 
 /*
  * If a message doesn't not contain another message which could be harmful
  * it is deemed to be safe.
  *
  * TODO: ensure nothing can get through this
  *
  * TODO: check to see if we need to
  * find anything else, perhaps anything
  * from the RFC821 table?
  */

 #if 0

 int
 messageIsAllText(const message *m)
 {
 	const text *t;
 
 	for(t = messageGetBody(m); t; t = t->t_next)
 		if(strncasecmp(t->t_text,
 			"Content-Transfer-Encoding",
 			strlen("Content-Transfer-Encoding")) == 0)
 				return 0;
 
 	return 1;
 }
 #else

 text *
 encodingLine(message *m)

 {

     return m->encoding;

 }
 #endif

 
 /*

  * Decode a line and add it to a buffer, return the end of the buffer

  * to help appending callers. There is no new line at the end of "line"

  *
  * len is sizeof(ptr)

  */

 unsigned char *

 decodeLine(message *m, encoding_type et, const char *line, unsigned char *buf, size_t buflen)

 {

     size_t len, reallen;
     bool softbreak;
     char *p2, *copy;
     char base64buf[RFC2045LENGTH + 1];

     /*cli_dbgmsg("decodeLine(et = %d buflen = %u)\n", (int)et, buflen);*/

     assert(m != NULL);
     assert(buf != NULL);

     switch (et) {
         case BINARY:
             /*

 			 * TODO: find out what this is, encoded as binary??
 			 */

             /* fall through */
         case NOENCODING:
         case EIGHTBIT:
         default:      /* unknown encoding type - try our best */
             if (line) /* empty line? */
                 buf = (unsigned char *)cli_strrcpy((char *)buf, line);
             /* Put the new line back in */
             return (unsigned char *)cli_strrcpy((char *)buf, "\n");
 
         case QUOTEDPRINTABLE:
             if (line == NULL) { /* empty line */
                 *buf++ = '\n';
                 break;
             }
 
             softbreak = FALSE;
             while (buflen && *line) {
                 if (*line == '=') {
                     unsigned char byte;
 
                     if ((*++line == '\0') || (*line == '\n')) {
                         softbreak = TRUE;
                         /* soft line break */
                         break;
                     }
 
                     byte = hex(*line);
 
                     if ((*++line == '\0') || (*line == '\n')) {
                         /*

 						 * broken e-mail, not
 						 * adhering to RFC2045
 						 */

                         *buf++ = byte;
                         break;
                     }

                     /*

 					 * Handle messages that use a broken
 					 * quoted-printable encoding of
 					 * href=\"http://, instead of =3D
 					 */

                     if (byte != '=')
                         byte = (byte << 4) | hex(*line);
                     else
                         line -= 2;
 
                     *buf++ = byte;
                 } else
                     *buf++ = *line;
                 ++line;
                 --buflen;
             }
             if (!softbreak)
                 /* Put the new line back in */
                 *buf++ = '\n';
             break;
 
         case BASE64:
             if (line == NULL)
                 break;
             /*

 			 * RFC2045 sets the maximum length to 76 bytes

 			 * but many e-mail clients ignore that
 			 */

             if (strlen(line) < sizeof(base64buf)) {
                 strcpy(base64buf, line);
                 copy = base64buf;
             } else {
                 copy = cli_strdup(line);
                 if (copy == NULL)
                     break;
             }

             p2 = strchr(copy, '=');
             if (p2)
                 *p2 = '\0';

             sanitiseBase64(copy);

             /*

 			 * Klez doesn't always put "=" on the last line
 			 */

             buf = decode(m, copy, buf, base64, (p2 == NULL) && ((strlen(copy) & 3) == 0));

             if (copy != base64buf)
                 free(copy);
             break;

         case UUENCODE:
             assert(m->base64chars == 0);

             if ((line == NULL) || (*line == '\0')) /* empty line */
                 break;
             if (strcasecmp(line, "end") == 0)
                 break;
             if (isuuencodebegin(line))
                 break;

             if ((line[0] & 0x3F) == ' ')
                 break;

             /*

 			 * reallen contains the number of bytes that were
 			 *	encoded
 			 */

             reallen = (size_t)uudecode(*line++);
             if (reallen <= 0)
                 break;
             if (reallen > 62)
                 break;
             len = strlen(line);
 
             if ((len > buflen) || (reallen > len))
                 /*

 				 * In practice this should never occur since
 				 * the maximum length of a uuencoded line is
 				 * 62 characters
 				 */

                 cli_dbgmsg("uudecode: buffer overflow stopped, attempting to ignore but decoding may fail\n");
             else {
                 (void)decode(m, line, buf, uudecode, (len & 3) == 0);
                 buf = &buf[reallen];
             }
             m->base64chars = 0; /* this happens with broken uuencoded files */
             break;
         case YENCODE:
             if ((line == NULL) || (*line == '\0')) /* empty line */
                 break;
             if (strncmp(line, "=yend ", 6) == 0)
                 break;
 
             while (*line)
                 if (*line == '=') {
                     if (*++line == '\0')
                         break;
                     *buf++ = ((*line++ - 64) & 255);
                 } else
                     *buf++ = ((*line++ - 42) & 255);
             break;
     }
 
     *buf = '\0';
     return buf;

 }
 

 /*

  * Remove the non base64 characters such as spaces from a string. Spaces
  * shouldn't appear mid string in base64 files, but some broken mail clients
  * ignore such errors rather than discarding the mail, and virus writers
  * exploit this bug

  */
 static void

 sanitiseBase64(char *s)

 {

     cli_dbgmsg("sanitiseBase64 '%s'\n", s);
     while (*s)
         if (base64Table[(unsigned int)(*s & 0xFF)] == 255) {
             char *p1;
 
             for (p1 = s; p1[0] != '\0'; p1++)
                 p1[0] = p1[1];
         } else
             s++;

 }
 
 /*

  * Returns one byte after the end of the decoded data in "out"

  *
  * Update m->base64chars with the last few bytes of data that we haven't
  * decoded. After the last line is found, decode will be called with in = NULL
  * to flush these out

  */

 static unsigned char *

 decode(message *m, const char *in, unsigned char *out, unsigned char (*decoder)(char), bool isFast)
 {

     unsigned char b1, b2, b3, b4;
     unsigned char cb1, cb2, cb3; /* carried over from last line */

     /*cli_dbgmsg("decode %s (len %d isFast %d base64chars %d)\n", in,

 		in ? strlen(in) : 0,

 		isFast, m->base64chars);*/

     cb1 = cb2 = cb3 = '\0';
 
     switch (m->base64chars) {
         case 3:
             cb3 = m->base64_3;
             /* FALLTHROUGH */
         case 2:
             cb2 = m->base64_2;
             /* FALLTHROUGH */
         case 1:
             cb1    = m->base64_1;
             isFast = FALSE;
             break;
         default:
             assert(m->base64chars <= 3);
     }
 
     if (isFast)
         /* Fast decoding if not last line */
         while (*in) {
             b1 = (*decoder)(*in++);
             b2 = (*decoder)(*in++);
             b3 = (*decoder)(*in++);
             /*

 			 * Put this line here to help on some compilers which

 			 * can make use of some architecture's ability to

 			 * multiprocess when different variables can be
 			 * updated at the same time - here b3 is used in
 			 * one line, b1/b2 in the next and b4 in the next after
 			 * that, b3 and b4 rely on in but b1/b2 don't
 			 */

             *out++ = (b1 << 2) | ((b2 >> 4) & 0x3);
             b4     = (*decoder)(*in++);
             *out++ = (b2 << 4) | ((b3 >> 2) & 0xF);
             *out++ = (b3 << 6) | (b4 & 0x3F);
         }
     else if (in == NULL) { /* flush */
         int nbytes;
 
         if (m->base64chars == 0)
             return out;
 
         cli_dbgmsg("base64chars = %d (%c %c %c)\n", m->base64chars,
                    isalnum(cb1) ? cb1 : '@',
                    isalnum(cb2) ? cb2 : '@',
                    isalnum(cb3) ? cb3 : '@');
 
         m->base64chars--;
         b1     = cb1;
         nbytes = 1;
 
         if (m->base64chars) {
             m->base64chars--;
             b2 = cb2;
 
             if (m->base64chars) {
                 nbytes = 2;
                 m->base64chars--;
                 b3     = cb3;
                 nbytes = 3;
             } else if (b2)
                 nbytes = 2;
         }
 
         switch (nbytes) {
             case 3:
                 b4 = '\0';
                 /* fall through */
             case 4:
                 *out++ = (b1 << 2) | ((b2 >> 4) & 0x3);
                 *out++ = (b2 << 4) | ((b3 >> 2) & 0xF);
                 if ((nbytes == 4) || (b3 & 0x3))
                     *out++ = (b3 << 6) | (b4 & 0x3F);
                 break;
             case 2:
                 *out++ = (b1 << 2) | ((b2 >> 4) & 0x3);
                 if ((b2 << 4) & 0xFF)
                     *out++ = b2 << 4;
                 break;
             case 1:
                 *out++ = b1 << 2;
                 break;
             default:
                 assert(0);
         }
     } else
         while (*in) {
             int nbytes;
 
             if (m->base64chars) {
                 m->base64chars--;
                 b1 = cb1;
             } else
                 b1 = (*decoder)(*in++);
 
             if (*in == '\0') {
                 b2     = '\0';
                 nbytes = 1;
             } else {
                 if (m->base64chars) {
                     m->base64chars--;
                     b2 = cb2;
                 } else
                     b2 = (*decoder)(*in++);
 
                 if (*in == '\0') {
                     b3     = '\0';
                     nbytes = 2;
                 } else {
                     if (m->base64chars) {
                         m->base64chars--;
                         b3 = cb3;
                     } else
                         b3 = (*decoder)(*in++);
 
                     if (*in == '\0') {
                         b4     = '\0';
                         nbytes = 3;
                     } else {
                         b4     = (*decoder)(*in++);
                         nbytes = 4;
                     }
                 }
             }
 
             switch (nbytes) {
                 case 4:
                     *out++ = (b1 << 2) | ((b2 >> 4) & 0x3);
                     *out++ = (b2 << 4) | ((b3 >> 2) & 0xF);
                     *out++ = (b3 << 6) | (b4 & 0x3F);
                     continue;
                 case 3:
                     m->base64_3 = b3;
                 case 2:
                     m->base64_2 = b2;
                 case 1:
                     m->base64_1    = b1;
                     m->base64chars = nbytes;
                     break;
                 default:
                     assert(0);
             }
             break; /* nbytes != 4 => EOL */
         }
     return out;

 }

 
 static unsigned char
 hex(char c)
 {

     if (isdigit(c))
         return c - '0';
     if ((c >= 'A') && (c <= 'F'))
         return c - 'A' + 10;
     if ((c >= 'a') && (c <= 'f'))
         return c - 'a' + 10;
     cli_dbgmsg("Illegal hex character '%c'\n", c);
 
     /*

 	 * Some mails (notably some spam) break RFC2045 by failing to encode

 	 * the '=' character
 	 */

     return '=';

 }
 

 static unsigned char
 base64(char c)
 {

     const unsigned char ret = base64Table[(unsigned int)(c & 0xFF)];

     if (ret == 255) {
         /*cli_dbgmsg("Illegal character <%c> in base64 encoding\n", c);*/
         return 63;
     }
     return ret;

 }

 
 static unsigned char
 uudecode(char c)
 {

     return c - ' ';

 }

 
 /*
  * These are the only arguments we're interested in.
  * Do 'fgrep messageFindArgument *.c' if you don't believe me!
  * It's probably not good doing this since each time a new
  * messageFindArgument is added I need to remember to look here,
  * but it can save a lot of memory...
  */
 static int
 usefulArg(const char *arg)
 {

     if ((strncasecmp(arg, "name", 4) != 0) &&
         (strncasecmp(arg, "filename", 8) != 0) &&
         (strncasecmp(arg, "boundary", 8) != 0) &&
         (strncasecmp(arg, "protocol", 8) != 0) &&
         (strncasecmp(arg, "id", 2) != 0) &&
         (strncasecmp(arg, "number", 6) != 0) &&
         (strncasecmp(arg, "total", 5) != 0) &&
         (strncasecmp(arg, "type", 4) != 0)) {
         cli_dbgmsg("Discarding unwanted argument '%s'\n", arg);
         return 0;
     }
     return 1;

 }

 void messageSetCTX(message *m, cli_ctx *ctx)

 {

     m->ctx = ctx;

 }
 

 int messageContainsVirus(const message *m)

 {

     return m->isInfected ? TRUE : FALSE;

 }
 

 /*
  * We've run out of memory. Try to recover some by
  * deduping the message

  *
  * FIXME: this can take a long time. The real solution is for system admins
  *	to refrain from setting ulimits too low, then this routine won't be
  *	called

  */
 static void
 messageDedup(message *m)
 {

     const text *t1;
     size_t saved = 0;
 
     cli_dbgmsg("messageDedup\n");
 
     t1 = m->dedupedThisFar ? m->dedupedThisFar : m->body_first;
 
     for (t1 = m->body_first; t1; t1 = t1->t_next) {
         const char *d1;
         text *t2;
         line_t *l1;
         unsigned int r1;
 
         if (saved >= 100 * 1000)
             break; /* that's enough */
         l1 = t1->t_line;
         if (l1 == NULL)
             continue;
         d1 = lineGetData(l1);
         if (strlen(d1) < 8)
             continue; /* wouldn't recover many bytes */
 
         r1 = (unsigned int)lineGetRefCount(l1);
         if (r1 == 255)
             continue;
         /*

 		 * We don't want to foul up any pointers
 		 */

         if (t1 == m->encoding)
             continue;
         if (t1 == m->bounce)
             continue;
         if (t1 == m->binhex)
             continue;
         if (t1 == m->yenc)
             continue;
 
         for (t2 = t1->t_next; t2; t2 = t2->t_next) {
             const char *d2;
             line_t *l2 = t2->t_line;
 
             if (l2 == NULL)
                 continue;
             d2 = lineGetData(l2);
             if (d1 == d2)
                 /* already linked */
                 continue;
             if (strcmp(d1, d2) == 0) {
                 if (lineUnlink(l2) == NULL)
                     saved += strlen(d1) + 1;
                 t2->t_line = lineLink(l1);
                 if (t2->t_line == NULL) {
                     cli_errmsg("messageDedup: out of memory\n");
                     return;
                 }
                 if (++r1 == 255)
                     break;
             }
         }
     }
 
     cli_dbgmsg("messageDedup reclaimed %lu bytes\n", (unsigned long)saved);
     m->dedupedThisFar = t1;

 }

 
 /*

  * Handle RFC2231 encoding. Returns a malloc'd buffer that the caller must
  * free, or NULL on error.
  *
  * TODO: Currently only handles paragraph 4 of RFC2231 e.g.
  *	 protocol*=ansi-x3.4-1968''application%2Fpgp-signature;
  */
 static char *
 rfc2231(const char *in)
 {

     const char *ptr;
     char *ret, *out;
     enum { LANGUAGE,
            CHARSET,
            CONTENTS } field;
 
     if (strstr(in, "*0*=") != NULL) {
         char *p;
 
         /* Don't handle continuations, decode what we can */
         p = ret = cli_malloc(strlen(in) + 16);
         if (ret == NULL) {

             cli_errmsg("rfc2331: out of memory, unable to proceed\n");

             return NULL;

         }

         do {
             switch (*in) {
                 default:
                     *p++ = *in++;
                     continue;
                 case '*':
                     do
                         in++;
                     while ((*in != '*') && *in);
                     if (*in) {
                         in++;
                         continue;
                     }
                     break;
                 case '=':
                     /*strcpy(p, in);*/
                     strcpy(p, "=rfc2231failure");
                     p += strlen("=rfc2231failure");
                     break;
             }
             break;
         } while (*in);
         *p = '\0';
 
         cli_dbgmsg("RFC2231 parameter continuations are not yet handled, returning \"%s\"\n",
                    ret);
         return ret;
     }
 
     ptr = strstr(in, "*0=");
     if (ptr != NULL)
         /*

 		 * Parameter continuation, with no continuation
 		 * Thunderbird 1.5 (and possibly other versions) does this
 		 */

         field = CONTENTS;
     else {
         ptr   = strstr(in, "*=");
         field = LANGUAGE;
     }

     if (ptr == NULL) { /* quick return */
         out = ret = cli_strdup(in);
         while (*out)
             *out++ &= 0x7F;
         return ret;
     }

     cli_dbgmsg("rfc2231 '%s'\n", in);

     ret = cli_malloc(strlen(in) + 1);

     if (ret == NULL) {

         cli_errmsg("rfc2331: out of memory for ret\n");

         return NULL;

     }

     /*

 	 * memcpy(out, in, (ptr - in));
 	 * out = &out[ptr - in];
 	 * in = ptr;
 	 */

     out = ret;
     while (in != ptr)
         *out++ = *in++;

     *out++ = '=';

     while (*ptr++ != '=') continue;

     /*

 	 * We don't do anything with the language and character set, just skip
 	 * over them!
 	 */

     while (*ptr) {
         switch (field) {
             case LANGUAGE:
                 if (*ptr == '\'')
                     field = CHARSET;
                 break;
             case CHARSET:
                 if (*ptr == '\'')
                     field = CONTENTS;
                 break;
             case CONTENTS:
                 if (*ptr == '%') {
                     unsigned char byte;
 
                     if ((*++ptr == '\0') || (*ptr == '\n'))
                         break;
 
                     byte = hex(*ptr);
 
                     if ((*++ptr == '\0') || (*ptr == '\n')) {
                         *out++ = byte;
                         break;
                     }
 
                     byte <<= 4;
                     byte += hex(*ptr);
                     *out++ = byte;
                 } else
                     *out++ = *ptr;
         }
         if (*ptr++ == '\0')
             /*

 			 * Incorrect message that has just one character after
 			 * a '%'.
 			 * FIXME: stash something in out that would, for example
 			 *	treat %2 as %02, assuming field == CONTENTS
 			 */

             break;
     }

     if (field != CONTENTS) {
         free(ret);
         cli_dbgmsg("Invalid RFC2231 header: '%s'\n", in);
         return cli_strdup("");
     }

     *out = '\0';

     cli_dbgmsg("rfc2231 returns '%s'\n", ret);

     return ret;

 }
 
 /*

  * common/simil:
  *	From Computing Magazine 20/8/92
  * Returns %ge number from 0 to 100 - how similar are 2 strings?
  * 100 for exact match, < for error
  */

 struct pstr_list { /* internal stack */
     char *d1;
     struct pstr_list *next;

 };
 

 #define OUT_OF_MEMORY (-2)
 #define FAILURE (-3)
 #define SUCCESS (-4)
 #define ARRAY_OVERFLOW (-5)
 typedef struct pstr_list ELEMENT1;
 typedef ELEMENT1 *LINK1;

 static int push(LINK1 *top, const char *string);
 static int pop(LINK1 *top, char *buffer);
 static unsigned int compare(char *ls1, char **rs1, char *ls2, char **rs2);

 #define MAX_PATTERN_SIZ 50 /* maximum string lengths */

 
 static int
 simil(const char *str1, const char *str2)
 {

     LINK1 top          = NULL;
     unsigned int score = 0;
     size_t common, total;
     size_t len1, len2;
     char *rs1 = NULL, *rs2 = NULL;
     char *s1, *s2;
     char ls1[MAX_PATTERN_SIZ], ls2[MAX_PATTERN_SIZ];
 
     if (strcasecmp(str1, str2) == 0)
         return 100;
 
     if ((s1 = cli_strdup(str1)) == NULL)
         return OUT_OF_MEMORY;
     if ((s2 = cli_strdup(str2)) == NULL) {
         free(s1);
         return OUT_OF_MEMORY;
     }
 
     if (((total = strstrip(s1)) > MAX_PATTERN_SIZ - 1) || ((len2 = strstrip(s2)) > MAX_PATTERN_SIZ - 1)) {
         free(s1);
         free(s2);
         return ARRAY_OVERFLOW;
     }
 
     total += len2;
 
     if ((push(&top, s1) == OUT_OF_MEMORY) ||
         (push(&top, s2) == OUT_OF_MEMORY)) {
         free(s1);
         free(s2);
         return OUT_OF_MEMORY;
     }
 
     while (pop(&top, ls2) == SUCCESS) {
         pop(&top, ls1);
         common = compare(ls1, &rs1, ls2, &rs2);
         if (common > 0) {
             score += (unsigned int)common;
             len1 = strlen(ls1);
             len2 = strlen(ls2);
 
             if ((len1 > 1 && len2 >= 1) || (len2 > 1 && len1 >= 1))
                 if ((push(&top, ls1) == OUT_OF_MEMORY) || (push(&top, ls2) == OUT_OF_MEMORY)) {
                     free(s1);
                     free(s2);
                     return OUT_OF_MEMORY;
                 }
             len1 = strlen(rs1);
             len2 = strlen(rs2);
 
             if ((len1 > 1 && len2 >= 1) || (len2 > 1 && len1 >= 1))
                 if ((push(&top, rs1) == OUT_OF_MEMORY) || (push(&top, rs2) == OUT_OF_MEMORY)) {
                     free(s1);
                     free(s2);
                     return OUT_OF_MEMORY;
                 }
         }
     }
     free(s1);
     free(s2);
     return (total > 0) ? ((score * 200) / total) : 0;

 }
 
 static unsigned int
 compare(char *ls1, char **rs1, char *ls2, char **rs2)
 {

     unsigned int common, maxchars = 0;
     bool some_similarity = FALSE;
     char *s1, *s2;
     char *maxs1 = NULL, *maxs2 = NULL, *maxe1 = NULL, *maxe2 = NULL;
     char *cs1, *cs2, *start1, *end1, *end2;
 
     end1   = ls1 + strlen(ls1);
     end2   = ls2 + strlen(ls2);
     start1 = ls1;
 
     for (;;) {
         s1 = start1;
         s2 = ls2;
 
         if (s1 < end1) {
             while (s1 < end1 && s2 < end2) {
                 if (tolower(*s1) == tolower(*s2)) {
                     some_similarity = TRUE;
                     cs1             = s1;
                     cs2             = s2;
                     common          = 0;
                     do
                         if (s1 == end1 || s2 == end2)
                             break;
                         else {
                             s1++;
                             s2++;
                             common++;
                         }
                     while (tolower(*s1) == tolower(*s2));
 
                     if (common > maxchars) {
                         unsigned int diff = common - maxchars;
                         maxchars          = common;
                         maxs1             = cs1;
                         maxs2             = cs2;
                         maxe1             = s1;
                         maxe2             = s2;
                         end1 -= diff;
                         end2 -= diff;
                     } else
                         s1 -= common;
                 } else
                     s2++;
             }
             start1++;
         } else
             break;
     }
     if (some_similarity) {
         *maxs1 = '\0';
         *maxs2 = '\0';
         *rs1   = maxe1;
         *rs2   = maxe2;
     }
     return maxchars;

 }
 
 static int
 push(LINK1 *top, const char *string)
 {

     LINK1 element;
 
     if ((element = (LINK1)cli_malloc(sizeof(ELEMENT1))) == NULL)
         return OUT_OF_MEMORY;
     if ((element->d1 = cli_strdup(string)) == NULL) {
         free(element);
         return OUT_OF_MEMORY;
     }
     element->next = *top;
     *top          = element;
 
     return SUCCESS;

 }
 
 static int
 pop(LINK1 *top, char *buffer)
 {

     LINK1 t1;
 
     if ((t1 = *top) != NULL) {
         (void)strcpy(buffer, t1->d1);
         *top = t1->next;
         free(t1->d1);
         free((char *)t1);
         return SUCCESS;
     }
     return FAILURE;

 }

 
 /*
  * Have we found a line that is a start of a uuencoded file (see uuencode(5))?
  */

 int isuuencodebegin(const char *line)

 {

     if (line[0] != 'b') /* quick check */
         return 0;

     if (strlen(line) < 10)
         return 0;

     return (strncasecmp(line, "begin ", 6) == 0) &&
            isdigit(line[6]) && isdigit(line[7]) &&
            isdigit(line[8]) && (line[9] == ' ');

 }

 
 #if HAVE_JSON
 json_object *messageGetJObj(message *m)
 {

     assert(m != NULL);

     if (m->jobj == NULL)
         m->jobj = cli_jsonobj(NULL, NULL);

     return m->jobj;

 }
 #endif