rpc_wifi_api_client.cpp

/*
 * Generated by erpcgen 1.7.4 on Fri Feb 26 14:47:17 2021.
 *
 * AUTOGENERATED - DO NOT EDIT
 */


#include "erpc_client_manager.h"
#include "erpc_port.h"
#include "erpc_codec.h"
extern "C"
{
#include "rpc_wifi_api.h"
// import callbacks declaration from other groups
#include "rpc_system.h"
#include "rpc_ble_api.h"
#include "rpc_ble_callback.h"
#include "rpc_wifi_callback.h"
}

#if 10704 != ERPC_VERSION_NUMBER
#error "The generated shim code version is different to the rest of eRPC code."
#endif

using namespace erpc;
using namespace std;

extern ClientManager *g_client;

//! @brief Function to write struct binary_t
static void write_binary_t_struct(erpc::Codec * codec, const binary_t * data);


// Write struct binary_t function implementation
static void write_binary_t_struct(erpc::Codec * codec, const binary_t * data)
{
    codec->writeBinary(data->dataLength, data->data);
}


//! @brief Function to read struct binary_t
static void read_binary_t_struct(erpc::Codec * codec, binary_t * data);


// Read struct binary_t function implementation
static void read_binary_t_struct(erpc::Codec * codec, binary_t * data)
{
    uint8_t * data_local;
    codec->readBinary(&data->dataLength, &data_local);
    data->data = (uint8_t *) erpc_malloc(data->dataLength * sizeof(uint8_t));
    if (data->data == NULL)
    {
        codec->updateStatus(kErpcStatus_MemoryError);
    }
    else
    {
        memcpy(data->data, data_local, data->dataLength);
    }
}



// rpc_wifi_drv interface rpc_wifi_connect function client shim.
int32_t rpc_wifi_connect(const char * ssid, const char * password, uint32_t security_type, int32_t key_id, uint32_t semaphore)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_connect_id, request.getSequence());

        codec->writeString(strlen(ssid), ssid);

        if (password == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(password), password);
        }

        codec->write(security_type);

        codec->write(key_id);

        codec->write(semaphore);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_connect_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_connect_bssid function client shim.
int32_t rpc_wifi_connect_bssid(const binary_t * bssid, const char * ssid, const char * password, uint32_t security_type, int32_t key_id, uint32_t semaphore)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_connect_bssid_id, request.getSequence());

        write_binary_t_struct(codec, bssid);

        if (ssid == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(ssid), ssid);
        }

        codec->writeString(strlen(password), password);

        codec->write(security_type);

        codec->write(key_id);

        codec->write(semaphore);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_connect_bssid_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_disconnect function client shim.
int32_t rpc_wifi_disconnect(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_disconnect_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_disconnect_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_is_connected_to_ap function client shim.
int32_t rpc_wifi_is_connected_to_ap(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_is_connected_to_ap_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_is_connected_to_ap_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_is_up function client shim.
int32_t rpc_wifi_is_up(uint32_t itf)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_is_up_id, request.getSequence());

        codec->write(itf);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_is_up_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_is_ready_to_transceive function client shim.
int32_t rpc_wifi_is_ready_to_transceive(uint32_t itf)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_is_ready_to_transceive_id, request.getSequence());

        codec->write(itf);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_is_ready_to_transceive_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_mac_address function client shim.
int32_t rpc_wifi_set_mac_address(const binary_t * mac)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_mac_address_id, request.getSequence());

        write_binary_t_struct(codec, mac);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_mac_address_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_mac_address function client shim.
int32_t rpc_wifi_get_mac_address(uint8_t mac[18])
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_mac_address_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        for (uint32_t arrayCount0 = 0; arrayCount0 < 18; ++arrayCount0)
        {
            codec->read(&mac[arrayCount0]);
        }

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_mac_address_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_enable_powersave function client shim.
int32_t rpc_wifi_enable_powersave(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_enable_powersave_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_enable_powersave_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_resume_powersave function client shim.
int32_t rpc_wifi_resume_powersave(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_resume_powersave_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_resume_powersave_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_disable_powersave function client shim.
int32_t rpc_wifi_disable_powersave(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_disable_powersave_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_disable_powersave_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_btcoex_set_bt_on function client shim.
void rpc_wifi_btcoex_set_bt_on(void)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_btcoex_set_bt_on_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_btcoex_set_bt_on_id);

    return;
}

// rpc_wifi_drv interface rpc_wifi_btcoex_set_bt_off function client shim.
void rpc_wifi_btcoex_set_bt_off(void)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_btcoex_set_bt_off_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_btcoex_set_bt_off_id);

    return;
}

// rpc_wifi_drv interface rpc_wifi_get_associated_client_list function client shim.
int32_t rpc_wifi_get_associated_client_list(binary_t * client_list_buffer, uint16_t buffer_length)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_associated_client_list_id, request.getSequence());

        codec->write(buffer_length);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, client_list_buffer);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_associated_client_list_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_ap_bssid function client shim.
int32_t rpc_wifi_get_ap_bssid(uint8_t bssid[6])
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_ap_bssid_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        for (uint32_t arrayCount0 = 0; arrayCount0 < 6; ++arrayCount0)
        {
            codec->read(&bssid[arrayCount0]);
        }

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_ap_bssid_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_ap_info function client shim.
int32_t rpc_wifi_get_ap_info(binary_t * ap_info, uint32_t * security)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_ap_info_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, ap_info);

        codec->read(security);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_ap_info_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_country function client shim.
int32_t rpc_wifi_set_country(uint32_t country_code)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_country_id, request.getSequence());

        codec->write(country_code);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_country_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_sta_max_data_rate function client shim.
