hsms_msg.h

/*   
 *   (c) Copyright 2008 Philipp Skadorov (philipp_s@users.sourceforge.net)
 *
 *   This file is part of FREESECS.
 *
 *   FREESECS is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   FREESECS is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with FREESECS, see COPYING.
 *   If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef hsms_msg_h
#define hsms_msg_h

#include <arpa/inet.h>
#include "log.h"

#define HSMS_CTRL_SESSION_ID    0xffff
#define HSMS_LEN_BYTES_LEN      4
#define HSMS_HDR_LEN            10
#define HSMS_HDR_OFFSET         HSMS_LEN_BYTES_LEN
#define HSMS_SESSION_OFFSET     HSMS_HDR_OFFSET
#define HSMS_BYTE2_OFFSET       6
#define HSMS_BYTE3_OFFSET       7
#define HSMS_PTYPE_OFFSET       8
#define HSMS_STYPE_OFFSET       9
#define HSMS_SYSBYTES_OFFSET    10
#define HSMS_DATABYTES_OFFSET   14

#define HSMS_MSG_STYPE(m)   *((unsigned char*)((m)+HSMS_STYPE_OFFSET))
#define HSMS_MSG_PTYPE(m)   *((unsigned char*)((m)+HSMS_PTYPE_OFFSET))
#define HSMS_MSG_LEN(m)     *((unsigned*)(m))
#define HSMS_MSG_BYTE2(m)   *((unsigned char*)((m)+HSMS_BYTE2_OFFSET))
#define HSMS_MSG_BYTE3(m)   *((unsigned char*)((m)+HSMS_BYTE3_OFFSET))
#define HSMS_SESSION_ID(m)  *((unsigned short*)((m)+HSMS_SESSION_OFFSET))
#define HSMS_CTRL_STATUS(m) *((unsigned short*)((m)+HSMS_BYTE2_OFFSET))
#define HSMS_STREAM(m)      *((unsigned char*)((m)+HSMS_BYTE2_OFFSET))
#define HSMS_FUNCTION(m)    *((unsigned char*)((m)+HSMS_BYTE3_OFFSET))
#define HSMS_SYSBYTES(m)    *((unsigned*)((m)+HSMS_SYSBYTES_OFFSET))
#define HSMS_DATABYTES(m)   ((unsigned char*)((m)+HSMS_DATABYTES_OFFSET))

#define HSMS_MSG_LOG_LEVEL 10

namespace freesecs
{
    template < typename data_t >
    class hsms_msg_base
    {
    public:
        virtual ~hsms_msg_base(){};
        typedef enum _msg_et
        {
            e_data = 0,
            e_select_req = 1,
            e_select_rsp = 2,
            e_deselect_req = 3,
            e_deselect_rsp = 4,
            e_linktest_req = 5,
            e_linktest_rsp = 6,
            e_reject_req = 7,
            e_separate_req = 9,
            e_invalid = 0xff
        } 
        msg_et;
        
        virtual bool 
        valid(const data_t &d) const
        {
            TRACE_DEBUG(HSMS_MSG_LOG_LEVEL,
                        "msg_base::valid: msg_len: %d,"
                        " msg.size: %d, type: %d", 
                         ntohl(HSMS_MSG_LEN(&d[0])), d.size(),
                         HSMS_MSG_STYPE(&d[0]));

            return HSMS_HDR_LEN <= ntohl(HSMS_MSG_LEN(&d[0]))
                && d.size() >= ntohl(HSMS_MSG_LEN(&d[0])) + HSMS_LEN_BYTES_LEN
                    && e_separate_req >= HSMS_MSG_STYPE(&d[0]);
        };

        msg_et
        type(const data_t &d)
        {
            return (msg_et)HSMS_MSG_STYPE(&d[0]);
        };

        unsigned
        transaction_id(const data_t &d)
        {
            return ntohl(HSMS_SYSBYTES(&d[0]));
        };
    };

    template < typename data_t > 
    class select_req : public hsms_msg_base<data_t>
    {
      public:
        typedef hsms_msg_base<data_t> base_t;

        static const unsigned short
            ctrl_session_id = 0xffff;

        virtual bool
        valid(const data_t &d) const
        {
            return HSMS_HDR_LEN == ntohl(HSMS_MSG_LEN(&d[0]))
                && d.size() >= ntohl(HSMS_MSG_LEN(&d[0])) + HSMS_LEN_BYTES_LEN
                && base_t::e_select_req == HSMS_MSG_STYPE(&d[0])
                && 0 == HSMS_MSG_PTYPE(&d[0])
                && 0 == HSMS_CTRL_STATUS(&d[0])
                && HSMS_CTRL_SESSION_ID == HSMS_SESSION_ID(&d[0]);
        };
        void
        compose(data_t &d, unsigned transaction_id)
        {
            d = data_t(HSMS_LEN_BYTES_LEN + HSMS_HDR_LEN, 0);
            HSMS_MSG_LEN(&d[0]) = htonl(HSMS_HDR_LEN);
            HSMS_MSG_STYPE(&d[0]) = base_t::e_select_req;
            HSMS_SYSBYTES(&d[0]) = htonl(transaction_id);
            HSMS_SESSION_ID(&d[0]) = HSMS_CTRL_SESSION_ID;
        };
    };

    template < typename data_t > 
    class select_rsp : public hsms_msg_base<data_t>
    {
      public:
        typedef hsms_msg_base<data_t> base_t;

        typedef enum _status_et
        {
            e_established = 0,
            e_already_active = 1,
            e_not_ready = 2,
            e_ctx_exhaust = 3,
        } status_et;

        virtual bool
        valid(const data_t &d) const
        {
            return HSMS_HDR_LEN == ntohl(HSMS_MSG_LEN(&d[0]))
                && d.size() >= ntohl(HSMS_MSG_LEN(&d[0])) + HSMS_LEN_BYTES_LEN
                && base_t::e_select_rsp == HSMS_MSG_STYPE(&d[0])
                && 0 == HSMS_MSG_PTYPE(&d[0])
                && HSMS_CTRL_SESSION_ID == HSMS_SESSION_ID(&d[0]);
        };
        status_et
        status(const data_t &d) const
        {
            return (status_et) HSMS_MSG_BYTE3(&d[0]);
        };
        void
        compose(data_t &d, unsigned transaction_id, status_et status)
        {
            d = data_t(HSMS_LEN_BYTES_LEN + HSMS_HDR_LEN, 0);
            HSMS_MSG_LEN(&d[0]) = htonl(HSMS_HDR_LEN);
            HSMS_MSG_STYPE(&d[0]) = base_t::e_select_rsp;
            HSMS_CTRL_STATUS(&d[0]) = status;
            HSMS_SYSBYTES(&d[0]) = htonl(transaction_id);
            HSMS_SESSION_ID(&d[0]) = HSMS_CTRL_SESSION_ID;
        };
    };

    template < typename data_t > 
    class linktest_req : public hsms_msg_base<data_t>
    {
      public:
        typedef hsms_msg_base<data_t> base_t;

        virtual bool
        valid(const data_t &d) const
        {
            return HSMS_HDR_LEN == ntohl(HSMS_MSG_LEN(&d[0]))
                && d.size() >= ntohl(HSMS_MSG_LEN(&d[0])) + HSMS_LEN_BYTES_LEN
                && base_t::e_linktest_req == HSMS_MSG_STYPE(&d[0])
                && 0 == HSMS_MSG_PTYPE(&d[0])
                && HSMS_CTRL_SESSION_ID == HSMS_SESSION_ID(&d[0]);
        };
        void
        compose(data_t &d, unsigned transaction_id)
        {
            d = data_t(HSMS_LEN_BYTES_LEN + HSMS_HDR_LEN, 0);
            HSMS_MSG_LEN(&d[0]) = htonl(HSMS_HDR_LEN);
            HSMS_MSG_STYPE(&d[0]) = base_t::e_linktest_req;
            HSMS_SYSBYTES(&d[0]) = htonl(transaction_id);
            HSMS_SESSION_ID(&d[0]) = HSMS_CTRL_SESSION_ID;
        };
    };

    template < typename data_t > 
    class linktest_rsp : public hsms_msg_base<data_t>
    {
      public:
        typedef hsms_msg_base<data_t> base_t;

        virtual bool 
        valid(const data_t &d) const
        {
            return HSMS_HDR_LEN == ntohl(HSMS_MSG_LEN(&d[0]))
                && d.size() >= ntohl(HSMS_MSG_LEN(&d[0])) + HSMS_LEN_BYTES_LEN
                && base_t::e_linktest_rsp == HSMS_MSG_STYPE(&d[0])
                && 0 == HSMS_MSG_PTYPE(&d[0])
                && HSMS_CTRL_SESSION_ID == HSMS_SESSION_ID(&d[0]);
        };
        void
        compose(data_t &d, unsigned transaction_id)
        {
            d = data_t(HSMS_LEN_BYTES_LEN + HSMS_HDR_LEN, 0);
            HSMS_MSG_LEN(&d[0]) = htonl(HSMS_HDR_LEN);
            HSMS_MSG_STYPE(&d[0]) = base_t::e_linktest_rsp;
            HSMS_SYSBYTES(&d[0]) = htonl(transaction_id);
            HSMS_SESSION_ID(&d[0]) = HSMS_CTRL_SESSION_ID;
        };
    };

    template < typename data_t > 
    class reject_req : public hsms_msg_base<data_t>
    {
      public:
        typedef hsms_msg_base<data_t> base_t;

        typedef enum _reason_et
            {
                e_stype_not_supported = 1,
                e_ptype_not_supported = 2,
                e_transaction_not_open = 3,
                e_not_selected = 4
            } reason_et;
        virtual bool
        valid(const data_t &d)const
        {
            return HSMS_HDR_LEN == ntohl(HSMS_MSG_LEN(&d[0]))
                && d.size() >= ntohl(HSMS_MSG_LEN(&d[0])) + HSMS_LEN_BYTES_LEN
                && base_t::e_reject_req == HSMS_MSG_STYPE(&d[0]);
        };
        unsigned short
        session_id(data_t &d)
        {
            return ntohl(HSMS_SESSION_ID(&d[0]));
        };
        unsigned char
        byte2(data_t &d)
        {
            return HSMS_MSG_BYTE2(&d[0]);
        };
        reason_et
        reason(data_t &d)
        {
            return (reason_et) HSMS_MSG_BYTE3(&d[0]);
        };
        void
        compose(data_t &d, unsigned transaction_id,
                unsigned short session_id, unsigned char byte2, reason_et reason)
        {
            d = data_t(HSMS_LEN_BYTES_LEN + HSMS_HDR_LEN, 0);
            HSMS_MSG_LEN(&d[0]) = htonl(HSMS_HDR_LEN);
            HSMS_MSG_STYPE(&d[0]) = base_t::e_reject_req;
            HSMS_SYSBYTES(&d[0]) = htonl(transaction_id);
            HSMS_SESSION_ID(&d[0]) = htons(session_id);
            HSMS_MSG_BYTE2(&d[0]) = byte2;
            HSMS_MSG_BYTE3(&d[0]) = reason;
        };
    };

    template < typename data_t > 
    class separate_req : public hsms_msg_base<data_t>
    {
      public:
        typedef hsms_msg_base<data_t> base_t;

        virtual bool 
        valid(const data_t &d) const
        {
            return HSMS_HDR_LEN == htonl(HSMS_MSG_LEN(&d[0]))
                && d.size() >= htonl(HSMS_MSG_LEN(&d[0])) + HSMS_LEN_BYTES_LEN
                && base_t::e_separate_req == HSMS_MSG_STYPE(&d[0])
                && 0 == HSMS_MSG_BYTE2(&d[0])
                && 0 == HSMS_MSG_BYTE3(&d[0])
                && 0 == HSMS_MSG_PTYPE(&d[0])
                && HSMS_CTRL_SESSION_ID == HSMS_SESSION_ID(&d[0]);
        };
        void
        compose(data_t &d, unsigned transaction_id)
        {
            d = data_t(HSMS_LEN_BYTES_LEN + HSMS_HDR_LEN, 0);
            HSMS_MSG_LEN(&d[0]) = htonl(HSMS_HDR_LEN);
            HSMS_MSG_STYPE(&d[0]) = base_t::e_separate_req;
            HSMS_SYSBYTES(&d[0]) = htonl(transaction_id);
            HSMS_SESSION_ID(&d[0]) = HSMS_CTRL_SESSION_ID;
        };
    };

    template < typename data_t > 
    class data_msg : public hsms_msg_base<data_t>
    {
      public:
        typedef hsms_msg_base<data_t> base_t;

        virtual bool
        valid(const data_t &d) const
        {
            return HSMS_HDR_LEN <= ntohl(HSMS_MSG_LEN(&d[0]))
                && d.size() >= ntohl(HSMS_MSG_LEN(&d[0])) + HSMS_LEN_BYTES_LEN
                && base_t::e_data == HSMS_MSG_STYPE(&d[0])
                && 0 == HSMS_MSG_PTYPE(&d[0]);
        };
        unsigned short
        session_id(const data_t &d)
        {
            return ntohl(HSMS_SESSION_ID(&d[0]));
        };
        unsigned char
        wbit(const data_t &d)
        {
            return HSMS_MSG_BYTE2(&d[0]) >> 7 & 0x1;
        };
        unsigned char
        stream(const data_t &d)
        {
            return HSMS_MSG_BYTE2(&d[0]) & 0x7F;
        };
        unsigned char
        function(const data_t &d)
        {
            return HSMS_MSG_BYTE3(&d[0]);
        };
        unsigned
        text_len(const data_t &d)
        {
            return ntohl(HSMS_MSG_LEN(&d[0])) - HSMS_HDR_LEN;
        }
        bool
        get_text(const data_t &d, data_t &text_data)
        {
            if (!valid(d))
            {
                return false;
            }
            text_data = data_t(&d[HSMS_DATABYTES_OFFSET], &d[HSMS_DATABYTES_OFFSET+text_len(d)]);
            return true;
        }
        void
        compose(    data_t &d,
                    unsigned char   stream,
                    unsigned char   function,
                    unsigned char   wbit,
                    unsigned int    transaction_id,
                    unsigned        text_len,
                    unsigned char   *text)
        {
            d = data_t(HSMS_LEN_BYTES_LEN + HSMS_HDR_LEN + text_len, 0);

            unsigned char *begin = &d[0];
            unsigned char *text_begin = begin + HSMS_DATABYTES_OFFSET;

            HSMS_MSG_LEN(begin)     = htonl(HSMS_HDR_LEN + text_len);
            HSMS_MSG_STYPE(begin)   = base_t::e_data;
            HSMS_SYSBYTES(begin)    = htonl(transaction_id);
            //HSMS_SESSION_ID(begin)  = session_id & 0x7fff;

            HSMS_MSG_BYTE2(begin)   = stream & 0x7F;
            HSMS_MSG_BYTE3(begin)   = function;
            HSMS_MSG_BYTE2(begin)  |= (wbit & 0x1) << 7;

            if(text)
            {
                memcpy(text_begin, text, text_len);
            }
        }
        void set_session_id(data_t &d, unsigned short session_id)
        {
            HSMS_SESSION_ID(&d[0])  = session_id & 0x7fff;
        }
    };
}//namespace
#endif //hsms_msg

---