// This file is under GNU General Public License 3.0

// see LICENSE.txt

#include "pEp_internal.h"

#include "message_api.h"

#include "platform.h"

#include "mime.h"

#include "blacklist.h"

#include "baseprotocol.h"

#include "KeySync_fsm.h"

#include "base64.h"

#include "resource_id.h"

#include <assert.h>

#include <string.h>

#include <stdlib.h>

#include <math.h>

// These are globals used in generating message IDs and should only be

// computed once, as they're either really constants or OS-dependent

int _pEp_rand_max_bits;

double _pEp_log2_36;

static bool is_a_pEpmessage(const message *msg)

{

    for (stringpair_list_t *i = msg->opt_fields; i && i->value ; i=i->next) {

        if (strcasecmp(i->value->key, "X-pEp-Version") == 0)

            return true;

    }

    return false;

}

static bool is_wrapper(message* src)

{

    bool retval = false;

    if (src) {

        unsigned char pEpstr[] = PEP_SUBJ_STRING;

        if (is_a_pEpmessage(src) || (src->shortmsg == NULL || strcmp(src->shortmsg, "pEp") == 0 ||

            _unsigned_signed_strcmp(pEpstr, src->shortmsg, PEP_SUBJ_BYTELEN) == 0) ||

            (strcmp(src->shortmsg, "p=p") == 0)) {

            char* plaintext = src->longmsg;

            if (plaintext) {

                const char *line_end = strchr(plaintext, '\n');

                if (line_end != NULL) {

                    size_t n = line_end - plaintext;

                    char* copycat = calloc(n + 1, 1);

                    if (copycat) {

                        strlcpy(copycat, plaintext, n+1);

                        if (strstr(copycat, PEP_MSG_WRAP_KEY) && strstr(copycat, "OUTER"))

                            retval = true;

                        free(copycat);

                    }

                }

            }

        }

    }

    return retval;

}

/*

 * static stringpair_t* search_optfields(const message* msg, const char* key) {

 *     if (msg && key) {

 *         stringpair_list_t* opt_fields = msg->opt_fields;

 *         

 *         const stringpair_list_t* curr;

 *         

 *         for (curr = opt_fields; curr && curr->value; curr = curr->next) {

 *             if (curr->value->key) {

 *                 if (strcasecmp(curr->value->key, key) == 0)

 *                     return curr->value;

 *             }

 *         } 

 *     }

 *     return NULL;

 * }

 */

static char * keylist_to_string(const stringlist_t *keylist)

{

    if (keylist) {

        size_t size = stringlist_length(keylist);

        const stringlist_t *_kl;

        for (_kl = keylist; _kl && _kl->value; _kl = _kl->next) {

            size += strlen(_kl->value);

        }

        char *result = calloc(size, 1);

        if (result == NULL)

            return NULL;

        char *_r = result;

        for (_kl = keylist; _kl && _kl->value; _kl = _kl->next) {

            _r = stpcpy(_r, _kl->value);

            if (_kl->next && _kl->next->value)

                _r = stpcpy(_r, ",");

        }

        return result;

    }

    else {

        return NULL;

    }

}

static const char * rating_to_string(PEP_rating rating)

{

    switch (rating) {

    case PEP_rating_cannot_decrypt:

        return "cannot_decrypt";

    case PEP_rating_have_no_key:

        return "have_no_key";

    case PEP_rating_unencrypted:

        return "unencrypted";

    case PEP_rating_unencrypted_for_some: // don't use this any more

        return "undefined";

    case PEP_rating_unreliable:

        return "unreliable";

    case PEP_rating_reliable:

        return "reliable";

    case PEP_rating_trusted:

        return "trusted";

    case PEP_rating_trusted_and_anonymized:

        return "trusted_and_anonymized";

    case PEP_rating_fully_anonymous:

        return "fully_anonymous";

    case PEP_rating_mistrust:

        return "mistrust";

    case PEP_rating_b0rken:

        return "b0rken";

    case PEP_rating_under_attack:

        return "under_attack";

    default:

        return "undefined";

    }

}

bool _memnmemn(const char* needle, 

                size_t needle_size,

                const char* haystack, 

                size_t haystack_size) 