int32_t rpc_wifi_get_sta_max_data_rate(uint8_t * inidata_rate)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_sta_max_data_rate_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(inidata_rate);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_sta_max_data_rate_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_rssi function client shim.
int32_t rpc_wifi_get_rssi(int32_t * pRSSI)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_rssi_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(pRSSI);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_rssi_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_channel function client shim.
int32_t rpc_wifi_set_channel(int32_t channel)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_channel_id, request.getSequence());

        codec->write(channel);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_channel_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_channel function client shim.
int32_t rpc_wifi_get_channel(int32_t * channel)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_channel_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(channel);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_channel_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_change_channel_plan function client shim.
int32_t rpc_wifi_change_channel_plan(uint8_t channel_plan)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_change_channel_plan_id, request.getSequence());

        codec->write(channel_plan);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_change_channel_plan_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_register_multicast_address function client shim.
int32_t rpc_wifi_register_multicast_address(const uint8_t mac[6])
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_register_multicast_address_id, request.getSequence());

        for (uint32_t arrayCount0 = 0; arrayCount0 < 6; ++arrayCount0)
        {
            codec->write(mac[arrayCount0]);
        }

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_register_multicast_address_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_unregister_multicast_address function client shim.
int32_t rpc_wifi_unregister_multicast_address(const uint8_t mac[6])
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_unregister_multicast_address_id, request.getSequence());

        for (uint32_t arrayCount0 = 0; arrayCount0 < 6; ++arrayCount0)
        {
            codec->write(mac[arrayCount0]);
        }

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_unregister_multicast_address_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_rf_on function client shim.
int32_t rpc_wifi_rf_on(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_rf_on_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_rf_on_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_rf_off function client shim.
int32_t rpc_wifi_rf_off(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_rf_off_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_rf_off_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_on function client shim.
int32_t rpc_wifi_on(uint32_t mode)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_on_id, request.getSequence());

        codec->write(mode);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_on_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_off function client shim.
int32_t rpc_wifi_off(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_off_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_off_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_mode function client shim.
int32_t rpc_wifi_set_mode(uint32_t mode)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_mode_id, request.getSequence());

        codec->write(mode);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_mode_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_off_fastly function client shim.
int32_t rpc_wifi_off_fastly(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_off_fastly_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_off_fastly_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_power_mode function client shim.
int32_t rpc_wifi_set_power_mode(uint8_t ips_mode, uint8_t lps_mode)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_power_mode_id, request.getSequence());

        codec->write(ips_mode);

        codec->write(lps_mode);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_power_mode_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_tdma_param function client shim.
int32_t rpc_wifi_set_tdma_param(uint8_t slot_period, uint8_t rfon_period_len_1, uint8_t rfon_period_len_2, uint8_t rfon_period_len_3)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_tdma_param_id, request.getSequence());

        codec->write(slot_period);

        codec->write(rfon_period_len_1);

        codec->write(rfon_period_len_2);

        codec->write(rfon_period_len_3);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_tdma_param_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_lps_dtim function client shim.
int32_t rpc_wifi_set_lps_dtim(uint8_t dtim)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_lps_dtim_id, request.getSequence());

        codec->write(dtim);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_lps_dtim_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_lps_dtim function client shim.
int32_t rpc_wifi_get_lps_dtim(uint8_t * dtim)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_lps_dtim_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(dtim);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_lps_dtim_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_lps_thresh function client shim.
int32_t rpc_wifi_set_lps_thresh(uint8_t mode)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_lps_thresh_id, request.getSequence());

        codec->write(mode);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_lps_thresh_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_lps_level function client shim.
int32_t rpc_wifi_set_lps_level(uint8_t lps_level)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_lps_level_id, request.getSequence());

        codec->write(lps_level);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_lps_level_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_mfp_support function client shim.
int32_t rpc_wifi_set_mfp_support(uint8_t value)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_mfp_support_id, request.getSequence());

        codec->write(value);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_mfp_support_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_start_ap function client shim.
int32_t rpc_wifi_start_ap(const char * ssid, const char * password, uint32_t security_type, int32_t channel)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_start_ap_id, request.getSequence());

        codec->writeString(strlen(ssid), ssid);

        if (password == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(password), password);
        }

        codec->write(security_type);

        codec->write(channel);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_start_ap_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_start_ap_with_hidden_ssid function client shim.
int32_t rpc_wifi_start_ap_with_hidden_ssid(const char * ssid, const char * password, uint32_t security_type, int32_t channel)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_start_ap_with_hidden_ssid_id, request.getSequence());

        codec->writeString(strlen(ssid), ssid);

        if (password == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(password), password);
        }

        codec->write(security_type);

        codec->write(channel);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_start_ap_with_hidden_ssid_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_pscan_chan function client shim.
int32_t rpc_wifi_set_pscan_chan(const binary_t * channel_list, uint8_t pscan_config)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_pscan_chan_id, request.getSequence());

        write_binary_t_struct(codec, channel_list);

        codec->write(pscan_config);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_pscan_chan_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_setting function client shim.
int32_t rpc_wifi_get_setting(const char * ifname, binary_t * pSetting)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_setting_id, request.getSequence());

        codec->writeString(strlen(ifname), ifname);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pSetting);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_setting_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_network_mode function client shim.
int32_t rpc_wifi_set_network_mode(uint32_t mode)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_network_mode_id, request.getSequence());

        codec->write(mode);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_network_mode_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_network_mode function client shim.
int32_t rpc_wifi_get_network_mode(uint32_t * pmode)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_network_mode_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(pmode);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_network_mode_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_wps_phase function client shim.
int32_t rpc_wifi_set_wps_phase(uint8_t is_trigger_wps)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_wps_phase_id, request.getSequence());

        codec->write(is_trigger_wps);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_wps_phase_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_restart_ap function client shim.
