// This file is under GNU General Public License 3.0

// see LICENSE.txt

// generate state machine code

// Copyleft (c) 2016-2019, p≡p foundation

// Written by Volker Birk

include yslt.yml2

tstylesheet {

    include standardlib.ysl2

    include ./functions.ysl2

    template "/protocol" {

        document "generated/{@name}_event.h", "text"

        ||

        // This file is under GNU General Public License 3.0

        // see LICENSE.txt

        #pragma once

        #include "pEpEngine.h"

        #ifdef __cplusplus

        extern "C" {

        #endif

        typedef struct «@name» «yml:ucase(@name)»;

        typedef int «yml:ucase(@name)»_PR;

        typedef struct «@name»_event {

            // state machine data

            «yml:ucase(@name)»_PR fsm;

            int event;

            «yml:ucase(@name)» *msg;

            // transport data

            pEp_identity *from;

            char *signature_fpr;

            identity_list *own_identities;

        } «@name»_event_t;

        // new_«@name»_event() - allocate a new «@name»_event

        //

        //  parameters:

        //      fsm (in)        finite state machine the event is for

        //      event (in)      event or None

        //      msg (in)        message to compute event from

        //

        //  return value:

        //      pointer to new event or NULL in case of failure

        //

        //  caveat:

        //      event must be valid for fsm or None

        //      in case msg is given event will be calculated out of message

        «@name»_event_t *new_«@name»_event(«yml:ucase(@name)»_PR fsm, int event, «yml:ucase(@name)» *msg);

        #define «yml:ucase(@name)»_TIMEOUT_EVENT new_«@name»_event(«@name»_PR_NOTHING, 0, NULL);

        // free_«@name»_event() - free memory occupied by event

        //

        //  parameters:

        //      ev (in)         event to free

        void free_«@name»_event(«@name»_event_t *ev);

        #ifdef __cplusplus

        }

        #endif

        ||

        document "generated/{@name}_event.c", "text"

        ||

        // This file is under GNU General Public License 3.0

        // see LICENSE.txt

        #include "platform.h"

        #include "pEp_internal.h"

        #include "«@name»_event.h"

        #include "«@name»_func.h"

        `` for "fsm" | #include "«@name»_fsm.h"

        «@name»_event_t *new_«@name»_event(«yml:ucase(@name)»_PR fsm, int event, «@name»_t *msg)

        {

            «@name»_event_t *ev = («@name»_event_t *) calloc(1, sizeof(«@name»_event_t));

            assert(ev);

            if (!ev)

                return NULL;

            ev->fsm = fsm;

            ev->event = event;

            ev->msg = msg;

            if (msg) {

                switch (fsm) {

                    `` apply "fsm", 3, mode=event

                    default:

                        // unknown protocol

                        free(ev);

                        return NULL;

                }

            }

            return ev;

        }

        void free_«@name»_event(«@name»_event_t *ev)

        {

            if (ev) {

                free_identity_list(ev->own_identities);

                free_«@name»_message(ev->msg);

                free_identity(ev->from);

                free(ev->signature_fpr);

                free(ev);

            }

        }

        ||

        document "generated/{@name}_impl.h", "text" {

            ||

            // This file is under GNU General Public License 3.0

            // see LICENSE.txt

            #pragma once

            #include "fsm_common.h"

            #include "«@name»_event.h"

            #include "message_api.h"

            #include "../asn.1/«@name».h"

            #define «yml:ucase(@name)»_THRESHOLD «@threshold»

            `` for "fsm" | #define «yml:ucase(@name)»_THRESHOLD «@threshold»

            #ifdef __cplusplus

            extern "C" {

            #endif

            // conditions

            ||

            for "func:distinctName(*//condition)"

                | PEP_STATUS «@name»(PEP_SESSION session, bool *result);

            ||

            // actions

            ||

            for "func:distinctName(*//action)"

                | PEP_STATUS «@name»(PEP_SESSION session);

            ||

            // timeout handler

            ||

            for "fsm[@threshold > 0]"

                | PEP_STATUS «@name»TimeoutHandler(PEP_SESSION session);

            ||

            // send message about an event to communication partners using state

            PEP_STATUS send_«@name»_message(

                    PEP_SESSION session, 

                    «@name»_PR fsm,

                    int message_type

                );

            // receive message and store it in state

            PEP_STATUS recv_«@name»_event(

                    PEP_SESSION session,

                    «@name»_event_t *ev

                );

            // state machine driver

            // if fsm or event set to 0 use fields in src if present

            PEP_STATUS «@name»_driver(

                    PEP_SESSION session,

                    «@name»_PR fsm,

                    int event

                );

            // API being used by the engine internally

            // call this if you need to signal an external event

            // caveat: the ownership of own_identities goes to the callee

            PEP_STATUS signal_«@name»_event(

                    PEP_SESSION session, 

                    «@name»_PR fsm,

                    int event,

                    identity_list *own_identities

                );

            // call this if you are a transport and are receiving

            // a «@name» message

            PEP_STATUS signal_«@name»_message(

                    PEP_SESSION session, 

                    PEP_rating rating,

                    const char *data,

                    size_t size,

                    const pEp_identity *from,

                    const char *signature_fpr

                );

            #ifdef __cplusplus

            }

            #endif

            ||

        }

        document "generated/{@name}_impl.c", "text" {

            ||

            // This file is under GNU General Public License 3.0

            // see LICENSE.txt

            #include "«@name»_impl.h"

            #include "pEp_internal.h"

            #include "«@name»_event.h"

            #include "«yml:lcase(@name)»_codec.h"

            #include "baseprotocol.h"

            `` for "fsm" | #include "«@name»_fsm.h"

            `` apply "fsm", 0, mode=timeout

            PEP_STATUS «@name»_driver(

                    PEP_SESSION session,

                    «@name»_PR fsm,

                    int event

                )

            {

                assert(session);

                if (!session)

                    return PEP_ILLEGAL_VALUE;

                switch (fsm) {

                    case None:

                        if (!event) {

                            // timeout occured

                        `` for "fsm" |>>>> «../@name»_driver(session, «../@name»_PR_«yml:lcase(@name)», None);

                            return PEP_STATUS_OK;

                        }

                        return PEP_ILLEGAL_VALUE;

                    `` apply "fsm", mode=reset_state_machine;

                    default:

                        return PEP_ILLEGAL_VALUE;

                }

                int next_state = None;

                do {

                    switch (fsm) {

                        `` apply "fsm", 3, mode=driver               

                        default:

                            return PEP_ILLEGAL_VALUE;

                    }

                }  while (next_state);

                return PEP_STATUS_OK;

            }

            PEP_STATUS signal_«@name»_event(

                    PEP_SESSION session, 

                    «@name»_PR fsm,

                    int event,

                    identity_list *own_identities

                )

            {

                «@name»_t *msg = NULL;

                «@name»_event_t *ev = NULL;

                assert(session && fsm > 0 && event > None);

                if (!(session && fsm > 0 && event > None))

                    return PEP_ILLEGAL_VALUE;

                PEP_STATUS status = PEP_STATUS_OK;

                if (!session->inject_«yml:lcase(@name)»_event)

                   return PEP_«yml:ucase(@name)»_NO_INJECT_CALLBACK;

                if (event < Extra) {

                    msg = new_«@name»_message(fsm, event);

                    if (!msg) {

                        status = PEP_OUT_OF_MEMORY;

                        goto the_end;

                    }

                    status = update_«@name»_message(session, msg);

                    if (status)

                        goto the_end;

                }

                ev = new_«@name»_event(fsm, event, msg);

                if (!ev) {

                    status = PEP_OUT_OF_MEMORY;

                    goto the_end;

                }

                ev->own_identities = own_identities;

                int result = session->inject_«yml:lcase(@name)»_event(ev,

                        session->«yml:lcase(@name)»_management);

                if (result) {

                    status = PEP_STATEMACHINE_ERROR;

                    goto the_end;

                }

                return PEP_STATUS_OK;

            the_end:

                free_«@name»_event(ev); // msg gets freed here

                return status;

            }

            PEP_STATUS signal_«@name»_message(

                    PEP_SESSION session, 

                    PEP_rating rating,

                    const char *data,

                    size_t size,

                    const pEp_identity *from,

                    const char *signature_fpr

                )

            {

                assert(session && data && size);

                if (!(session && data && size))

                    return PEP_ILLEGAL_VALUE;

                if (!session->inject_«yml:lcase(@name)»_event)

                   return PEP_«yml:ucase(@name)»_NO_INJECT_CALLBACK;

                PEP_STATUS status = PEP_STATUS_OK;

                «@name»_event_t *ev = NULL;

                «@name»_t *msg = NULL;

                status = decode_«@name»_message(data, size, &msg);

                if (status)

                    return status;

                «@name»_PR fsm = msg->present;

                int event = 0;

                bool is_own_key = false;

                switch (fsm) {

                    `` apply "fsm", 2, mode=signal_message

                    default:

                        status = PEP_«yml:ucase(@name)»_ILLEGAL_MESSAGE;

                        goto the_end;

                }

                ev = new_«@name»_event(fsm, event, msg);

                if (!ev) {

                    status = PEP_OUT_OF_MEMORY;

                    goto the_end;

                }

                // add transport data

                if (from) {

                    ev->from = identity_dup(from);

                    if (!ev->from) {

                        status = PEP_OUT_OF_MEMORY;

                        goto the_end;

                    }

                }

                if (signature_fpr) {

                    ev->signature_fpr = strdup(signature_fpr);

                    assert(ev->signature_fpr);

                    if (!ev->signature_fpr) {

                        status = PEP_OUT_OF_MEMORY;

                        goto the_end;

                    }

                }

                int result = session->inject_«yml:lcase(@name)»_event(ev,

                        session->«yml:lcase(@name)»_management);

                if (result) {

                    status = PEP_STATEMACHINE_ERROR;

                    goto the_end;

                }

                return PEP_STATUS_OK;

            the_end:

                free_«@name»_event(ev); // msg gets freed here

                return status;

            }

            PEP_STATUS send_«@name»_message(

                    PEP_SESSION session, 

                    «@name»_PR fsm,

                    int message_type

                )

            {

                PEP_STATUS status = PEP_STATUS_OK;

                assert(session && fsm > None && message_type > None);

                if (!(session && fsm > None && message_type > None))

                    return PEP_ILLEGAL_VALUE;

                «@name»_t *msg = new_«@name»_message(fsm, message_type);

                if (!msg)

                    return PEP_OUT_OF_MEMORY;

                char *data = NULL;

                message *m = NULL;

                identity_list *channels = NULL;

                char *key_data = NULL;

                size_t key_data_size = 0;

                stringlist_t *extra = NULL;

                bool transaction;

                status = update_«@name»_message(session, msg);

                if (status)

                    goto the_end;

                size_t size = 0;

                status = encode_«@name»_message(msg, &data, &size);

                if (status)

                    goto the_end;

                switch (message_type) {

                    // these messages are being broadcasted

                    `` for "fsm/message[@type='broadcast']" |>> case «../@name»_PR_«yml:mixedCase(@name)»:

                        status = _own_identities_retrieve(session, &channels, PEP_idf_not_for_«yml:lcase(@name)»);

                        if (status)

                            goto the_end;

                        if (!(channels && channels->ident)) {

                            // status = PEP_«yml:ucase(@name)»_NO_CHANNEL;

                            // we don't check for having a channel, because if

                            // this is initial setup before having an own

                            // identity we're fine

                            goto the_end;

                        }

                        break;

                    // these go anycast; previously used address is sticky (unicast)

                    `` for "fsm/message[@type='anycast']" |>> case «../@name»_PR_«yml:mixedCase(@name)»:

                        if (!session->«yml:lcase(@name)»_state.common.from `> |`|

                            (session->«yml:lcase(@name)»_state.common.from->flags &

                            PEP_idf_not_for_«yml:lcase(@name)»)) {

                            // no address available yet, try to find one

                            status = _own_identities_retrieve(session, &channels, PEP_idf_not_for_«yml:lcase(@name)»);

                            if (status)

                                goto the_end;

                            break;

                            if (channels && channels->ident) {

                                // only need the first one

                                free_identity_list(channels->next);

                                channels->next = NULL;

                            }

                            else {

                                status = PEP_«yml:ucase(@name)»_NO_CHANNEL;

                                goto the_end;

                            }

                        }

                        else {

                            pEp_identity *channel = identity_dup(session->«yml:lcase(@name)»_state.common.from);

                            if (!channel) {

                                status = PEP_OUT_OF_MEMORY;

                                goto the_end;

                            }

                            channels = new_identity_list(channel);

                            if (!channels) {

                                status = PEP_OUT_OF_MEMORY;

                                goto the_end;

                            }

                        }

                        break;

                    default:

                        status = PEP_«yml:ucase(@name)»_ILLEGAL_MESSAGE;

                        goto the_end;

                }

                for (identity_list *li = channels; li && li->ident ; li = li->next) {

                    message *_m = NULL;

                    char *_data = NULL;

                    _data = malloc(size);

                    assert(_data);

                    if (!_data) {

                        status = PEP_OUT_OF_MEMORY;

                        goto the_end;

                    }

                    memcpy(_data, data, size);

                    switch (message_type) {

                    `` for "fsm/message[@security='unencrypted']" |>>> case «../@name»_PR_«yml:mixedCase(@name)»:

                            status = base_prepare_message(

                                    session,

                                    li->ident,

                                    li->ident,

                                    _data,

                                    size,

                                    li->ident->fpr,

                                    &_m

                                );

                            if (status) {

                                free(_data);

                                goto the_end;

                            }

                            attach_own_key(session, _m);

                            m = _m;

                            break;

                    `` for "fsm/message[@security='untrusted']" |>>> case «../@name»_PR_«yml:mixedCase(@name)»:

                            // add fpr of key of comm partner

                            assert(session->«yml:lcase(@name)»_state.common.signature_fpr);

                            if (!session->«yml:lcase(@name)»_state.common.signature_fpr) {

                                status = PEP_«yml:ucase(@name)»_CANNOT_ENCRYPT;

                                goto the_end;

                            }

                            extra = new_stringlist(session->«yml:lcase(@name)»_state.common.signature_fpr);

                            if (!extra) {

                                status = PEP_OUT_OF_MEMORY;

                                goto the_end;

                            }

                            status = base_prepare_message(

                                    session,

                                    li->ident,

                                    li->ident,

                                    _data,

                                    size,

                                    NULL,

                                    &_m

                                );

                            if (status) {

                                free(_data);

                                goto the_end;

                            }

                            status = encrypt_message(session, _m, extra, &m, PEP_enc_PEP, 0);

                            if (status) {

                                status = PEP_«yml:ucase(@name)»_CANNOT_ENCRYPT;

                                goto the_end;

                            }

                            free_message(_m);

                            break;

                    `` for "fsm/message[@security='attach_own_keys']" |>>> case «../@name»_PR_«yml:mixedCase(@name)»:

                            // check if this is the key of a former negotiation

                            transaction = false;

                            for (int i=0; i < session->own_«yml:lcase(@name)»_state.negotiation.size; i++) {

                                if (session->own_«yml:lcase(@name)»_state.negotiation.buf[i]) {

                                    transaction = true;

                                    break;

                                }

                            }

                            // if it is a former negotiation check if the key

                            // is fully trusted and the sender key of this

                            // transaction; if so add the sender key to extra

                            // keys allowing this new partner to read the

                            // secret keys

                            if (transaction) {

                                assert(session->own_«yml:lcase(@name)»_state.signature_fpr &&

                                    session->«yml:lcase(@name)»_state.common.from &&

                                    session->«yml:lcase(@name)»_state.common.from->user_id);

                                if (!(session->own_«yml:lcase(@name)»_state.signature_fpr &&

                                        session->«yml:lcase(@name)»_state.common.from &&

                                        session->«yml:lcase(@name)»_state.common.from->user_id))

                                {

                                    status = PEP_«yml:ucase(@name)»_CANNOT_ENCRYPT;

                                    goto the_end;

                                }

                                // test if this is a green channel

                                pEp_identity *ident = new_identity(NULL,

                                        session->own_«yml:lcase(@name)»_state.signature_fpr,

                                        session->«yml:lcase(@name)»_state.common.from->user_id,

                                        NULL

                                    );

                                if (!ident) {

                                    status = PEP_OUT_OF_MEMORY;

                                    goto the_end;

                                }

                                status = get_trust(session, ident);

                                if (status) {

                                    free_identity(ident);

                                    goto the_end;

                                }

                                assert(ident->comm_type == PEP_ct_pEp); // we don't deliver otherwise

                                if (ident->comm_type != PEP_ct_pEp) {

                                    free_identity(ident);

                                    status = PEP_«yml:ucase(@name)»_CANNOT_ENCRYPT;

                                    goto the_end;

                                }

                                free_identity(ident);

                                // test if we accepted this as own key already

                                bool is_own_key = false;

                                status = own_key_is_listed(session,

                                        session->own_«yml:lcase(@name)»_state.signature_fpr,

                                        &is_own_key);

                                assert(!status);

                                if (status)

                                    goto the_end;

                                assert(is_own_key);

                                if (!is_own_key) {

                                    status = PEP_«yml:ucase(@name)»_CANNOT_ENCRYPT;

                                    goto the_end;

                                }

                                // if so add key of comm partner to extra keys

                                extra = new_stringlist(session->own_«yml:lcase(@name)»_state.signature_fpr);

                                if (!extra) {

                                    status = PEP_OUT_OF_MEMORY;

                                    goto the_end;

                                }

                            }

                            status = base_prepare_message(

                                    session,

                                    li->ident,

                                    li->ident,

                                    _data,

                                    size,

                                    NULL,

                                    &_m

                                );

                            if (status) {

                                free(_data);

                                goto the_end;

                            }

                            // export secret keys into memory

                            key_data = strdup("");

                            assert(key_data);

                            if (!key_data) {

                                free(_data);

                                free_message(_m);

                                status = PEP_OUT_OF_MEMORY;

                                goto the_end;

                            }

                            key_data_size = 1;

                            for (stringlist_t *sl = session->own_«yml:lcase(@name)»_state.own_keys;

                                    sl && sl->value ; sl = sl->next)

                            {

                                char *_key_data = NULL;

                                size_t _size = 0;

                                status = export_secret_key(session, sl->value, &_key_data, &_size);

                                if (status && status != PEP_KEY_NOT_FOUND) {

                                    free(_data);

                                    free_message(_m);

                                    goto the_end;

                                }

                                if (status != PEP_KEY_NOT_FOUND) {

                                    assert(_key_data && _size);

                                    char *n = realloc(key_data, key_data_size + _size);

                                    if (!n) {

                                        free(_data);

                                        free_message(_m);

                                        status = PEP_OUT_OF_MEMORY;

                                        goto the_end;

                                    }

                                    key_data = n;

                                    key_data_size += _size;

                                    strlcat(key_data, _key_data, key_data_size);

                                    free(_key_data);

                                    _key_data = NULL;

                                }

                                status = export_key(session, sl->value, &_key_data, &_size);

                                if (status && status != PEP_KEY_NOT_FOUND) {

                                    free(_data);

                                    free_message(_m);

                                    goto the_end;

                                }

                                if (status != PEP_KEY_NOT_FOUND) {

                                    assert(_key_data && _size);

                                    char *n = realloc(key_data, key_data_size + _size);

                                    if (!n) {

                                        free(_data);

                                        free_message(_m);

                                        status = PEP_OUT_OF_MEMORY;

                                        goto the_end;

                                    }

                                    key_data = n;

                                    key_data_size += _size;

                                    strlcat(key_data, _key_data, key_data_size);

                                    free(_key_data);

                                    _key_data = NULL;

                                }

                            }

                            // add secret key data as attachment

                            bloblist_t *bl = bloblist_add(_m->attachments, key_data, key_data_size,

                                    "application/octet-stream", "file://own.key");

                            if (!bl) {

                                free(_data);

                                free_message(_m);

                                status = PEP_OUT_OF_MEMORY;

                                goto the_end;

                            }

                            key_data = NULL;

                            status = encrypt_message(session, _m, extra, &m, PEP_enc_PEP, 0);

                            if (status) {

                                status = PEP_«yml:ucase(@name)»_CANNOT_ENCRYPT;

                                goto the_end;

                            }

                            free_message(_m);

                            break;

                        default: // security=trusted only

                            status = base_prepare_message(

                                    session,

                                    li->ident,

                                    li->ident,

                                    _data,

                                    size,

                                    NULL,

                                    &_m

                                );

                            if (status) {

                                free(_data);

                                goto the_end;

                            }

                            status = encrypt_message(session, _m, NULL, &m, PEP_enc_PEP, 0);

                            if (status) {

                                status = PEP_«yml:ucase(@name)»_CANNOT_ENCRYPT;

                                goto the_end;

                            }

                            free_message(_m);

                    }

                    status = session->messageToSend(m);

                    m = NULL;

                }

            the_end:

                free_stringlist(extra);

                free_identity_list(channels);

                free_message(m);

                free(data);

                free(key_data);

                free_«@name»_message(msg);

                return status;

            }

            PEP_STATUS recv_«@name»_event(

                    PEP_SESSION session,

                    «@name»_event_t *ev

                )

            {

                assert(session && ev);

                if (!(session && ev))

                    return PEP_ILLEGAL_VALUE;

                PEP_STATUS status = PEP_STATUS_OK;

                «@name»_PR fsm = (int) None;

                int event = None;

                if (ev->event > None && ev->event < Extra) {

                    status = update_«@name»_state(session, ev->msg, &fsm, &event);

                    if (status)

                        goto the_end;

                    if (ev->fsm) {

                        if (ev->fsm != fsm |`> |` ev->event != event) {

                            status = PEP_«yml:ucase(@name)»_ILLEGAL_MESSAGE;

                            goto the_end;

                        }

                    }

                    else if (ev->event) {

                        status = PEP_«yml:ucase(@name)»_ILLEGAL_MESSAGE;

                        goto the_end;

                    }

                }

                else {

                    fsm = ev->fsm;

                    event = ev->event;

                }

                // update transport data

                if (ev->from) {

                    free_identity(session->«yml:lcase(@name)»_state.common.from);

                    session->«yml:lcase(@name)»_state.common.from = ev->from;

                    ev->from = NULL;

                }

                if (ev->signature_fpr) {

                    free(session->«yml:lcase(@name)»_state.common.signature_fpr);

                    session->«yml:lcase(@name)»_state.common.signature_fpr = ev->signature_fpr;

                    ev->signature_fpr = NULL;

                }

                // update own identities

                if (ev->own_identities && ev->own_identities->ident) {

                    free_identity_list(session->own_«yml:lcase(@name)»_state.own_identities);

                    session->own_«yml:lcase(@name)»_state.own_identities = ev->own_identities;

                    ev->own_identities = NULL;

                }

                status = «@name»_driver(session, fsm, event);

            the_end:

                //free_«@name»_event(ev); // FIXME: We don't own this pointer. Are we sure it gets freed externally?

                return status;

            }

            ||

        }

        apply "fsm", 0, mode=gen;

    }

    template "fsm", mode=timeout

    ||

    static bool _«@name»_timeout(int state)

    {

        static int last_state = None;

        static time_t switch_time = 0;

        if (state > Init) {

            if (state == last_state) {

                if (time(NULL) - switch_time > «yml:ucase(@name)»_THRESHOLD) {

                    last_state = None;

                    switch_time = 0;

                    return true;

                }

            }

            else {

                last_state = state;

                switch_time = time(NULL);

            }

        }

        else {

            last_state = None;

            switch_time = 0;

        }

        return false;

    }

    ||

    template "fsm", mode=reset_state_machine

    ||

        case «../@name»_PR_«yml:lcase(@name)»: {

            int state = session->«yml:lcase(../@name)»_state.«yml:lcase(@name)».state;

            switch (state) {

                `` for "state[@name!='InitState' and @timeout != 'off']" |>>> case «@name»:

                    if (_«@name»_timeout(state)) {

                        session->«yml:lcase(../@name)»_state.«yml:lcase(@name)».state = Init;

                        event = Init;

                        `` if "@threshold > 0" |>>>>> «@name»TimeoutHandler(session);

                    }

                    break;

                default:

                    _«@name»_timeout(None);

            }

            break;

        }

    ||

    template "fsm", mode=signal_message

    {

        ||

        case «../@name»_PR_«yml:lcase(@name)»:

            switch (msg->choice.«yml:lcase(@name)».present) {

        ||

        for "message[@security='unencrypted']" {

        if "position()=1" |>> // these messages require a detached signature

        ||

                case «../@name»_PR_«yml:mixedCase(@name)»:

                    if (!signature_fpr) {

                        status = PEP_«yml:ucase(ancestor::protocol/@name)»_ILLEGAL_MESSAGE;

                        goto the_end;

                    }

                    event = «@name»;

                    break;

        ||

        }

        for "message[@security='untrusted']" {

        if "position()=1" |>> // these messages must arrive encrypted

        ||

                case «../@name»_PR_«yml:mixedCase(@name)»:

                    if (rating < PEP_rating_reliable) {

                        status = PEP_«yml:ucase(ancestor::protocol/@name)»_ILLEGAL_MESSAGE;

                        goto the_end;

                    }

                    event = «@name»;

                    break;

        ||

        }

        for "message[@security!='unencrypted' and @security!='untrusted']" {

        if "position()=1" |>> // these messages must come through a trusted channel

        ||

                case «../@name»_PR_«yml:mixedCase(@name)»:

                    if (rating < PEP_rating_trusted) {

                        status = PEP_«yml:ucase(ancestor::protocol/@name)»_ILLEGAL_MESSAGE;

                        goto the_end;

                    }

                    status = own_key_is_listed(session, signature_fpr, &is_own_key);

                    if (status)

                        goto the_end;

                    if (!is_own_key) {

                        status = PEP_«yml:ucase(ancestor::protocol/@name)»_ILLEGAL_MESSAGE;

                        goto the_end;

                    }

                    event = «@name»;

                    break;

        ||

        }

        ||

                default:

                    status = PEP_«yml:ucase(ancestor::protocol/@name)»_ILLEGAL_MESSAGE;

                    goto the_end;

            }

            break;

        ||

    }

    template "fsm", mode=event

    {

    ||

    case «../@name»_PR_«yml:lcase(@name)»: {

        switch (msg->choice.«yml:lcase(@name)».present) {

    ||

    for "message"

    ||

            case «../@name»_PR_«yml:mixedCase(@name)»:

                ev->event = «@name»;

                break;

    ||

    ||

            default:

                // unknown message type

                free(ev);

                return NULL;

        }

        break;

    }

    ||

    }

    template "fsm", mode=driver

    ||

    case «../@name»_PR_«yml:lcase(@name)»: {

        int state = session->«yml:lcase(../@name)»_state.«yml:lcase(@name)».state;

        next_state = fsm_«@name»(session, state, event);

        if (next_state > None) {

            session->«yml:lcase(../@name)»_state.«yml:lcase(@name)».state = next_state;

            event = Init;

        }

        else if (next_state < None) {

            return PEP_STATEMACHINE_ERROR - next_state;

        }

        break;

    }

    ||

    template "fsm", mode=gen {

        document "generated/{@name}_fsm.h", "text" {