{

    if (needle_size > haystack_size) {

        return false;

    }

    else if (needle_size == 0) {

        return true;

    }

    bool found = true;

    const char* haystack_ptr = haystack;

    unsigned int i = 0;

    size_t remaining_hay = haystack_size;

    for (i = 0; i < haystack_size && (remaining_hay >= needle_size); i++, haystack_ptr++) {

        found = false;

        const char* needle_ptr = needle;

        if (*haystack_ptr == *needle) {

            const char* haystack_tmp = haystack_ptr;

            unsigned int j;

            found = true;

            for (j = 0; j < needle_size; j++) {

                if (*needle_ptr++ != *haystack_tmp++) {

                    found = false;

                    break;

                }

            }

            if (found)

                break;

        }

        remaining_hay--;

    }

    return found;

}

void add_opt_field(message *msg, const char *name, const char *value)

{

    assert(msg && name && value);

    if (msg && name && value) {

        stringpair_t *pair = new_stringpair(name, value);

        if (pair == NULL)

            return;

        stringpair_list_t *field = stringpair_list_add(msg->opt_fields, pair);

        if (field == NULL)

        {

            free_stringpair(pair);

            return;

        }

        if (msg->opt_fields == NULL)

            msg->opt_fields = field;

    }

}

void replace_opt_field(message *msg, 

                       const char *name, 

                       const char *value,

                       bool clobber)

{

    assert(msg && name && value);

    if (msg && name && value) {

        stringpair_list_t* opt_fields = msg->opt_fields;

        stringpair_t* pair = NULL;

        if (opt_fields) {

            while (opt_fields) {

                pair = opt_fields->value;

                if (pair && (strcmp(name, pair->key) == 0))

                    break;

                pair = NULL;

                opt_fields = opt_fields->next;

            }

        }

        if (pair) {

            if (clobber) {

                free(pair->value);

                pair->value = strdup(value);

            }

        }

        else {

            add_opt_field(msg, name, value);

        }

    }

}

static void decorate_message(

    message *msg,

    PEP_rating rating,

    stringlist_t *keylist,

    bool add_version,

    bool clobber

    )

{

    assert(msg);

    if (add_version)

        replace_opt_field(msg, "X-pEp-Version", PEP_VERSION, clobber);

    if (rating != PEP_rating_undefined)

        replace_opt_field(msg, "X-EncStatus", rating_to_string(rating), clobber);

    if (keylist) {

        char *_keylist = keylist_to_string(keylist);

        replace_opt_field(msg, "X-KeyList", _keylist, clobber);

        free(_keylist);

    }

}

static char* _get_resource_ptr_noown(char* uri) {

    char* uri_delim = strstr(uri, "://");

    if (!uri_delim)

        return uri;

    else

        return uri + 3;

}

static bool string_equality(const char *s1, const char *s2)

{

    if (s1 == NULL || s2 == NULL)

        return false;

    assert(s1 && s2);

    return strcmp(s1, s2) == 0;

}

static bool is_mime_type(const bloblist_t *bl, const char *mt)

{

    assert(mt);

    return bl && string_equality(bl->mime_type, mt);

}

//

// This function presumes the file ending is a proper substring of the

// filename (i.e. if bl->filename is "a.pgp" and fe is ".pgp", it will

// return true, but if bl->filename is ".pgp" and fe is ".pgp", it will

// return false. This is desired behaviour.

//

static bool is_fileending(const bloblist_t *bl, const char *fe)

{

    assert(fe);

    if (bl == NULL || bl->filename == NULL || fe == NULL || is_cid_uri(bl->filename))

        return false;

    assert(bl && bl->filename);

    size_t fe_len = strlen(fe);

    size_t fn_len = strlen(bl->filename);

    if (fn_len <= fe_len)

        return false;

    assert(fn_len > fe_len);

    return strcmp(bl->filename + (fn_len - fe_len), fe) == 0;

}

char * encapsulate_message_wrap_info(const char *msg_wrap_info, const char *longmsg)

{

    assert(msg_wrap_info);

    if (!msg_wrap_info) {

        if (!longmsg)

            return NULL;

        else {

            char *result = strdup(longmsg);

            assert(result);

            return result;            

        }    

    }

    if (longmsg == NULL)

        longmsg = "";

    const char * const newlines = "\n\n";

    const size_t NL_LEN = 2;

    const size_t bufsize = PEP_MSG_WRAP_KEY_LEN + strlen(msg_wrap_info) + NL_LEN + strlen(longmsg) + 1;

    char * ptext = calloc(bufsize, 1);

    assert(ptext);

    if (ptext == NULL)

        return NULL;

    strlcpy(ptext, PEP_MSG_WRAP_KEY, bufsize);

    strlcat(ptext, msg_wrap_info, bufsize);

    strlcat(ptext, newlines, bufsize);

    strlcat(ptext, longmsg, bufsize);

    return ptext;

}