int32_t rpc_wifi_restart_ap(const binary_t * ssid, const binary_t * password, uint32_t security_type, int32_t channel)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_restart_ap_id, request.getSequence());

        write_binary_t_struct(codec, ssid);

        write_binary_t_struct(codec, password);

        codec->write(security_type);

        codec->write(channel);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_restart_ap_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_config_autoreconnect function client shim.
int32_t rpc_wifi_config_autoreconnect(uint8_t mode, uint8_t retry_times, uint16_t timeout)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_config_autoreconnect_id, request.getSequence());

        codec->write(mode);

        codec->write(retry_times);

        codec->write(timeout);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_config_autoreconnect_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_autoreconnect function client shim.
int32_t rpc_wifi_set_autoreconnect(uint8_t mode)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_autoreconnect_id, request.getSequence());

        codec->write(mode);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_autoreconnect_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_autoreconnect function client shim.
int32_t rpc_wifi_get_autoreconnect(uint8_t * mode)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_autoreconnect_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(mode);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_autoreconnect_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_last_error function client shim.
int32_t rpc_wifi_get_last_error(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_last_error_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_last_error_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_add_custom_ie function client shim.
int32_t rpc_wifi_add_custom_ie(const binary_t * cus_ie)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_add_custom_ie_id, request.getSequence());

        write_binary_t_struct(codec, cus_ie);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_add_custom_ie_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_update_custom_ie function client shim.
int32_t rpc_wifi_update_custom_ie(const binary_t * cus_ie, int32_t ie_index)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_update_custom_ie_id, request.getSequence());

        write_binary_t_struct(codec, cus_ie);

        codec->write(ie_index);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_update_custom_ie_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_del_custom_ie function client shim.
int32_t rpc_wifi_del_custom_ie(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_del_custom_ie_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_del_custom_ie_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_indicate_mgnt function client shim.
void rpc_wifi_set_indicate_mgnt(int32_t enable)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_indicate_mgnt_id, request.getSequence());

        codec->write(enable);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_indicate_mgnt_id);

    return;
}

// rpc_wifi_drv interface rpc_wifi_get_drv_ability function client shim.
int32_t rpc_wifi_get_drv_ability(uint32_t * ability)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_drv_ability_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(ability);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_drv_ability_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_channel_plan function client shim.
int32_t rpc_wifi_set_channel_plan(uint8_t channel_plan)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_channel_plan_id, request.getSequence());

        codec->write(channel_plan);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_channel_plan_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_channel_plan function client shim.
int32_t rpc_wifi_get_channel_plan(uint8_t * channel_plan)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_channel_plan_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(channel_plan);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_channel_plan_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_enable_forwarding function client shim.
int32_t rpc_wifi_enable_forwarding(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_enable_forwarding_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_enable_forwarding_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_disable_forwarding function client shim.
int32_t rpc_wifi_disable_forwarding(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_disable_forwarding_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_disable_forwarding_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_ch_deauth function client shim.
int32_t rpc_wifi_set_ch_deauth(uint8_t enable)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_ch_deauth_id, request.getSequence());

        codec->write(enable);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_ch_deauth_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_band_type function client shim.
uint8_t rpc_wifi_get_band_type(void)
{
    erpc_status_t err = kErpcStatus_Success;

    uint8_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_band_type_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_band_type_id);

    if (err)
    {
        return 0xFFU;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_set_tx_pause_data function client shim.
int32_t rpc_wifi_set_tx_pause_data(uint32_t NewState)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_set_tx_pause_data_id, request.getSequence());

        codec->write(NewState);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_set_tx_pause_data_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_get_reconnect_data function client shim.
int32_t rpc_wifi_get_reconnect_data(binary_t * wifi_info)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_get_reconnect_data_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, wifi_info);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_get_reconnect_data_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_clear_reconnect_data function client shim.
int32_t rpc_wifi_clear_reconnect_data(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_clear_reconnect_data_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_clear_reconnect_data_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_scan_start function client shim.
int32_t rpc_wifi_scan_start(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_scan_start_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_scan_start_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_is_scaning function client shim.
bool rpc_wifi_is_scaning(void)
{
    erpc_status_t err = kErpcStatus_Success;

    bool result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_is_scaning_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_is_scaning_id);

    if (err)
    {
        return false;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_scan_get_ap_records function client shim.
int32_t rpc_wifi_scan_get_ap_records(uint16_t number, binary_t * _scanResult)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_scan_get_ap_records_id, request.getSequence());

        codec->write(number);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, _scanResult);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_scan_get_ap_records_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_drv interface rpc_wifi_scan_get_ap_num function client shim.
uint16_t rpc_wifi_scan_get_ap_num(void)
{
    erpc_status_t err = kErpcStatus_Success;

    uint16_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_drv_service_id, krpc_wifi_drv_rpc_wifi_scan_get_ap_num_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_drv_rpc_wifi_scan_get_ap_num_id);

    if (err)
    {
        return 0xFFFFU;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_init function client shim.
int32_t rpc_tcpip_adapter_init(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_init_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_init_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_sta_start function client shim.
int32_t rpc_tcpip_adapter_sta_start(const binary_t * mac, const binary_t * ip_info)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_sta_start_id, request.getSequence());

        write_binary_t_struct(codec, mac);

        write_binary_t_struct(codec, ip_info);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_sta_start_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_ap_start function client shim.
int32_t rpc_tcpip_adapter_ap_start(const binary_t * mac, const binary_t * ip_info)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_ap_start_id, request.getSequence());

        write_binary_t_struct(codec, mac);

        write_binary_t_struct(codec, ip_info);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_ap_start_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_stop function client shim.
int32_t rpc_tcpip_adapter_stop(uint32_t tcpip_if)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_stop_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_stop_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_up function client shim.
int32_t rpc_tcpip_adapter_up(uint32_t tcpip_if)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_up_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_up_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_down function client shim.
int32_t rpc_tcpip_adapter_down(uint32_t tcpip_if)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_down_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_down_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_get_ip_info function client shim.
int32_t rpc_tcpip_adapter_get_ip_info(uint32_t tcpip_if, binary_t * ip_info)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_get_ip_info_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, ip_info);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_get_ip_info_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_set_ip_info function client shim.
int32_t rpc_tcpip_adapter_set_ip_info(uint32_t tcpip_if, const binary_t * ip_info)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_set_ip_info_id, request.getSequence());

        codec->write(tcpip_if);

        write_binary_t_struct(codec, ip_info);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_set_ip_info_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_set_dns_info function client shim.
