// This file is under GNU General Public License 3.0

 // see LICENSE.txt

 #include "platform.h"

 #include "pEp_internal.h"

 #include "internal_format.h"

 static struct _internal_message_type {

     char type;

     char subtype;

     const char *mime_type;

 } message_type[] = {

     // Keys

     { 'K',  0, "application/keys" },

     // OpenPGP

     { 'K',  2, "application/pgp-keys" },

     // x.509

     { 'K',  3, "application/pkcs10" },

     { 'K',  4, "application/pkix-cert" },

     { 'K',  5, "application/pkix-crl" },

     { 'K',  6, "application/pkcs7-mime" },

     { 'K',  7, "application/x-x509-ca-cert" },

     { 'K',  8, "application/x-x509-user-cert" },

     { 'K',  9, "application/x-pkcs7-crl" },

     { 'K', 10, "application/x-pem-file" },

     { 'K', 11, "application/x-pkcs12" },

     { 'K', 12, "application/x-pkcs7-certificates" },

     { 'K', 13, "application/x-pkcs7-certreqresp" },

     // Sync

     { 'S', 0, "application/pEp.sync" },

     // Distribution

     { 'D', 0, "application/pEp.distribution" },

     { 'D', 0, "application/pEp.keyreset" },

     // Authentication

     { 'A', 0, "application/auth" },

     { 'A', 1, "application/signature" },

     // OpenPGP

     { 'A', 2, "application/pgp-signature" },

     // x.509

     { 'A', 3, "application/pkcs7-signature" },

     { 'A', 3, "application/x-pkcs7-signature" },

     // end marker

     { 0, 0, NULL }

 };

 DYNAMIC_API PEP_STATUS encode_internal(

         const char *value,

         size_t size,

         const char *mime_type,

         char **code,

         size_t *code_size

     )

 {

     assert(value && size && mime_type && code && code_size);

     if (!(value && size && mime_type && code && code_size))

         return PEP_ILLEGAL_VALUE;

     *code = NULL;

     *code_size = 0;

     char type = 0;

     char subtype;

     struct _internal_message_type *mt;

     for (mt = message_type; mt->type; ++mt) {

         if (strcasecmp(mime_type, mt->mime_type) == 0) {

             type = mt->type;

             subtype = mt->subtype;

             break;

         }

     }

     // unsupported MIME type

     if (!type)

         return PEP_STATUS_OK;

     // those are more BSOBs than BLOBS, so we copy

     char *result = malloc(size + 4);

     assert(result);

     if (!result)

         return PEP_OUT_OF_MEMORY;

     result[0] = 0;

     result[1] = type;

     result[2] = subtype;

     result[3] = 0;

     memcpy(result + 4, value, size);

     *code = result;

     *code_size = size + 4;

     return PEP_STATUS_OK;

 }

 DYNAMIC_API PEP_STATUS decode_internal(

         const char *code,

         size_t code_size,

         char **value,

         size_t *size,

         char **mime_type

     )

 {

     assert(value && size && mime_type && code && !code[0] && code_size);

     if (!(value && size && mime_type && code && !code[0] && code_size))

         return PEP_ILLEGAL_VALUE;

     *value = NULL;

     *size = 0;

     *mime_type = NULL;

     // elevated attachments have at least 5 bytes

     assert(code_size > 4);

     if (code_size < 5)

         return PEP_ILLEGAL_VALUE;

     assert(!code[0]);

     char type = code[1];

     char subtype = code[2];

     // char reserved = code[3];

     char *_mime_type = NULL;

     struct _internal_message_type *mt;

     for (mt = message_type; mt->type; ++mt) {

         if (type == mt->type && subtype == mt->subtype) {

             assert(mt->mime_type);

             _mime_type = strdup(mt->mime_type);

             assert(_mime_type);

             if (!_mime_type)

                 return PEP_OUT_OF_MEMORY;

             break;

         }

     }

     if (!_mime_type)

         return PEP_ILLEGAL_VALUE;

     char *result = malloc(code_size - 4);

     assert(result);

     if (!result) {

         free(_mime_type);

         return PEP_OUT_OF_MEMORY;

     }

     memcpy(result, code + 4, code_size - 4);

     *value = result;

     *size = code_size - 4;

     *mime_type = _mime_type;

     return PEP_STATUS_OK;

 }