static char * combine_short_and_long(const char *shortmsg, const char *longmsg)

{

    assert(shortmsg);

    unsigned char pEpstr[] = PEP_SUBJ_STRING;

    assert(strcmp(shortmsg, "pEp") != 0 && _unsigned_signed_strcmp(pEpstr, shortmsg, PEP_SUBJ_BYTELEN) != 0); 

    if (!shortmsg || strcmp(shortmsg, "pEp") == 0 || 

                     _unsigned_signed_strcmp(pEpstr, shortmsg, PEP_SUBJ_BYTELEN) == 0) {

        if (!longmsg) {

            return NULL;

        }

        else {

            char *result = strdup(longmsg);

            assert(result);

            return result;

        }

    }

    if (longmsg == NULL)

        longmsg = "";

    const char * const newlines = "\n\n";

    const size_t NL_LEN = 2;

    const size_t bufsize = PEP_SUBJ_KEY_LEN + strlen(shortmsg) + NL_LEN + strlen(longmsg) + 1;

    char * ptext = calloc(bufsize, 1);

    assert(ptext);

    if (ptext == NULL)

        return NULL;

    strlcpy(ptext, PEP_SUBJ_KEY, bufsize);

    strlcat(ptext, shortmsg, bufsize);

    strlcat(ptext, newlines, bufsize);

    strlcat(ptext, longmsg, bufsize);

    return ptext;

}

static PEP_STATUS replace_subject(message* msg) {

    unsigned char pEpstr[] = PEP_SUBJ_STRING;

    if (msg->shortmsg && *(msg->shortmsg) != '\0') {

        char* longmsg = combine_short_and_long(msg->shortmsg, msg->longmsg);

        if (!longmsg)

            return PEP_OUT_OF_MEMORY;

        else {

            free(msg->longmsg);

            msg->longmsg = longmsg;

        }

    }

    free(msg->shortmsg);

#ifdef WIN32

    msg->shortmsg = strdup("pEp");

#else

    msg->shortmsg = strdup((char*)pEpstr);

#endif    

    if (!msg->shortmsg)

        return PEP_OUT_OF_MEMORY;

    return PEP_STATUS_OK;

}

unsigned long long get_bitmask(int num_bits) {

    if (num_bits <= 0)

        return 0;

    unsigned long long bitmask = 0;

    int i;

    for (i = 1; i < num_bits; i++) {

        bitmask = bitmask << 1;

        bitmask |= 1;

    }

    return bitmask;

}

static char* get_base_36_rep(unsigned long long value, int num_sig_bits) {

    int bufsize = ((int) ceil((double) num_sig_bits / _pEp_log2_36)) + 1;

    // based on

    // https://en.wikipedia.org/wiki/Base36#C_implementation

    // ok, we supposedly have a 64-bit kinda sorta random blob

    const char base_36_symbols[37] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    char* retbuf = calloc(bufsize, 1); 

    assert(retbuf);

    if (!retbuf)

        return NULL;

    int i = bufsize - 1; // (end index)

    while (i > 0) {

        retbuf[--i] = base_36_symbols[value % 36];

        value /= 36;

    }

    return retbuf;

}

static char* message_id_prand_part(void) {

    // RAND modulus

    int num_bits = _pEp_rand_max_bits;

    if (num_bits < 0)

        return NULL;

    const int DESIRED_BITS = 64;

    num_bits = MIN(num_bits, DESIRED_BITS);

    int i;

    // at least 64 bits

    unsigned long long bitmask = get_bitmask(num_bits);

    unsigned long long output_value = 0;

    i = DESIRED_BITS;

    while (i > 0) {

        int bitshift = 0;

        int randval = rand();

        unsigned long long temp_val = randval & bitmask;

        output_value |= temp_val;

        i -= MIN(num_bits, i); 

        bitshift = MIN(num_bits, i);

        output_value <<= bitshift;        

        bitmask = get_bitmask(bitshift);

    }

    return get_base_36_rep(output_value, DESIRED_BITS);

}