int32_t rpc_tcpip_adapter_set_dns_info(uint32_t tcpip_if, uint32_t dns_type, const binary_t * dns)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_set_dns_info_id, request.getSequence());

        codec->write(tcpip_if);

        codec->write(dns_type);

        write_binary_t_struct(codec, dns);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_set_dns_info_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_get_dns_info function client shim.
int32_t rpc_tcpip_adapter_get_dns_info(uint32_t tcpip_if, uint32_t dns_type, binary_t * dns)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_get_dns_info_id, request.getSequence());

        codec->write(tcpip_if);

        codec->write(dns_type);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, dns);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_get_dns_info_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_dhcps_start function client shim.
int32_t rpc_tcpip_adapter_dhcps_start(uint32_t tcpip_if)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_dhcps_start_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_dhcps_start_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_dhcps_stop function client shim.
int32_t rpc_tcpip_adapter_dhcps_stop(uint32_t tcpip_if)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_dhcps_stop_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_dhcps_stop_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_dhcpc_start function client shim.
int32_t rpc_tcpip_adapter_dhcpc_start(uint32_t tcpip_if)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_dhcpc_start_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_dhcpc_start_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_dhcpc_stop function client shim.
int32_t rpc_tcpip_adapter_dhcpc_stop(uint32_t tcpip_if)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_dhcpc_stop_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_dhcpc_stop_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_set_hostname function client shim.
int32_t rpc_tcpip_adapter_set_hostname(uint32_t tcpip_if, const char * hostname)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_set_hostname_id, request.getSequence());

        codec->write(tcpip_if);

        codec->writeString(strlen(hostname), hostname);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_set_hostname_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_get_hostname function client shim.
int32_t rpc_tcpip_adapter_get_hostname(uint32_t tcpip_if, char * hostname)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_get_hostname_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        uint32_t hostname_len;
        char * hostname_local;
        codec->readString(&hostname_len, &hostname_local);
        memcpy(hostname, hostname_local, hostname_len);
        (hostname)[hostname_len] = 0;

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_get_hostname_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_get_mac function client shim.
int32_t rpc_tcpip_adapter_get_mac(uint32_t tcpip_if, binary_t * mac)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_get_mac_id, request.getSequence());

        codec->write(tcpip_if);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, mac);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_get_mac_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_adapter_set_mac function client shim.
int32_t rpc_tcpip_adapter_set_mac(uint32_t tcpip_if, const binary_t * mac)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_adapter_set_mac_id, request.getSequence());

        codec->write(tcpip_if);

        write_binary_t_struct(codec, mac);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_adapter_set_mac_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcpip_api_call function client shim.
int32_t rpc_tcpip_api_call(const binary_t * func, const binary_t * call)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcpip_api_call_id, request.getSequence());

        write_binary_t_struct(codec, func);

        write_binary_t_struct(codec, call);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcpip_api_call_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_connect function client shim.
int32_t rpc_tcp_connect(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * ipaddr, uint16_t port, const binary_t * connected)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_connect_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, ipaddr);

        codec->write(port);

        write_binary_t_struct(codec, connected);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_connect_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_recved function client shim.
int32_t rpc_tcp_recved(const binary_t * pcb_in, binary_t * pcb_out, uint16_t len)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_recved_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        codec->write(len);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_recved_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_abort function client shim.
int32_t rpc_tcp_abort(const binary_t * pcb_in, binary_t * pcb_out)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_abort_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_abort_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_write function client shim.
int32_t rpc_tcp_write(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * data, uint8_t apiflags)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_write_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, data);

        codec->write(apiflags);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_write_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_output function client shim.
int32_t rpc_tcp_output(const binary_t * pcb_in, binary_t * pcb_out)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_output_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_output_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_close function client shim.
int32_t rpc_tcp_close(const binary_t * pcb_in, binary_t * pcb_out)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_close_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_close_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_bind function client shim.
int32_t rpc_tcp_bind(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * ipaddr, uint16_t port)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_bind_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, ipaddr);

        codec->write(port);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_bind_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_new_ip_type function client shim.
int32_t rpc_tcp_new_ip_type(uint8_t ip_type, binary_t * pcb_out)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_new_ip_type_id, request.getSequence());

        codec->write(ip_type);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_new_ip_type_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_arg function client shim.
int32_t rpc_tcp_arg(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * func_arg)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_arg_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, func_arg);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_arg_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_err function client shim.
int32_t rpc_tcp_err(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * func_err)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_err_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, func_err);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_err_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_recv function client shim.
int32_t rpc_tcp_recv(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * func_recv)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_recv_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, func_recv);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_recv_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_sent function client shim.
int32_t rpc_tcp_sent(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * func_sent)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_sent_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, func_sent);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_sent_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_accept function client shim.
int32_t rpc_tcp_accept(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * func_accept)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_accept_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, func_accept);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_accept_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_poll function client shim.
int32_t rpc_tcp_poll(const binary_t * pcb_in, binary_t * pcb_out, const binary_t * func_poll, uint8_t interval)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_poll_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        write_binary_t_struct(codec, func_poll);

        codec->write(interval);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_poll_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_tcp_listen_with_backlog function client shim.
