// This file is under GNU General Public License 3.0

 // see LICENSE.txt

 #include "platform.h"

 // it seems pEp_internal.h needs to be the first pEp include due to the 

 // #define for the dllimport / dllexport DYNAMIC_API stuff.

 #include "pEp_internal.h"

 #include "sync_impl.h"

 #include "keymanagement.h"

 #include "message_api.h"

 #include "map_asn1.h"

 #include "baseprotocol.h"

 #define SYNC_VERSION_MAJOR 1

 #define SYNC_VERSION_MINOR 0

 #define SYNC_INHIBIT_TIME (60*10)

 #define SYNC_MSG_EXPIRE_TIME (60 * 10)

 struct _sync_msg_t {

     bool is_a_message;

     union {

         DeviceGroup_Protocol_t *message;

         struct {

             DeviceState_event event;

             Identity partner;

             void *extra;

         } event;

     } u;

 };

 static bool _is_own_uuid( PEP_SESSION session, UTF8String_t *uuid)

 {

     return strncmp(session->sync_session->sync_uuid,

                    (const char*)uuid->buf, uuid->size) == 0;

 }

 static bool _is_own_group_uuid( PEP_SESSION session, UTF8String_t *uuid, char** our_group)

 {

     PEP_STATUS status = PEP_STATUS_OK;

     char *devgrp = NULL;

     if(our_group == NULL || *our_group == NULL)

         status = get_device_group(session, &devgrp);

     else

         devgrp = *our_group;

     bool res = (status == PEP_STATUS_OK && devgrp && devgrp[0] &&

         strncmp(devgrp,(const char*)uuid->buf, uuid->size) == 0);

     if(our_group == NULL)

         free(devgrp);

     else if(*our_group == NULL)

         *our_group = devgrp;

     return res;

 }

 PEP_STATUS receive_sync_msg(

         PEP_SESSION session,

         sync_msg_t *sync_msg,

         time_t *timeout

     )

 {

     PEP_STATUS status;

     void *extra = NULL;

     Identity partner = NULL;

     DeviceState_event event = DeviceState_event_NONE;

     assert(session && sync_msg);

     if (!(session && sync_msg))

         return PEP_ILLEGAL_VALUE;

     char* own_id = NULL;

     bool msgIsFromGroup = false;

     if(sync_msg->is_a_message){

         DeviceGroup_Protocol_t *msg = sync_msg->u.message;

         assert(msg && msg->payload.present != DeviceGroup_Protocol__payload_PR_NOTHING);

         if (!(msg && msg->payload.present != DeviceGroup_Protocol__payload_PR_NOTHING)){

             status = PEP_OUT_OF_MEMORY;

             goto error;

         }

         partner = Identity_to_Struct(&msg->header.me, NULL);

         if (!partner){

             status = PEP_OUT_OF_MEMORY;

             ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

             goto error;

         }

         msgIsFromGroup = msg->header.devicegroup;

         switch (msg->payload.present) {

             case DeviceGroup_Protocol__payload_PR_beacon:

                 event = Beacon;

                 break;

             case DeviceGroup_Protocol__payload_PR_handshakeRequest:

             {

                 // re-check uuid in case sync_uuid or group changed while in the queue

                 char *own_group_id = NULL;

                 bool is_for_me = _is_own_uuid(session, 

                     msg->payload.choice.handshakeRequest.partner_id);

                 bool is_for_group = !is_for_me && _is_own_group_uuid(session, 

                     msg->payload.choice.handshakeRequest.partner_id, &own_group_id);

                 if (!(is_for_me || is_for_group)){

                     status = PEP_MESSAGE_IGNORE;

                     goto error;

                 }

                 UTF8String_t *guuid = msg->payload.choice.handshakeRequest.group_id;

                 if(msgIsFromGroup && guuid && guuid->buf && guuid->size) {

                     bool is_from_own_group = _is_own_group_uuid(session, 

                                                                 guuid, &own_group_id);

                     // Filter handshake requests from own group

                     if(is_from_own_group) {

                         status = PEP_MESSAGE_IGNORE;

                         goto error;

                     }

                     // if it comes from another group, 

                     // we want to communicate with that group

                     // insert group_id given in handshake request 

                     // into partner's id

                     free(partner->user_id);

                     partner->user_id = strndup((const char*)guuid->buf, guuid->size);

                     if(partner->user_id == NULL){

                         status = PEP_OUT_OF_MEMORY;

                         goto error;

                     }

                     // if it comes from another group, and we are grouped,

                     // then this is groupmerge

                 }

                 event = HandshakeRequest;

                 break;

             }

             case DeviceGroup_Protocol__payload_PR_updateRequest:

                 event = UpdateRequest;

                 break;

             case DeviceGroup_Protocol__payload_PR_groupKeys:

             {

                 // re-check uuid in case sync_uuid or group_uuid changed while in the queue

                 char *own_group_id = NULL;

                 UTF8String_t *puuid = msg->payload.choice.groupKeys.partner_id;

                 bool is_for_me = _is_own_uuid(session, puuid);

                 bool is_for_group = !is_for_me &&

                                     _is_own_group_uuid(session, 

                                         puuid, &own_group_id);

                 if (!(is_for_me || is_for_group)){

                     status = PEP_MESSAGE_IGNORE;

                     goto error;

                 }

                 UTF8String_t *guuid = msg->payload.choice.groupKeys.group_id;

                 // GroupKeys come from groups, no choice

                 if(!(msgIsFromGroup && guuid && guuid->buf && guuid->size)) {

                     status = PEP_SYNC_ILLEGAL_MESSAGE;

                     goto error;

                 }

                 // Filter groupKeys from own group

                 bool is_from_own_group = _is_own_group_uuid(session, 

                                                             guuid, 

                                                             &own_group_id);

                 if(is_from_own_group) {

                     // FixMe : protocol shouldn't allow this

                     status = PEP_SYNC_ILLEGAL_MESSAGE;

                     goto error;

                 }

                 // insert group_id given in groupKeys into partner's id

                 free(partner->user_id);

                 partner->user_id = strndup((const char*)guuid->buf, guuid->size);

                 if(partner->user_id == NULL){

                     status = PEP_OUT_OF_MEMORY;

                     goto error;

                 }

                 // if it comes from another group, and we are grouped,

                 // then this is groupmerge's groupKeys

                 group_keys_extra_t *group_keys_extra;

                 group_keys_extra = malloc(sizeof(group_keys_extra_t));

                 if(group_keys_extra == NULL){

                     status = PEP_OUT_OF_MEMORY;

                     ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

                     goto error;

                 }

                 char *group_id = strndup((char*)guuid->buf, guuid->size);

                 if (!group_id){

                     status = PEP_OUT_OF_MEMORY;

                     free(group_keys_extra);

                     ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

                     goto error;

                 }

                 group_keys_extra->group_id = group_id;

                 identity_list *group_keys = IdentityList_to_identity_list(

                         &msg->payload.choice.groupKeys.ownIdentities,

                         NULL);

                 if (!group_keys) {

                     status = PEP_OUT_OF_MEMORY;

                     free(group_id);

                     free(group_keys_extra);

                     ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

                     goto error;

                 }

                 group_keys_extra->group_keys = group_keys;

                 extra = (void *) group_keys_extra;

                 event = GroupKeys;

                 break;

             }

             case DeviceGroup_Protocol__payload_PR_groupUpdate:

             {

                 identity_list *group_keys = IdentityList_to_identity_list(

                         &msg->payload.choice.groupUpdate.ownIdentities, NULL);

                 if (!group_keys) {

                     status = PEP_OUT_OF_MEMORY;

                     ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

                     goto error;

                 }

                 extra = (void *) group_keys;

                 event = GroupUpdate;

                 break;

             }

             default:

                 status = PEP_SYNC_ILLEGAL_MESSAGE;

                 ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

                 goto error;

         }

     }

     else{

         partner = sync_msg->u.event.partner;

         extra = sync_msg->u.event.extra;

         event = sync_msg->u.event.event;

     }

     // Event inhibition, to limit mailbox and prevent cycles

     time_t *last = NULL;

     switch(event){

         case CannotDecrypt:

             last = &session->LastCannotDecrypt;

             break;

         case UpdateRequest:

             last = &session->LastUpdateRequest;

             break;

         default:

             break;

     }

     if(last != NULL){

         time_t now = time(NULL);

         if(*last != 0 && (*last + SYNC_INHIBIT_TIME) > now ){

             status = PEP_STATEMACHINE_INHIBITED_EVENT;

             goto error;

         }

         *last = now;

     }

     // partner identity must be explicitely added DB to later

     // be able to communicate securely with it.

     if(partner){

         status = get_default_own_userid(session, &own_id);

         if (!own_id)

             own_id = strdup(PEP_OWN_USERID);

         // protect virtual user IDs 

         if((strncmp("TOFU_", partner->user_id, 6) == 0 &&

            strlen(partner->user_id) == strlen(partner->address) + 6 &&

            strcmp(partner->user_id + 6, partner->address)) ||

         // protect own ID 

            (strcmp(own_id, partner->user_id) == 0)){

             status = PEP_SYNC_ILLEGAL_MESSAGE;

             free(own_id);

             goto error;

         }

         free(own_id);

         // partner IDs are UUIDs bound to session lifespan

         // and therefore partner identities are not supposed

         // to mutate over time, but just not be used anymore.

         // It should then be safe to accept given identity if not 

         // already pre-existing

         pEp_identity *stored_identity = NULL;

         status = get_identity(session,

                               partner->address,

                               partner->user_id,

                               &stored_identity);

         if (!stored_identity) {

             // make a safe copy of partner, with no flags or comm_type

             pEp_identity *tmpident = new_identity(partner->address,

                                                   partner->fpr,

                                                   partner->user_id,

                                                   partner->username);

             if (tmpident == NULL){

                 status = PEP_OUT_OF_MEMORY;

                 goto error;

             }

             // finaly add partner to DB

             status = set_identity(session, tmpident);

             assert(status == PEP_STATUS_OK);

             if(status == PEP_STATUS_OK && msgIsFromGroup)

                 status = set_identity_flags(session, tmpident, PEP_idf_devicegroup);

             free_identity(tmpident);

             assert(status == PEP_STATUS_OK);

             if (status != PEP_STATUS_OK) {

                 goto error;

             }

         }

         else if (status == PEP_STATUS_OK) {

             free_identity(stored_identity);

         } 

         else

             goto error;

     }

     status = fsm_DeviceState_inject(session, event, partner, extra, timeout);

 error:

     free_identity(partner);

     switch(event){

         case GroupKeys:

         {

             free_group_keys_extra((group_keys_extra_t*)extra);

             break;

         }

         case GroupUpdate:

         {

             identity_list *group_keys = (identity_list*) extra;

             free_identity_list(group_keys);

             break;

         }

         default:

             assert(extra==NULL);

             break;

     }

     free(sync_msg);

     free(own_id);

     return status;

 }

 // TODO: DYNAMIC_API was here, but broke the windows build. 

 // We need to check whether it belongs here or it's a bug.

 /* DYNAMIC_API */ void free_sync_msg(sync_msg_t *sync_msg)

 {

     if (!sync_msg)

         return;

     if(sync_msg->is_a_message){

         DeviceGroup_Protocol_t *msg = sync_msg->u.message;

         assert(msg);

         if (!(msg))

             return;

         ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

     }

     else{

         Identity partner = NULL;

         partner = sync_msg->u.event.partner;

         if(partner != NULL)

             free_identity(partner);

     }

     free(sync_msg);

     return;

 }

 // from sync.c

 int call_inject_sync_msg(PEP_SESSION session, void *msg);

 PEP_STATUS inject_DeviceState_event(

     PEP_SESSION session, 

     DeviceState_event event,

     Identity partner,

     void *extra)

 {

     PEP_STATUS status;

     assert(session);

     if (!(session))

         return PEP_ILLEGAL_VALUE;

     sync_msg_t *sync_msg = malloc(sizeof(sync_msg_t));

     if(sync_msg == NULL)

         return PEP_OUT_OF_MEMORY;

     sync_msg->is_a_message = false;

     sync_msg->u.event.partner = partner;

     sync_msg->u.event.extra = extra;

     sync_msg->u.event.event = event;

     status = call_inject_sync_msg(session, sync_msg);

     if (status == PEP_SYNC_NO_INJECT_CALLBACK){

         free(sync_msg);

     }

     return status;

 }

 PEP_STATUS receive_DeviceState_msg(

     PEP_SESSION session, 

     message *src, 

     PEP_rating rating, 

     stringlist_t *keylist)

 {

     assert(session && src);

     if (!(session && src))

         return PEP_ILLEGAL_VALUE;

     bool consume = false;

     bool discard = false;

     bool force_keep_msg = false;

     char* own_id = NULL;

     PEP_STATUS own_id_status = get_default_own_userid(session, &own_id);

     for (bloblist_t *bl = src->attachments; bl && bl->value; bl = bl->next) {

         if (bl->mime_type && strcasecmp(bl->mime_type, "application/pEp.sync") == 0

                 && bl->size) {

             DeviceGroup_Protocol_t *msg = NULL;

             uper_decode_complete(NULL, &asn_DEF_DeviceGroup_Protocol, (void **)

                     &msg, bl->value, bl->size);

             if (msg) {

                 PEP_STATUS status = PEP_STATUS_OK;

                 char *user_id = strndup((char *) msg->header.me.user_id->buf,

                         msg->header.me.user_id->size);

                 assert(user_id);

                 if (!user_id) {

                     ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

                     return PEP_OUT_OF_MEMORY;

                 }

                 // detect and mitigate address spoofing

                 Identity check_me = NULL;

                 char* null_terminated_address = 

                     strndup((char *) msg->header.me.address->buf,

                             msg->header.me.address->size);

                 if(null_terminated_address){

                     if (own_id) {                        

                         status = get_identity(session, 

                                               null_terminated_address, 

                                               own_id, 

                                               &check_me);

                         free(null_terminated_address);

                     }

                     else {

                         status = own_id_status;

                     }

                 } 

                 else

                     status = PEP_OUT_OF_MEMORY;

                 if (status == PEP_OUT_OF_MEMORY)

                     goto free_all;

                 free_identity(check_me);

                 bool not_own_address = status != PEP_STATUS_OK;

                 status = PEP_STATUS_OK;

                 if (not_own_address || 

                     strncmp(src->from->address,

                             (char *) msg->header.me.address->buf,

                             msg->header.me.address->size) != 0 ||

                     strncmp(src->to->ident->address,

                             (char *) msg->header.me.address->buf,

                             msg->header.me.address->size) != 0) {

                     consume = true;

                     goto free_all;

                 }

                 // if encrypted, ensure that header.me.fpr match signer's fpr

                 if (rating >= PEP_rating_reliable && (

                         !keylist ||

                         !_same_fpr((char *) msg->header.me.fpr.buf,

                                    msg->header.me.fpr.size,

                                    keylist->value,

                                    strlen(keylist->value)))) {

                     consume = true;

                     goto free_all;

                 }

                 // check message expiry 

                 if(src->recv) {

                     time_t expiry = timegm(src->recv) + SYNC_MSG_EXPIRE_TIME;

                     time_t now = time(NULL);

                     if(expiry != 0 && now != 0 && expiry < now){

                         consume = true;

                         goto free_all;

                     }

                 }

                 int32_t value = (int32_t) msg->header.sequence;

                 if (value < 1) {

                     status = PEP_SEQUENCE_VIOLATED;

                 } else {

                     status = sequence_value(session, (char *) user_id,

                             &value);

                 }

                 if (status == PEP_STATUS_OK) {

                     switch (msg->payload.present) {

                         // HandshakeRequest needs encryption

                         case DeviceGroup_Protocol__payload_PR_handshakeRequest:

                         {

                             UTF8String_t *puuid = 

                               msg->payload.choice.handshakeRequest.partner_id;

                             bool is_for_me = _is_own_uuid(session, puuid);

                             bool is_for_group = !is_for_me && 

                                                 _is_own_group_uuid(

                                                     session, puuid, NULL);

                             // Reject handshake requests not addressed to us

                             if (rating < PEP_rating_reliable ||

                                 !(is_for_me || is_for_group)){

                                 discard = true;

                                 goto free_all;

                             }

                             // do not consume handshake request for group

                             if(is_for_group){ 

                                 force_keep_msg = true;

                             }

                             break;

                         }

                         // accepting GroupKeys needs encryption and trust of peer device

                         case DeviceGroup_Protocol__payload_PR_groupKeys:

                         {

                             UTF8String_t *puuid = msg->payload.choice.groupKeys.partner_id;

                             bool is_for_me = _is_own_uuid(session, puuid);

                             bool is_for_group = !is_for_me &&

                                                 _is_own_group_uuid(session, 

                                                     puuid, NULL);

                             if (!keylist || rating < PEP_rating_reliable ||

                                 // message is only consumed by instance it is addressed to

                                 !(is_for_me || is_for_group)){

                                 discard = true;

                                 goto free_all;

                             }

                             // do not consume groupKeys for group

                             if(is_for_group){ 

                                 // This happens in case case of groupmerge

                                 force_keep_msg = true;

                             }

                             // Trust check disabled here but it still it should be safe.

                             // SameIdentity checks in state machine ensures that we only

                             // store groupkeys signed by device or group that have been 

                             // previously accepted in handshake.

                             //

                             // // check trust of identity using user_id given in msg.header.me

                             // // to exacly match identity of device, the one trusted in

                             // // case of accepted handshake from a sole device

                             // pEp_identity *_from = new_identity(NULL, 

                             //                                    keylist->value,

                             //                                    user_id,

                             //                                    NULL);

                             // if (_from == NULL){

                             //     status = PEP_OUT_OF_MEMORY;

                             //     goto free_all;

                             // }

                             // status = get_trust(session, _from);

                             // if (status != PEP_STATUS_OK || _from->comm_type < PEP_ct_strong_encryption) {

                             //     // re-try with group_id instead, in case of handshake with pre-existing group

                             //     UTF8String_t *guuid = msg->payload.choice.groupKeys.group_id;

                             //     free(_from->user_id);

                             //     if ((_from->user_id = strndup((const char*)guuid->buf, guuid->size)) == NULL){

                             //         free_identity(_from);

                             //         status = PEP_OUT_OF_MEMORY;

                             //         goto free_all;

                             //     }

                             //     _from->comm_type = PEP_ct_unknown;

                             //     status = get_trust(session, _from);

                             //     if (status != PEP_STATUS_OK || _from->comm_type < PEP_ct_strong_encryption) {

                             //         status = PEP_STATUS_OK;

                             //         free_identity(_from);

                             //         discard = true;

                             //         goto free_all;

                             //     }

                             // }

                             // free_identity(_from);

                             break;

                         }

                         case DeviceGroup_Protocol__payload_PR_groupUpdate:

                         case DeviceGroup_Protocol__payload_PR_updateRequest:

                         {

                             // inject message but don't consume it, so 

                             // that other group members can also be updated

                             force_keep_msg = true;

                             if (!keylist || rating < PEP_rating_reliable){

                                 discard = true;

                                 goto free_all;

                             }

                             // GroupUpdate and UpdateRequests come from group.

                             // check trust relation in between signer key and 

                             // own id to be sure.

                             if (status != PEP_STATUS_OK)

                                 goto free_all;

                             pEp_identity* _from = NULL;

                             if (own_id) {    

                                 _from = new_identity(NULL, 

                                                      keylist->value,

                                                      own_id,

                                                      NULL);

                             }

                             else {

                                 status = own_id_status;

                                 goto free_all;

                             }

                             if (_from == NULL){

                                 status = PEP_OUT_OF_MEMORY;

                                 goto free_all;

                             }

                             status = get_trust(session, _from);

                             if (status != PEP_STATUS_OK || _from->comm_type < PEP_ct_pEp) {

                                 status = PEP_STATUS_OK;

                                 free_identity(_from);

                                 discard = true;

                                 goto free_all;

                             }

                             free_identity(_from);

                         }

                         default:

                             break;

                     }

                     consume = true;

                     sync_msg_t *sync_msg = malloc(sizeof(sync_msg_t));

                     if(sync_msg == NULL){

                         status = PEP_OUT_OF_MEMORY;

                         goto free_all;

                     }

                     sync_msg->is_a_message = true;

                     sync_msg->u.message = msg;

                     status = call_inject_sync_msg(session, sync_msg);

                     if (status != PEP_STATUS_OK){

                         if (status == PEP_SYNC_NO_INJECT_CALLBACK){

                             free(sync_msg);

                         }

                         goto free_all;

                     }

                     // don't free message now that it is in the queue

                     goto free_userid;

                 }

                 else if (status == PEP_OWN_SEQUENCE || status == PEP_SEQUENCE_VIOLATED) {

                     status = PEP_STATUS_OK;

                     discard = true;

                     goto free_all;

                 }

             free_all:

                 ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

             free_userid:

                 free(user_id);

                 free(own_id);

                 if (status != PEP_STATUS_OK)

                     return status;

             }

         }

     }

     if (force_keep_msg) {

         return PEP_MESSAGE_IGNORE;

     }

     if (consume && !session->keep_sync_msg) {

         for (stringpair_list_t *spl = src->opt_fields ; spl && spl->value ;

                 spl = spl->next) {

             if (spl->value->key &&

                     strcasecmp(spl->value->key, "pEp-auto-consume") == 0) {

                 if (spl->value->value &&

                         strcasecmp(spl->value->value, "yes") == 0)

                     return PEP_MESSAGE_CONSUME;

             }

         }

         return PEP_MESSAGE_IGNORE;

     }

     if(discard)

         return PEP_MESSAGE_IGNORE;

     if (!session->keep_sync_msg) {

         bloblist_t *last = NULL;

         for (bloblist_t *bl = src->attachments; bl && bl->value; ) {

             if (bl->mime_type && strcasecmp(bl->mime_type, "application/pEp.sync") == 0) {

                 bloblist_t *b = bl;

                 bl = bl->next;

                 if (!last)

                     src->attachments = bl;

                 else

                     last->next = bl;

                 free(b->mime_type);

                 free(b->filename);

                 free(b->value);

                 free(b);

             }

             else {

                 last = bl;

                 bl = bl->next;

             }

         }

     }

     return PEP_STATUS_OK;

 }

 DeviceGroup_Protocol_t *new_DeviceGroup_Protocol_msg(DeviceGroup_Protocol__payload_PR type)

 {

     DeviceGroup_Protocol_t *msg = (DeviceGroup_Protocol_t *)

             calloc(1, sizeof(DeviceGroup_Protocol_t));

     assert(msg);

     if (!msg)

         return NULL;

     msg->payload.present = type;

     return msg;

 }

 void free_DeviceGroup_Protocol_msg(DeviceGroup_Protocol_t *msg)

 {

     ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

 }

 #ifndef NDEBUG

 static int _append(const void *buffer, size_t size, void *appkey)

 {

     char **dest_ptr = (char **)appkey;

     size_t osize = strlen(*dest_ptr);

     size_t nsize = size + osize;

     *dest_ptr = realloc(*dest_ptr, nsize + 1);

     if(*dest_ptr == NULL) return -1;

     memcpy(*dest_ptr + osize, buffer, size);

     (*dest_ptr)[nsize] = '\0';

     return 0;

 }

 #endif

 PEP_STATUS unicast_msg(

         PEP_SESSION session,

         const Identity partner,

         DeviceState_state state,

         DeviceGroup_Protocol_t *msg,

         bool encrypted

     )

 {

     PEP_STATUS status = PEP_STATUS_OK;

     char *payload = NULL;

     message *_message = NULL;

     pEp_identity *me = NULL;

     pEp_identity *_me = NULL;

     char* own_id = NULL;

     assert(session && partner && state && msg);

     if (!(session && partner && state && msg))

         return PEP_ILLEGAL_VALUE;

     assert(session->messageToSend);

     if (!session->messageToSend) {

         status = PEP_SEND_FUNCTION_NOT_REGISTERED;

         goto error;

     }

     status = get_default_own_userid(session, &own_id);

     if (status != PEP_STATUS_OK)

         goto error;

     msg->header.version.major = SYNC_VERSION_MAJOR;

     msg->header.version.minor = SYNC_VERSION_MINOR;

     status = get_identity(session, partner->address, own_id, &me);

     if (status != PEP_STATUS_OK)

         goto error;

     int32_t seq = 0;

     status = sequence_value(session, session->sync_session->sync_uuid, &seq);

     if (status != PEP_OWN_SEQUENCE && status != PEP_STATUS_OK)

         goto error;

     msg->header.sequence = (long) seq;

     _me = identity_dup(me);

     if (!_me)

         goto enomem;

     free(_me->user_id);

     _me->user_id = strndup(session->sync_session->sync_uuid, 36);

     assert(_me->user_id);

     if (!_me->user_id)

         goto enomem;

     if (Identity_from_Struct(_me, &msg->header.me) == NULL)

         goto enomem;

     free_identity(_me);

     _me = NULL;

     msg->header.state = (long) state;

     bool devicegroup = deviceGrouped(session);

     if (devicegroup)

         msg->header.devicegroup = 1;

     else

         msg->header.devicegroup = 0;

     if (asn_check_constraints(&asn_DEF_DeviceGroup_Protocol, msg, NULL, NULL)) {

         status = PEP_CONTRAINTS_VIOLATED;

         goto error;

     }

     ssize_t size = uper_encode_to_new_buffer(&asn_DEF_DeviceGroup_Protocol,

             NULL, msg, (void **) &payload);

     if (size == -1) {

         status = PEP_CANNOT_ENCODE;

         goto error;

     }

     status = prepare_message(me, partner, payload, size, &_message);

     if (status != PEP_STATUS_OK)

         goto error;

     payload = NULL;

     free_identity(me);

     me = NULL;

 #ifndef NDEBUG

     asn_enc_rval_t er;

     er = xer_encode(&asn_DEF_DeviceGroup_Protocol, msg, 

                     XER_F_BASIC, _append, &_message->longmsg);

     if(er.encoded == -1)

         goto error;

 #endif

     if (encrypted) {

         if (msg->payload.present == DeviceGroup_Protocol__payload_PR_groupKeys || 

             msg->payload.present == DeviceGroup_Protocol__payload_PR_groupUpdate) {

             PEP_rating rating = PEP_rating_undefined;

             status = outgoing_message_rating(session, _message, &rating);

             if (status != PEP_STATUS_OK)

                 goto error;

             if (rating < PEP_rating_trusted) {

                 status = PEP_SYNC_NO_TRUST;

                 goto error;

             }

             stringlist_t *keylist = NULL;

             status = _own_keys_retrieve(session, &keylist, PEP_idf_not_for_sync);

             if (status != PEP_STATUS_OK)

                 goto error;

             for (stringlist_t *_keylist=keylist; _keylist!=NULL; _keylist=_keylist->next) {

                 char *fpr = _keylist->value;

                 static char filename[MAX_LINELENGTH];

                 int result = snprintf(filename, MAX_LINELENGTH, "file://%s-sec.asc", fpr);

                 if (result < 0)

                     goto enomem;

                 char *key = NULL;

                 size_t size = 0;

                 status = export_secret_key(session, fpr, &key, &size);

                 if (status != PEP_STATUS_OK)

                     goto error;

                 bloblist_t *bl = bloblist_add(_message->attachments,

                         (char *) key, size, "application/pgp-keys", filename);

                 if (!bl)

                     goto enomem;

                 if (!_message->attachments)

                     _message->attachments = bl;

             }

         }

         message *_encrypted = NULL;

         status = encrypt_message(session, _message, NULL, &_encrypted, PEP_enc_PEP, 0);

         if (status != PEP_STATUS_OK)

             goto error;

         free_message(_message);

         _message = _encrypted;

     }

     else {

         attach_own_key(session, _message);

     }

     status = session->messageToSend(session->sync_obj, _message);

     return status;

 enomem:

     status = PEP_OUT_OF_MEMORY;

 error:

     free_identity(_me);

     free(payload);

     free_message(_message);

     free_identity(me);

     free(own_id);

     return status;

 }

 PEP_STATUS multicast_self_msg(

         PEP_SESSION session,

         DeviceState_state state,

         DeviceGroup_Protocol_t *msg,

         bool encrypted

     )

 {

     PEP_STATUS status = PEP_STATUS_OK;

     assert(session && state && msg);

     if (!(session && state && msg))

         return PEP_ILLEGAL_VALUE;

     identity_list *own_identities = NULL;

     status = _own_identities_retrieve(session, &own_identities, PEP_idf_not_for_sync);

     if (status != PEP_STATUS_OK)

         return status;

     for (identity_list *_i = own_identities; _i && _i->ident; _i = _i->next) {

         pEp_identity *me = _i->ident;

         // FIXME: no deep copy for multicast supported yet

         // DeviceGroup_Protocol_t *_msg = malloc(sizeof(DeviceGroup_Protocol_t));

         // assert(_msg);

         // if (_msg == NULL){

         //     status = PEP_OUT_OF_MEMORY;

         //     goto error;

         // }

         // memcpy(_msg, msg, sizeof(DeviceGroup_Protocol_t));

         status = unicast_msg(session, me, state, msg, encrypted);

         //status = unicast_msg(session, me, state, _msg, encrypted);

         //free_DeviceGroup_Protocol_msg(_msg);

     }

     free_identity_list(own_identities);

     return PEP_STATUS_OK;

 // error:

 //     free_identity_list(own_identities);

 //     return status;

 }

 void free_group_keys_extra(group_keys_extra_t* group_keys_extra)

 {

     identity_list *group_keys = group_keys_extra->group_keys;

     char *group_id = group_keys_extra->group_id;

     free_identity_list(group_keys);

     free(group_id);

     free(group_keys_extra);

 }

 group_keys_extra_t* group_keys_extra_dup(group_keys_extra_t* group_key_extra_src)

 {

     group_keys_extra_t *group_key_extra_dst;

     group_key_extra_dst = calloc(1,sizeof(group_keys_extra_t));

     if(group_key_extra_dst == NULL){

         return NULL;

     }

     char *group_id = strdup(group_key_extra_src->group_id);

     if (group_key_extra_dst->group_id && !group_id){

         free(group_key_extra_dst);

         return NULL;

     }

     group_key_extra_dst->group_id = group_id;

     identity_list *group_keys = identity_list_dup(group_key_extra_src->group_keys);;

     if (!group_keys) {

         free(group_id);

         free(group_key_extra_dst);

         return NULL;

     }

     group_key_extra_dst->group_keys = group_keys;

     return group_key_extra_dst;

 }