static PEP_STATUS generate_message_id(message* msg) {

    if (!msg || !msg->from || !msg->from->address)

        return PEP_ILLEGAL_VALUE;

    char* time_prefix = NULL;

    char* random_id = NULL;

    char* retval = NULL;

    size_t buf_len = 2; // NUL + @

    char* from_addr = msg->from->address;

    char* domain_ptr = strstr(from_addr, "@");

    if (!domain_ptr || *(domain_ptr + 1) == '\0')

        domain_ptr = "localhost";

    else

        domain_ptr++;

    buf_len += strlen(domain_ptr);

    if (msg->id)

        free(msg->id);

    msg->id = NULL;

    time_t curr_time = time(NULL);

    time_prefix = get_base_36_rep(curr_time, (int) ceil(log2((double) curr_time)));

    if (!time_prefix)

        goto enomem;

    buf_len += strlen(time_prefix);

    random_id = message_id_prand_part();

    if (!random_id)

        goto enomem;

    buf_len += strlen(random_id);

    // make a new uuid - depending on rand() impl, time precision, etc,

    // we may still not be unique. We'd better make sure. So. 

    char new_uuid[37];

    pEpUUID uuid;

    uuid_generate_random(uuid);

    uuid_unparse_upper(uuid, new_uuid);

    buf_len += strlen(new_uuid);

    buf_len += 6; // "pEp" and 3 '.' chars

    retval = calloc(buf_len, 1);

    if (!retval)

        goto enomem;

    strlcpy(retval, "pEp.", buf_len);

    strlcat(retval, time_prefix, buf_len);

    strlcat(retval, ".", buf_len);

    strlcat(retval, random_id, buf_len);

    strlcat(retval, ".", buf_len);

    strlcat(retval, new_uuid, buf_len);        

    strlcat(retval, "@", buf_len);    

    strlcat(retval, domain_ptr, buf_len);    

    msg->id = retval;

    free(time_prefix);

    free(random_id);

    return PEP_STATUS_OK;

enomem:

    free(time_prefix);

    free(random_id);

    return PEP_OUT_OF_MEMORY;

}

/* 

   WARNING: For the moment, this only works for the first line of decrypted

   plaintext because we don't need more. IF WE DO, THIS MUST BE EXPANDED, or

   we need a delineated section to parse separately

   Does case-insensitive compare of keys, so sending in a lower-cased

   string constant saves a bit of computation

 */

static PEP_STATUS get_data_from_encapsulated_line(const char* plaintext, const char* key, 

                                                  const size_t keylen, char** data, 

                                                  char** modified_msg) {

    char* _data = NULL;

    char* _modified = NULL;

    if (strncasecmp(plaintext, key, keylen) == 0) {

        const char *line_end = strchr(plaintext, '\n');

        if (line_end == NULL) {

            _data = strdup(plaintext + keylen);

            assert(_data);

            if (_data == NULL)

                return PEP_OUT_OF_MEMORY;

        }

        else {

            size_t n = line_end - plaintext;

            if (*(line_end - 1) == '\r')

                _data = strndup(plaintext + keylen, n - (keylen + 1));

            else

                _data = strndup(plaintext + keylen, n - keylen);

            assert(_data);

            if (_data == NULL)

                return PEP_OUT_OF_MEMORY;

            while (*(plaintext + n) && (*(plaintext + n) == '\n' || *(plaintext + n) == '\r'))

                ++n;

            if (*(plaintext + n)) {

                _modified = strdup(plaintext + n);

                assert(_modified);

                if (_modified == NULL)

                    return PEP_OUT_OF_MEMORY;

            }

        }

    }

    *data = _data;

    *modified_msg = _modified;

    return PEP_STATUS_OK;

}

static int separate_short_and_long(const char *src, char **shortmsg, char** msg_wrap_info, char **longmsg)