int32_t rpc_tcp_listen_with_backlog(const binary_t * pcb_in, binary_t * pcb_out, uint8_t backlog)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_tcp_listen_with_backlog_id, request.getSequence());

        write_binary_t_struct(codec, pcb_in);

        codec->write(backlog);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, pcb_out);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_tcp_listen_with_backlog_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_pbuf_free function client shim.
int32_t rpc_pbuf_free(const binary_t * p)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_pbuf_free_id, request.getSequence());

        write_binary_t_struct(codec, p);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_pbuf_free_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_tcpip interface rpc_ip4addr_ntoa function client shim.
char * rpc_ip4addr_ntoa(const binary_t * ip4_addr_in)
{
    erpc_status_t err = kErpcStatus_Success;

    char * result = NULL;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_ip4addr_ntoa_id, request.getSequence());

        write_binary_t_struct(codec, ip4_addr_in);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        uint32_t return_len;
        char * return_local;
        codec->readString(&return_len, &return_local);
        result = (char *) erpc_malloc((return_len + 1) * sizeof(char));
        if (result == NULL)
        {
            codec->updateStatus(kErpcStatus_MemoryError);
        }
        else
        {
            memcpy(result, return_local, return_len);
            (result)[return_len] = 0;
        }

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_ip4addr_ntoa_id);

    return result;
}

// rpc_wifi_tcpip interface rpc_inet_chksum function client shim.
uint16_t rpc_inet_chksum(const binary_t * dataptr_in)
{
    erpc_status_t err = kErpcStatus_Success;

    uint16_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_tcpip_service_id, krpc_wifi_tcpip_rpc_inet_chksum_id, request.getSequence());

        write_binary_t_struct(codec, dataptr_in);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_tcpip_rpc_inet_chksum_id);

    if (err)
    {
        return 0xFFFFU;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_accept function client shim.
int32_t rpc_lwip_accept(int32_t s, const binary_t * addr, uint32_t * addrlen)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_accept_id, request.getSequence());

        codec->write(s);

        write_binary_t_struct(codec, addr);

        codec->write(*addrlen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(addrlen);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_accept_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_bind function client shim.
int32_t rpc_lwip_bind(int32_t s, const binary_t * name, uint32_t namelen)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_bind_id, request.getSequence());

        codec->write(s);

        write_binary_t_struct(codec, name);

        codec->write(namelen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_bind_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_shutdown function client shim.
int32_t rpc_lwip_shutdown(int32_t s, int32_t how)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_shutdown_id, request.getSequence());

        codec->write(s);

        codec->write(how);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_shutdown_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_getpeername function client shim.
int32_t rpc_lwip_getpeername(int32_t s, binary_t * name, uint32_t * namelen)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_getpeername_id, request.getSequence());

        codec->write(s);

        codec->write(*namelen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, name);

        codec->read(namelen);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_getpeername_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_getsockname function client shim.
int32_t rpc_lwip_getsockname(int32_t s, binary_t * name, uint32_t * namelen)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_getsockname_id, request.getSequence());

        codec->write(s);

        codec->write(*namelen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, name);

        codec->read(namelen);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_getsockname_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_getsockopt function client shim.
int32_t rpc_lwip_getsockopt(int32_t s, int32_t level, int32_t optname, const binary_t * in_optval, binary_t * out_optval, uint32_t * optlen)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_getsockopt_id, request.getSequence());

        codec->write(s);

        codec->write(level);

        codec->write(optname);

        write_binary_t_struct(codec, in_optval);

        codec->write(*optlen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, out_optval);

        codec->read(optlen);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_getsockopt_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_setsockopt function client shim.
int32_t rpc_lwip_setsockopt(int32_t s, int32_t level, int32_t optname, const binary_t * optval, uint32_t optlen)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_setsockopt_id, request.getSequence());

        codec->write(s);

        codec->write(level);

        codec->write(optname);

        write_binary_t_struct(codec, optval);

        codec->write(optlen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_setsockopt_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_close function client shim.
int32_t rpc_lwip_close(int32_t s)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_close_id, request.getSequence());

        codec->write(s);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_close_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_connect function client shim.
int32_t rpc_lwip_connect(int32_t s, const binary_t * name, uint32_t namelen)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_connect_id, request.getSequence());

        codec->write(s);

        write_binary_t_struct(codec, name);

        codec->write(namelen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_connect_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_listen function client shim.
int32_t rpc_lwip_listen(int32_t s, int32_t backlog)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_listen_id, request.getSequence());

        codec->write(s);

        codec->write(backlog);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_listen_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_available function client shim.
int32_t rpc_lwip_available(int32_t s)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_available_id, request.getSequence());

        codec->write(s);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_available_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_recv function client shim.
int32_t rpc_lwip_recv(int32_t s, binary_t * mem, uint32_t len, int32_t flags, uint32_t timeout)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_recv_id, request.getSequence());

        codec->write(s);

        codec->write(len);

        codec->write(flags);

        codec->write(timeout);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, mem);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_recv_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_read function client shim.
int32_t rpc_lwip_read(int32_t s, binary_t * mem, uint32_t len, uint32_t timeout)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_read_id, request.getSequence());

        codec->write(s);

        codec->write(len);

        codec->write(timeout);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, mem);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_read_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_recvfrom function client shim.
int32_t rpc_lwip_recvfrom(int32_t s, binary_t * mem, uint32_t len, int32_t flags, binary_t * from, uint32_t * fromlen, uint32_t timeout)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_recvfrom_id, request.getSequence());

        codec->write(s);

        codec->write(len);

        codec->write(flags);

        codec->write(*fromlen);

        codec->write(timeout);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, mem);

        read_binary_t_struct(codec, from);

        codec->read(fromlen);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_recvfrom_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_send function client shim.
