taf_mdc_messages.h

Go to the documentation of this file.

/*
 * ====================== WARNING ======================
 *
 * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
 * DO NOT MODIFY IN ANY WAY.
 *
 * ====================== WARNING ======================
 */


#ifndef TAF_MDC_MESSAGES_H_INCLUDE_GUARD
#define TAF_MDC_MESSAGES_H_INCLUDE_GUARD


#include "taf_mdc_common.h"

#define _MAX_MSG_SIZE IFGEN_TAF_MDC_MSG_SIZE

// Define the message type for communicating between client and server
typedef struct __attribute__((packed))
{
    uint32_t id;
    uint8_t buffer[_MAX_MSG_SIZE];
}
_Message_t;

#define _MSGID_taf_mdc_StartSession 0
#define _MSGID_taf_mdc_StartSessionAsync 1
#define _MSGID_taf_mdc_StopSession 2
#define _MSGID_taf_mdc_StopSessionAsync 3


// Define type-safe pack/unpack functions for all enums, including included types

static inline bool taf_dcs_PackDataBearerTechnology
(
    uint8_t **bufferPtr,
    taf_dcs_DataBearerTechnology_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackDataBearerTechnology
(
    uint8_t **bufferPtr,
    taf_dcs_DataBearerTechnology_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_DataBearerTechnology_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackConState
(
    uint8_t **bufferPtr,
    taf_dcs_ConState_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackConState
(
    uint8_t **bufferPtr,
    taf_dcs_ConState_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_ConState_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackPdp
(
    uint8_t **bufferPtr,
    taf_dcs_Pdp_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackPdp
(
    uint8_t **bufferPtr,
    taf_dcs_Pdp_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_Pdp_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackRoamingType
(
    uint8_t **bufferPtr,
    taf_dcs_RoamingType_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackRoamingType
(
    uint8_t **bufferPtr,
    taf_dcs_RoamingType_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_RoamingType_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackAuth
(
    uint8_t **bufferPtr,
    taf_dcs_Auth_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackAuth
(
    uint8_t **bufferPtr,
    taf_dcs_Auth_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_Auth_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackApnType
(
    uint8_t **bufferPtr,
    taf_dcs_ApnType_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackApnType
(
    uint8_t **bufferPtr,
    taf_dcs_ApnType_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_ApnType_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackTech
(
    uint8_t **bufferPtr,
    taf_dcs_Tech_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackTech
(
    uint8_t **bufferPtr,
    taf_dcs_Tech_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_Tech_t)value;
    }
    return result;
}

// Define pack/unpack functions for all structures, including included types


static inline bool taf_dcs_PackDefaultGatewayAddresses
(
    uint8_t **bufferPtr,
    const taf_dcs_DefaultGatewayAddresses_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv4Addr, 16);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv6Addr, 46);
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackDefaultGatewayAddresses
(
    uint8_t **bufferPtr,
    taf_dcs_DefaultGatewayAddresses_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv4Addr,
                                      sizeof(valuePtr->ipv4Addr),
                                      16);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv6Addr,
                                      sizeof(valuePtr->ipv6Addr),
                                      46);
    }
    return result;
}

static inline bool taf_dcs_PackDnsServerAddresses
(
    uint8_t **bufferPtr,
    const taf_dcs_DnsServerAddresses_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv4Addr1, 16);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv4Addr2, 16);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv6Addr1, 46);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv6Addr2, 46);
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackDnsServerAddresses
(
    uint8_t **bufferPtr,
    taf_dcs_DnsServerAddresses_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv4Addr1,
                                      sizeof(valuePtr->ipv4Addr1),
                                      16);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv4Addr2,
                                      sizeof(valuePtr->ipv4Addr2),
                                      16);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv6Addr1,
                                      sizeof(valuePtr->ipv6Addr1),
                                      46);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv6Addr2,
                                      sizeof(valuePtr->ipv6Addr2),
                                      46);
    }
    return result;
}

static inline bool taf_dcs_PackStateInfo
(
    uint8_t **bufferPtr,
    const taf_dcs_StateInfo_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = taf_dcs_PackPdp( bufferPtr,
                                                 valuePtr->ipType );
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackStateInfo
(
    uint8_t **bufferPtr,
    taf_dcs_StateInfo_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = taf_dcs_UnpackPdp(bufferPtr,
                                                   &valuePtr->ipType );
    }
    return result;
}

static inline bool taf_dcs_PackRoamingStatusInd
(
    uint8_t **bufferPtr,
    const taf_dcs_RoamingStatusInd_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->phoneId );
    result = result && subResult;
    subResult = le_pack_PackBool( bufferPtr,
                                                 valuePtr->isRoaming );
    result = result && subResult;
    subResult = taf_dcs_PackRoamingType( bufferPtr,
                                                 valuePtr->type );
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackRoamingStatusInd
(
    uint8_t **bufferPtr,
    taf_dcs_RoamingStatusInd_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->phoneId );
    }
    if (result)
    {
        result = le_pack_UnpackBool(bufferPtr,
                                                   &valuePtr->isRoaming );
    }
    if (result)
    {
        result = taf_dcs_UnpackRoamingType(bufferPtr,
                                                   &valuePtr->type );
    }
    return result;
}

static inline bool taf_dcs_PackProfileInfo
(
    uint8_t **bufferPtr,
    const taf_dcs_ProfileInfo_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint32( bufferPtr,
                                                 valuePtr->index );
    result = result && subResult;
    subResult = taf_dcs_PackTech( bufferPtr,
                                                 valuePtr->tech );
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->name, 64);
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackProfileInfo
(
    uint8_t **bufferPtr,
    taf_dcs_ProfileInfo_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint32(bufferPtr,
                                                   &valuePtr->index );
    }
    if (result)
    {
        result = taf_dcs_UnpackTech(bufferPtr,
                                                   &valuePtr->tech );
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->name,
                                      sizeof(valuePtr->name),
                                      64);
    }
    return result;
}

#endif // TAF_MDC_MESSAGES_H_INCLUDE_GUARD