{

    char *_shortmsg = NULL;

    char *_msg_wrap_info = NULL;

    char *_longmsg = NULL;

    assert(src);

    assert(shortmsg);

    assert(msg_wrap_info);

    assert(longmsg);

    if (src == NULL || shortmsg == NULL || msg_wrap_info == NULL || longmsg == NULL)

        return -1;

    *shortmsg = NULL;

    *longmsg = NULL;

    *msg_wrap_info = NULL;

    // We generated the input here. If we ever need more than one header value to be

    // encapsulated and hidden in the encrypted text, we will have to modify this.

    // As is, we're either doing this with a version 1.0 client, in which case

    // the only encapsulated header value is subject, or 2.0+, in which the

    // message wrap info is the only encapsulated header value. If we need this

    // to be more complex, we're going to have to do something more elegant

    // and efficient.    

    PEP_STATUS status = get_data_from_encapsulated_line(src, PEP_SUBJ_KEY_LC, 

                                                        PEP_SUBJ_KEY_LEN, 

                                                        &_shortmsg, &_longmsg);

    if (_shortmsg) {

        if (status == PEP_STATUS_OK)

            *shortmsg = _shortmsg;

        else

            goto enomem;

    }

    else {

        status = get_data_from_encapsulated_line(src, PEP_MSG_WRAP_KEY_LC, 

                                                 PEP_MSG_WRAP_KEY_LEN, 

                                                 &_msg_wrap_info, &_longmsg);

        if (_msg_wrap_info) {

            if (status == PEP_STATUS_OK)

                *msg_wrap_info = _msg_wrap_info;

            else

                goto enomem;

        }

    }

    // If there was no secret data hiding in the first line...

    if (!_shortmsg && !_msg_wrap_info) {

        _longmsg = strdup(src);

        assert(_longmsg);

        if (_longmsg == NULL)

            goto enomem;

    }

    *longmsg = _longmsg;

    return 0;

enomem:

    free(_shortmsg);

    free(_msg_wrap_info);

    free(_longmsg);

    return -1;

}

static PEP_STATUS copy_fields(message *dst, const message *src)