int32_t rpc_lwip_send(int32_t s, const binary_t * dataptr, int32_t flags)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_send_id, request.getSequence());

        codec->write(s);

        write_binary_t_struct(codec, dataptr);

        codec->write(flags);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_send_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_sendmsg function client shim.
int32_t rpc_lwip_sendmsg(int32_t s, const binary_t * msg_name, const binary_t * msg_iov, const binary_t * msg_control, int32_t msg_flags, int32_t flags)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_sendmsg_id, request.getSequence());

        codec->write(s);

        write_binary_t_struct(codec, msg_name);

        write_binary_t_struct(codec, msg_iov);

        write_binary_t_struct(codec, msg_control);

        codec->write(msg_flags);

        codec->write(flags);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_sendmsg_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_sendto function client shim.
int32_t rpc_lwip_sendto(int32_t s, const binary_t * dataptr, int32_t flags, const binary_t * to, uint32_t tolen)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_sendto_id, request.getSequence());

        codec->write(s);

        write_binary_t_struct(codec, dataptr);

        codec->write(flags);

        write_binary_t_struct(codec, to);

        codec->write(tolen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_sendto_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_socket function client shim.
int32_t rpc_lwip_socket(int32_t domain, int32_t l_type, int32_t protocol)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_socket_id, request.getSequence());

        codec->write(domain);

        codec->write(l_type);

        codec->write(protocol);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_socket_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_write function client shim.
int32_t rpc_lwip_write(int32_t s, const binary_t * dataptr, uint32_t size)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_write_id, request.getSequence());

        codec->write(s);

        write_binary_t_struct(codec, dataptr);

        codec->write(size);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_write_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_writev function client shim.
int32_t rpc_lwip_writev(int32_t s, const binary_t * iov, int32_t iovcnt)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_writev_id, request.getSequence());

        codec->write(s);

        write_binary_t_struct(codec, iov);

        codec->write(iovcnt);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_writev_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_select function client shim.
int32_t rpc_lwip_select(int32_t maxfdp1, const binary_t * readset, const binary_t * writeset, const binary_t * exceptset, const binary_t * timeout)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_select_id, request.getSequence());

        codec->write(maxfdp1);

        if (readset == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            write_binary_t_struct(codec, readset);
        }

        if (writeset == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            write_binary_t_struct(codec, writeset);
        }

        if (exceptset == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            write_binary_t_struct(codec, exceptset);
        }

        if (timeout == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            write_binary_t_struct(codec, timeout);
        }

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_select_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_ioctl function client shim.
int32_t rpc_lwip_ioctl(int32_t s, uint32_t cmd, const binary_t * in_argp, binary_t * out_argp)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_ioctl_id, request.getSequence());

        codec->write(s);

        codec->write(cmd);

        write_binary_t_struct(codec, in_argp);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, out_argp);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_ioctl_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_fcntl function client shim.
int32_t rpc_lwip_fcntl(int32_t s, int32_t cmd, int32_t val)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_fcntl_id, request.getSequence());

        codec->write(s);

        codec->write(cmd);

        codec->write(val);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_fcntl_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_lwip_errno function client shim.
int32_t rpc_lwip_errno(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_lwip_errno_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_lwip_errno_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_netconn_gethostbyname function client shim.
int8_t rpc_netconn_gethostbyname(const char * name, binary_t * addr)
{
    erpc_status_t err = kErpcStatus_Success;

    int8_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_netconn_gethostbyname_id, request.getSequence());

        codec->writeString(strlen(name), name);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, addr);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_netconn_gethostbyname_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_lwip interface rpc_dns_gethostbyname_addrtype function client shim.
int8_t rpc_dns_gethostbyname_addrtype(const char * hostname, binary_t * addr, uint32_t found, const binary_t * callback_arg, uint8_t dns_addrtype)
{
    erpc_status_t err = kErpcStatus_Success;

    int8_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_lwip_service_id, krpc_wifi_lwip_rpc_dns_gethostbyname_addrtype_id, request.getSequence());

        codec->writeString(strlen(hostname), hostname);

        codec->write(found);

        if (callback_arg == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            write_binary_t_struct(codec, callback_arg);
        }

        codec->write(dns_addrtype);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, addr);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_lwip_rpc_dns_gethostbyname_addrtype_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_client_create function client shim.
uint32_t rpc_wifi_ssl_client_create(void)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_client_create_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_client_create_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_client_destroy function client shim.
void rpc_wifi_ssl_client_destroy(uint32_t ssl_client)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_client_destroy_id, request.getSequence());

        codec->write(ssl_client);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_client_destroy_id);

    return;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_init function client shim.
void rpc_wifi_ssl_init(uint32_t ssl_client)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_init_id, request.getSequence());

        codec->write(ssl_client);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_init_id);

    return;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_set_socket function client shim.
void rpc_wifi_ssl_set_socket(uint32_t ssl_client, int32_t socket)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_set_socket_id, request.getSequence());

        codec->write(ssl_client);

        codec->write(socket);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_set_socket_id);

    return;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_set_timeout function client shim.
void rpc_wifi_ssl_set_timeout(uint32_t ssl_client, uint32_t timeout)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_set_timeout_id, request.getSequence());

        codec->write(ssl_client);

        codec->write(timeout);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_set_timeout_id);

    return;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_get_socket function client shim.
int32_t rpc_wifi_ssl_get_socket(uint32_t ssl_client)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_get_socket_id, request.getSequence());

        codec->write(ssl_client);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_get_socket_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_get_timeout function client shim.
uint32_t rpc_wifi_ssl_get_timeout(uint32_t ssl_client)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_get_timeout_id, request.getSequence());

        codec->write(ssl_client);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_get_timeout_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_set_rootCA function client shim.