{

    assert(dst);

    assert(src);

    if(!(dst && src))

        return PEP_ILLEGAL_VALUE;

    free_timestamp(dst->sent);

    dst->sent = NULL;

    if (src->sent) {

        dst->sent = timestamp_dup(src->sent);

        if (dst->sent == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_timestamp(dst->recv);

    dst->recv = NULL;

    if (src->recv) {

        dst->recv = timestamp_dup(src->recv);

        if (dst->recv == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_identity(dst->from);

    dst->from = NULL;

    if (src->from) {

        dst->from = identity_dup(src->from);

        if (dst->from == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_identity_list(dst->to);

    dst->to = NULL;

    if (src->to && src->to->ident) {

        dst->to = identity_list_dup(src->to);

        if (dst->to == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_identity(dst->recv_by);

    dst->recv_by = NULL;

    if (src->recv_by) {

        dst->recv_by = identity_dup(src->recv_by);

        if (dst->recv_by == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_identity_list(dst->cc);

    dst->cc = NULL;

    if (src->cc && src->cc->ident) {

        dst->cc = identity_list_dup(src->cc);

        if (dst->cc == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_identity_list(dst->bcc);

    dst->bcc = NULL;

    if (src->bcc && src->bcc->ident) {

        dst->bcc = identity_list_dup(src->bcc);

        if (dst->bcc == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_identity_list(dst->reply_to);

    dst->reply_to = NULL;

    if (src->reply_to && src->reply_to->ident) {

        dst->reply_to = identity_list_dup(src->reply_to);

        if (dst->reply_to == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_stringlist(dst->in_reply_to);

    dst->in_reply_to = NULL;

    if (src->in_reply_to && src->in_reply_to->value) {

        dst->in_reply_to = stringlist_dup(src->in_reply_to);

        if (dst->in_reply_to == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_stringlist(dst->references);

    dst->references = NULL;

    if (src->references) {

        dst->references = stringlist_dup(src->references);

        if (dst->references == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_stringlist(dst->keywords);

    dst->keywords = NULL;

    if (src->keywords && src->keywords->value) {

        dst->keywords = stringlist_dup(src->keywords);

        if (dst->keywords == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free(dst->comments);

    dst->comments = NULL;

    if (src->comments) {

        dst->comments = strdup(src->comments);

        assert(dst->comments);

        if (dst->comments == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    free_stringpair_list(dst->opt_fields);

    dst->opt_fields = NULL;

    if (src->opt_fields) {

        dst->opt_fields = stringpair_list_dup(src->opt_fields);

        if (dst->opt_fields == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    return PEP_STATUS_OK;

}

// FIXME: error mem leakage

static message* extract_minimal_envelope(const message* src, 

                                         PEP_msg_direction direct) {

    message* envelope = new_message(direct);

    if (!envelope)

        return NULL;

    envelope->shortmsg = _pEp_subj_copy();

    if (!envelope->shortmsg)

        goto enomem;

    if (src->from) {

        envelope->from = identity_dup(src->from);

        if (!envelope->from)

            goto enomem;

    }

    if (src->to) {

        envelope->to = identity_list_dup(src->to);

        if (!envelope->to)

            goto enomem;

    }

    if (src->cc) {

        envelope->cc = identity_list_dup(src->cc);

        if (!envelope->cc)

            goto enomem;

    }

    if (src->bcc) {

        envelope->bcc = identity_list_dup(src->bcc);

        if (!envelope->bcc)

            goto enomem;

    }

    // For Outlook Force-Encryption

    // const char* pull_keys[] = {"pEp-auto-consume",

    //                            "pEp-force-protection",

    //                            "X-pEp-Never-Unsecure"};

    // int pull_keys_len = 3; // UPDATE WHEN MORE ADDED ABOVE

    // 

    // int i = 0;

    // stringpair_t* opt_add = NULL;    

    // for( ; i < pull_keys_len; i++) {        

    //     opt_add = search_optfields(src, pull_keys[i]);

    //     stringpair_list_t* add_ptr = NULL;

    //     if (opt_add) {

    //         add_ptr = stringpair_list_add(src->opt_fields, stringpair_dup(opt_add));

    //         if (!add_ptr)

    //             goto enomem;

    //     }

    //     opt_add = NULL;

    //     add_ptr = NULL;

    // }

    envelope->enc_format = src->enc_format;        

    return envelope;

enomem:

    free(envelope);

    return NULL;

}

static message * clone_to_empty_message(const message * src)

{

    PEP_STATUS status;

    message * msg = NULL;

    assert(src);

    if (src == NULL)

        return NULL;

    msg = calloc(1, sizeof(message));

    assert(msg);

    if (msg == NULL)

        goto enomem;

    msg->dir = src->dir;

    status = copy_fields(msg, src);

    if (status != PEP_STATUS_OK)

        goto enomem;

    return msg;

enomem:

    free_message(msg);

    return NULL;

}

static message* wrap_message_as_attachment(message* envelope, 

    message* attachment, message_wrap_type wrap_type, bool keep_orig_subject) {

    if (!attachment)

        return NULL;

    message* _envelope = envelope;

    PEP_STATUS status = PEP_STATUS_OK;

    replace_opt_field(attachment, "X-pEp-Version", PEP_VERSION, true);

    if (!_envelope && (wrap_type != PEP_message_transport)) {

        _envelope = extract_minimal_envelope(attachment, PEP_dir_outgoing);

        status = generate_message_id(_envelope);

        if (status != PEP_STATUS_OK)

            goto enomem;

        const char* inner_type_string = "";

        switch (wrap_type) {

            case PEP_message_key_reset:

                inner_type_string = "KEY_RESET";

                break;

            default:

                inner_type_string = "INNER";

        }

        attachment->longmsg = encapsulate_message_wrap_info(inner_type_string, attachment->longmsg);

        _envelope->longmsg = encapsulate_message_wrap_info("OUTER", _envelope->longmsg);

    }

    else if (_envelope) {

        _envelope->longmsg = encapsulate_message_wrap_info("TRANSPORT", _envelope->longmsg);

    }

    else {

        return NULL;

    }

    if (!attachment->id || attachment->id[0] == '\0') {

        free(attachment->id);

        if (!_envelope->id) {

            status = generate_message_id(_envelope);

            if (status != PEP_STATUS_OK)

                goto enomem;

        }

        attachment->id = strdup(_envelope->id);

    }

    char* message_text = NULL;

    /* prevent introduction of pEp in inner message */

    if (!attachment->shortmsg) {

        attachment->shortmsg = strdup("");

        if (!attachment->shortmsg)

            goto enomem;

    }

    /* Turn message into a MIME-blob */

    status = _mime_encode_message_internal(attachment, false, &message_text, true);

    if (status != PEP_STATUS_OK)

        goto enomem;

    size_t message_len = strlen(message_text);

    bloblist_t* message_blob = new_bloblist(message_text, message_len,

                                            "message/rfc822", NULL);

    _envelope->attachments = message_blob;

    if (keep_orig_subject && attachment->shortmsg)

        _envelope->shortmsg = strdup(attachment->shortmsg);

    return _envelope;

enomem:

    if (!envelope) {

        free_message(_envelope);

    }

    return NULL;    

}

static PEP_STATUS encrypt_PGP_inline(

        PEP_SESSION session,

        const message *src,

        stringlist_t *keys,

        message *dst,

        PEP_encrypt_flags_t flags

    )

{

    char *ctext = NULL;

    size_t csize = 0;

    PEP_STATUS status = encrypt_and_sign(session, keys, src->longmsg,

            strlen(src->longmsg), &ctext, &csize);

    if (status)

        return status;

    dst->enc_format = PEP_enc_inline;

    // shortmsg is being copied