uint32_t rpc_wifi_ssl_set_rootCA(uint32_t ssl_client, const char * rootCABuff)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_set_rootCA_id, request.getSequence());

        codec->write(ssl_client);

        codec->writeString(strlen(rootCABuff), rootCABuff);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_set_rootCA_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_get_rootCA function client shim.
uint32_t rpc_wifi_ssl_get_rootCA(uint32_t ssl_client, char * rootCABuff)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_get_rootCA_id, request.getSequence());

        codec->write(ssl_client);

        if (rootCABuff == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
        }

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        if (rootCABuff != NULL)
        {
            uint32_t rootCABuff_len;
            char * rootCABuff_local;
            codec->readString(&rootCABuff_len, &rootCABuff_local);
            memcpy(rootCABuff, rootCABuff_local, rootCABuff_len);
            (rootCABuff)[rootCABuff_len] = 0;
        }

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_get_rootCA_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_set_cliCert function client shim.
uint32_t rpc_wifi_ssl_set_cliCert(uint32_t ssl_client, const char * cli_cert)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_set_cliCert_id, request.getSequence());

        codec->write(ssl_client);

        codec->writeString(strlen(cli_cert), cli_cert);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_set_cliCert_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_get_cliCert function client shim.
uint32_t rpc_wifi_ssl_get_cliCert(uint32_t ssl_client, const char * cli_cert)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_get_cliCert_id, request.getSequence());

        codec->write(ssl_client);

        if (cli_cert == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(cli_cert), cli_cert);
        }

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_get_cliCert_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_set_cliKey function client shim.
uint32_t rpc_wifi_ssl_set_cliKey(uint32_t ssl_client, const char * cli_key)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_set_cliKey_id, request.getSequence());

        codec->write(ssl_client);

        codec->writeString(strlen(cli_key), cli_key);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_set_cliKey_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_get_cliKey function client shim.
uint32_t rpc_wifi_ssl_get_cliKey(uint32_t ssl_client, const char * cli_key)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_get_cliKey_id, request.getSequence());

        codec->write(ssl_client);

        if (cli_key == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(cli_key), cli_key);
        }

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_get_cliKey_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_set_pskIdent function client shim.
uint32_t rpc_wifi_ssl_set_pskIdent(uint32_t ssl_client, const char * pskIdent)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_set_pskIdent_id, request.getSequence());

        codec->write(ssl_client);

        codec->writeString(strlen(pskIdent), pskIdent);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_set_pskIdent_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_get_pskIdent function client shim.
uint32_t rpc_wifi_ssl_get_pskIdent(uint32_t ssl_client, const char * pskIdent)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_get_pskIdent_id, request.getSequence());

        codec->write(ssl_client);

        if (pskIdent == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(pskIdent), pskIdent);
        }

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_get_pskIdent_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_set_psKey function client shim.
uint32_t rpc_wifi_ssl_set_psKey(uint32_t ssl_client, const char * psKey)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_set_psKey_id, request.getSequence());

        codec->write(ssl_client);

        codec->writeString(strlen(psKey), psKey);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_set_psKey_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_get_psKey function client shim.
uint32_t rpc_wifi_ssl_get_psKey(uint32_t ssl_client, const char * psKey)
{
    erpc_status_t err = kErpcStatus_Success;

    uint32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_get_psKey_id, request.getSequence());

        codec->write(ssl_client);

        if (psKey == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(psKey), psKey);
        }

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_get_psKey_id);

    if (err)
    {
        return 0xFFFFFFFFU;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_start_ssl_client function client shim.
int32_t rpc_wifi_start_ssl_client(uint32_t ssl_client, const char * host, uint32_t port, int32_t timeout)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_start_ssl_client_id, request.getSequence());

        codec->write(ssl_client);

        if (host == NULL)
        {
            codec->writeNullFlag(true);
        }
        else
        {
            codec->writeNullFlag(false);
            codec->writeString(strlen(host), host);
        }

        codec->write(port);

        codec->write(timeout);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_start_ssl_client_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_stop_ssl_socket function client shim.
void rpc_wifi_stop_ssl_socket(uint32_t ssl_client)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_stop_ssl_socket_id, request.getSequence());

        codec->write(ssl_client);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_stop_ssl_socket_id);

    return;
}

// rpc_wifi_mbedtls interface rpc_wifi_data_to_read function client shim.
int32_t rpc_wifi_data_to_read(uint32_t ssl_client)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_data_to_read_id, request.getSequence());

        codec->write(ssl_client);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_data_to_read_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_send_ssl_data function client shim.
int32_t rpc_wifi_send_ssl_data(uint32_t ssl_client, const binary_t * data, uint16_t len)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_send_ssl_data_id, request.getSequence());

        codec->write(ssl_client);

        write_binary_t_struct(codec, data);

        codec->write(len);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_send_ssl_data_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_get_ssl_receive function client shim.
int32_t rpc_wifi_get_ssl_receive(uint32_t ssl_client, binary_t * data, int32_t length)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_get_ssl_receive_id, request.getSequence());

        codec->write(ssl_client);

        codec->write(length);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, data);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_get_ssl_receive_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_verify_ssl_fingerprint function client shim.
bool rpc_wifi_verify_ssl_fingerprint(uint32_t ssl_client, const char * fp, const char * domain_name)
{
    erpc_status_t err = kErpcStatus_Success;

    bool result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_verify_ssl_fingerprint_id, request.getSequence());

        codec->write(ssl_client);

        codec->writeString(strlen(fp), fp);

        codec->writeString(strlen(domain_name), domain_name);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_verify_ssl_fingerprint_id);

    if (err)
    {
        return false;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_verify_ssl_dn function client shim.
bool rpc_wifi_verify_ssl_dn(uint32_t ssl_client, const char * domain_name)
{
    erpc_status_t err = kErpcStatus_Success;

    bool result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_verify_ssl_dn_id, request.getSequence());

        codec->write(ssl_client);

        codec->writeString(strlen(domain_name), domain_name);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_verify_ssl_dn_id);

    if (err)
    {
        return false;
    }

    return result;
}

// rpc_wifi_mbedtls interface rpc_wifi_ssl_strerror function client shim.
void rpc_wifi_ssl_strerror(int32_t errnum, binary_t * buffer, uint32_t buflen)
{
    erpc_status_t err = kErpcStatus_Success;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mbedtls_service_id, krpc_wifi_mbedtls_rpc_wifi_ssl_strerror_id, request.getSequence());

        codec->write(errnum);

        codec->write(buflen);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, buffer);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mbedtls_rpc_wifi_ssl_strerror_id);

    return;
}

// rpc_wifi_mdns interface rpc_mdns_init function client shim.
int32_t rpc_mdns_init(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_init_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_init_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_free function client shim.
int32_t rpc_mdns_free(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_free_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_free_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_service_add function client shim.
int32_t rpc_mdns_service_add(const char * instance_name, const char * service_type, const char * proto, uint16_t port)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_service_add_id, request.getSequence());

        codec->writeString(strlen(instance_name), instance_name);

        codec->writeString(strlen(service_type), service_type);

        codec->writeString(strlen(proto), proto);

        codec->write(port);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_service_add_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_service_remove function client shim.
int32_t rpc_mdns_service_remove(const char * service_type, const char * proto)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_service_remove_id, request.getSequence());

        codec->writeString(strlen(service_type), service_type);

        codec->writeString(strlen(proto), proto);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_service_remove_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_service_txt_item_set function client shim.
int32_t rpc_mdns_service_txt_item_set(const char * service_type, const char * proto, const char * key, const char * value)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_service_txt_item_set_id, request.getSequence());

        codec->writeString(strlen(service_type), service_type);

        codec->writeString(strlen(proto), proto);

        codec->writeString(strlen(key), key);

        codec->writeString(strlen(value), value);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_service_txt_item_set_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_service_instance_name_set function client shim.
int32_t rpc_mdns_service_instance_name_set(const char * service, const char * proto, const char * instance)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_service_instance_name_set_id, request.getSequence());

        codec->writeString(strlen(service), service);

        codec->writeString(strlen(proto), proto);

        codec->writeString(strlen(instance), instance);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_service_instance_name_set_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_instance_name_set function client shim.
int32_t rpc_mdns_instance_name_set(const char * instance_name)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_instance_name_set_id, request.getSequence());

        codec->writeString(strlen(instance_name), instance_name);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_instance_name_set_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_hostname_set function client shim.
int32_t rpc_mdns_hostname_set(const char * hostname)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_hostname_set_id, request.getSequence());

        codec->writeString(strlen(hostname), hostname);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_hostname_set_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_query_a function client shim.
int32_t rpc_mdns_query_a(const char * host_name, uint32_t timeout, binary_t * addr)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_query_a_id, request.getSequence());

        codec->writeString(strlen(host_name), host_name);

        codec->write(timeout);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, addr);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_query_a_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_query_ptr function client shim.
int32_t rpc_mdns_query_ptr(const char * service_type, const char * proto, uint32_t timeout, int32_t max_results, int32_t * result_total)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_query_ptr_id, request.getSequence());

        codec->writeString(strlen(service_type), service_type);

        codec->writeString(strlen(proto), proto);

        codec->write(timeout);

        codec->write(max_results);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(result_total);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_query_ptr_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_query_ptr_result_basic function client shim.
int32_t rpc_mdns_query_ptr_result_basic(int32_t result_target, binary_t * scan_result)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_query_ptr_result_basic_id, request.getSequence());

        codec->write(result_target);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, scan_result);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_query_ptr_result_basic_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_query_ptr_result_txt function client shim.
int32_t rpc_mdns_query_ptr_result_txt(int32_t result_target, int32_t txt_target, binary_t * txt)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_query_ptr_result_txt_id, request.getSequence());

        codec->write(result_target);

        codec->write(txt_target);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, txt);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_query_ptr_result_txt_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_query_ptr_result_addr function client shim.
int32_t rpc_mdns_query_ptr_result_addr(int32_t result_target, int32_t addr_target, binary_t * addr)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_query_ptr_result_addr_id, request.getSequence());

        codec->write(result_target);

        codec->write(addr_target);

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        read_binary_t_struct(codec, addr);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_query_ptr_result_addr_id);

    if (err)
    {
        return -1;
    }

    return result;
}

// rpc_wifi_mdns interface rpc_mdns_query_results_free function client shim.
int32_t rpc_mdns_query_results_free(void)
{
    erpc_status_t err = kErpcStatus_Success;

    int32_t result;

    // Get a new request.
    RequestContext request = g_client->createRequest(false);

    // Encode the request.
    Codec * codec = request.getCodec();

    if (codec == NULL)
    {
        err = kErpcStatus_MemoryError;
    }
    else
    {
        codec->startWriteMessage(kInvocationMessage, krpc_wifi_mdns_service_id, krpc_wifi_mdns_rpc_mdns_query_results_free_id, request.getSequence());

        // Send message to server
        // Codec status is checked inside this function.
        g_client->performRequest(request);

        codec->read(&result);

        err = codec->getStatus();
    }

    // Dispose of the request.
    g_client->releaseRequest(request);

    // Invoke error handler callback function
    g_client->callErrorHandler(err, krpc_wifi_mdns_rpc_mdns_query_results_free_id);

    if (err)
    {
        return -1;
    }

    return result;
}