/*
 *
 *    Copyright (c) 2013-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *    @file
 *      This file implements a derived unsolicited responder
 *      (i.e., server) for the Weave Service Provisioning profile used
 *      for the Weave mock device command line functional testing
 *      tool.
 *
 */

#define __STDC_FORMAT_MACROS

#include <inttypes.h>
#include <stdio.h>

#include "ToolCommon.h"
#include "MockSPServer.h"
#include "MockDDServer.h"
#include <Weave/Support/CodeUtils.h>
#include <Weave/Core/WeaveTLV.h>
#include <Weave/Profiles/WeaveProfiles.h>
#include <Weave/Profiles/device-description/DeviceDescription.h>
#include <Weave/Profiles/common/CommonProfile.h>
#include <Weave/Support/ErrorStr.h>
#include "CASEOptions.h"

using namespace nl::Weave;
using namespace nl::Weave::TLV;
using namespace nl::Weave::Profiles;
using namespace nl::Weave::Profiles::ServiceProvisioning;
using namespace nl::Weave::Profiles::DeviceDescription;

extern MockDeviceDescriptionServer MockDDServer;

MockServiceProvisioningServer::MockServiceProvisioningServer()
{
    mPersistedServiceId = 0;
    mPersistedAccountId = NULL;
    mPersistedServiceConfig = NULL;
    mPersistedServiceConfigLen = 0;
    mPairingServerCon = NULL;
    mPairingServerBinding = NULL;
}

WEAVE_ERROR MockServiceProvisioningServer::Init(WeaveExchangeManager *exchangeMgr)
{
    WEAVE_ERROR err;

    // Initialize the base class.
    err = this->ServiceProvisioningServer::Init(exchangeMgr);
    SuccessOrExit(err);

    // Tell the base class that it should delegate service provisioning requests to us.
    SetDelegate(this);

    static char defaultPairingServerAddr[64];
    strcpy(defaultPairingServerAddr, "127.0.0.1");

#if WEAVE_CONFIG_ENABLE_TARGETED_LISTEN
    if (FabricState->ListenIPv4Addr == IPAddress::Any)
    {
        if (FabricState->ListenIPv6Addr != IPAddress::Any)
            FabricState->ListenIPv6Addr.ToString(defaultPairingServerAddr, sizeof(defaultPairingServerAddr));
    }
    else
        FabricState->ListenIPv4Addr.ToString(defaultPairingServerAddr, sizeof(defaultPairingServerAddr));
#endif

    PairingEndPointId = FabricState->LocalNodeId;
    PairingServerAddr = defaultPairingServerAddr;

    // Clear our state.
    mPersistedServiceId = 0;
    mPersistedAccountId = NULL;
    mPersistedServiceConfig = NULL;
    mPersistedServiceConfigLen = 0;
    mPairingServerCon = NULL;
    mPairingServerBinding = NULL;

exit:
    return err;
}

WEAVE_ERROR MockServiceProvisioningServer::Shutdown()
{
    ClearPersistedService();
    return this->ServiceProvisioningServer::Shutdown();
}

void MockServiceProvisioningServer::Reset()
{
    ClearPersistedService();
}

void MockServiceProvisioningServer::Preconfig()
{
    // This dummy service config object contains the following information:
    //
    //    Trusted Certificates:
    //        The Nest Development Root Certificate
    //        A dummy "account" certificate with a common name of "DUMMY-ACCOUNT-ID" (see below)
    //
    //    Directory End Point:
    //        Endpoint Id: 18B4300200000001 (the service directory endpoint)
    //        Endpoint Host Name: frontdoor.integration.nestlabs.com
    //        Endpoint Port: 11095 (the weave default port)
    //
    // The dummy account certificate is:
    //
    //    1QAABAABADABCE4vMktB1zrbJAIENwMsgRBEVU1NWS1BQ0NPVU5ULUlEGCYEy6j6GyYFSzVPQjcG
    //    LIEQRFVNTVktQUNDT1VOVC1JRBgkBwImCCUAWiMwCjkEK9nbWmLvurFTKg+ZY7eKMMWKQSmlGU5L
    //    C/N+2sXpszXwdRhtSV2GxEQlB0G006nv7rQq1gpdneA1gykBGDWCKQEkAgUYNYQpATYCBAIEARgY
    //    NYEwAghCPJVfRh5S2xg1gDACCEI8lV9GHlLbGDUMMAEdAIphhmI9F7LSz9JtOT3kJWngkeoFanXO
    //    3UXrg88wAhx0tCukbRRlt7dxmlqvZNKIYG6zsaAxypJvyvJDGBg=
    //
    // The corresponding private key is:
    //
    //    1QAABAACACYBJQBaIzACHLr840+Gv3w4EnAr+aMQv0+b8+8wD6VETUI6Z2owAzkEK9nbWmLvurFT
    //    Kg+ZY7eKMMWKQSmlGU5LC/N+2sXpszXwdRhtSV2GxEQlB0G006nv7rQq1gpdneAY
    //
    // The following is a fabric access token containing the dummy account certificate and
    // private key.  This can be used to authenticate to the mock device when it has been
    // configured to use the dummy service config.
    //
    //    1QAABAAJADUBMAEITi8yS0HXOtskAgQ3AyyBEERVTU1ZLUFDQ09VTlQtSUQYJgTLqPobJgVLNU9C
    //    NwYsgRBEVU1NWS1BQ0NPVU5ULUlEGCQHAiYIJQBaIzAKOQQr2dtaYu+6sVMqD5ljt4owxYpBKaUZ
    //    TksL837axemzNfB1GG1JXYbERCUHQbTTqe/utCrWCl2d4DWDKQEYNYIpASQCBRg1hCkBNgIEAgQB
    //    GBg1gTACCEI8lV9GHlLbGDWAMAIIQjyVX0YeUtsYNQwwAR0AimGGYj0XstLP0m05PeQlaeCR6gVq
    //    dc7dReuDzzACHHS0K6RtFGW3t3GaWq9k0ohgbrOxoDHKkm/K8kMYGDUCJgElAFojMAIcuvzjT4a/
    //    fDgScCv5oxC/T5vz7zAPpURNQjpnajADOQQr2dtaYu+6sVMqD5ljt4owxYpBKaUZTksL837axemz
    //    NfB1GG1JXYbERCUHQbTTqe/utCrWCl2d4BgY
    //
    //
    static const char dummyAccountId[] = "DUMMY-ACCOUNT-ID";
    static const uint8_t dummyServiceConfig[] =
    {
        0xd5, 0x00, 0x00, 0x0f, 0x00, 0x01, 0x00, 0x36, 0x01, 0x15, 0x30, 0x01, 0x08, 0x4e, 0x2f, 0x32,
        0x4b, 0x41, 0xd7, 0x3a, 0xdb, 0x24, 0x02, 0x04, 0x37, 0x03, 0x2c, 0x81, 0x10, 0x44, 0x55, 0x4d,
        0x4d, 0x59, 0x2d, 0x41, 0x43, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x2d, 0x49, 0x44, 0x18, 0x26, 0x04,
        0xcb, 0xa8, 0xfa, 0x1b, 0x26, 0x05, 0x4b, 0x35, 0x4f, 0x42, 0x37, 0x06, 0x2c, 0x81, 0x10, 0x44,
        0x55, 0x4d, 0x4d, 0x59, 0x2d, 0x41, 0x43, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x2d, 0x49, 0x44, 0x18,
        0x24, 0x07, 0x02, 0x26, 0x08, 0x25, 0x00, 0x5a, 0x23, 0x30, 0x0a, 0x39, 0x04, 0x2b, 0xd9, 0xdb,
        0x5a, 0x62, 0xef, 0xba, 0xb1, 0x53, 0x2a, 0x0f, 0x99, 0x63, 0xb7, 0x8a, 0x30, 0xc5, 0x8a, 0x41,
        0x29, 0xa5, 0x19, 0x4e, 0x4b, 0x0b, 0xf3, 0x7e, 0xda, 0xc5, 0xe9, 0xb3, 0x35, 0xf0, 0x75, 0x18,
        0x6d, 0x49, 0x5d, 0x86, 0xc4, 0x44, 0x25, 0x07, 0x41, 0xb4, 0xd3, 0xa9, 0xef, 0xee, 0xb4, 0x2a,
        0xd6, 0x0a, 0x5d, 0x9d, 0xe0, 0x35, 0x83, 0x29, 0x01, 0x18, 0x35, 0x82, 0x29, 0x01, 0x24, 0x02,
        0x05, 0x18, 0x35, 0x84, 0x29, 0x01, 0x36, 0x02, 0x04, 0x02, 0x04, 0x01, 0x18, 0x18, 0x35, 0x81,
        0x30, 0x02, 0x08, 0x42, 0x3c, 0x95, 0x5f, 0x46, 0x1e, 0x52, 0xdb, 0x18, 0x35, 0x80, 0x30, 0x02,
        0x08, 0x42, 0x3c, 0x95, 0x5f, 0x46, 0x1e, 0x52, 0xdb, 0x18, 0x35, 0x0c, 0x30, 0x01, 0x1d, 0x00,
        0x8a, 0x61, 0x86, 0x62, 0x3d, 0x17, 0xb2, 0xd2, 0xcf, 0xd2, 0x6d, 0x39, 0x3d, 0xe4, 0x25, 0x69,
        0xe0, 0x91, 0xea, 0x05, 0x6a, 0x75, 0xce, 0xdd, 0x45, 0xeb, 0x83, 0xcf, 0x30, 0x02, 0x1c, 0x74,
        0xb4, 0x2b, 0xa4, 0x6d, 0x14, 0x65, 0xb7, 0xb7, 0x71, 0x9a, 0x5a, 0xaf, 0x64, 0xd2, 0x88, 0x60,
        0x6e, 0xb3, 0xb1, 0xa0, 0x31, 0xca, 0x92, 0x6f, 0xca, 0xf2, 0x43, 0x18, 0x18, 0x15, 0x30, 0x01,
        0x09, 0x00, 0xa8, 0x34, 0x22, 0xe9, 0xd9, 0x75, 0xe4, 0x55, 0x24, 0x02, 0x04, 0x57, 0x03, 0x00,
        0x27, 0x13, 0x01, 0x00, 0x00, 0xee, 0xee, 0x30, 0xb4, 0x18, 0x18, 0x26, 0x04, 0x95, 0x23, 0xa9,
        0x19, 0x26, 0x05, 0x15, 0xc1, 0xd2, 0x2c, 0x57, 0x06, 0x00, 0x27, 0x13, 0x01, 0x00, 0x00, 0xee,
        0xee, 0x30, 0xb4, 0x18, 0x18, 0x24, 0x07, 0x02, 0x24, 0x08, 0x15, 0x30, 0x0a, 0x31, 0x04, 0x78,
        0x52, 0xe2, 0x9c, 0x92, 0xba, 0x70, 0x19, 0x58, 0x46, 0x6d, 0xae, 0x18, 0x72, 0x4a, 0xfb, 0x43,
        0x0d, 0xf6, 0x07, 0x29, 0x33, 0x0d, 0x61, 0x55, 0xe5, 0x65, 0x46, 0x8e, 0xba, 0x0d, 0xa5, 0x3f,
        0xb5, 0x17, 0xc0, 0x47, 0x64, 0x44, 0x02, 0x18, 0x4f, 0xa8, 0x11, 0x24, 0x50, 0xd4, 0x7b, 0x35,
        0x83, 0x29, 0x01, 0x29, 0x02, 0x18, 0x35, 0x82, 0x29, 0x01, 0x24, 0x02, 0x60, 0x18, 0x35, 0x81,
        0x30, 0x02, 0x08, 0x42, 0x0c, 0xac, 0xf6, 0xb4, 0x64, 0x71, 0xe6, 0x18, 0x35, 0x80, 0x30, 0x02,
        0x08, 0x42, 0x0c, 0xac, 0xf6, 0xb4, 0x64, 0x71, 0xe6, 0x18, 0x35, 0x0c, 0x30, 0x01, 0x19, 0x00,
        0xbe, 0x0e, 0xda, 0xa1, 0x63, 0x5a, 0x8e, 0xf1, 0x52, 0x17, 0x45, 0x80, 0xbd, 0xdc, 0x94, 0x12,
        0xd4, 0xcc, 0x1c, 0x2c, 0x33, 0x4e, 0x29, 0xdc, 0x30, 0x02, 0x19, 0x00, 0x8b, 0xe7, 0xee, 0x2e,
        0x11, 0x17, 0x14, 0xae, 0x92, 0xda, 0x2b, 0x3b, 0x6d, 0x2f, 0xd7, 0x5d, 0x9e, 0x5f, 0xcd, 0xb8,
        0xba, 0x2f, 0x65, 0x76, 0x18, 0x18, 0x18, 0x35, 0x02, 0x27, 0x01, 0x01, 0x00, 0x00, 0x00, 0x02,
        0x30, 0xb4, 0x18, 0x36, 0x02, 0x15, 0x2c, 0x01, 0x22, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x64, 0x6f,
        0x6f, 0x72, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x6e,
        0x65, 0x73, 0x74, 0x6c, 0x61, 0x62, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x18, 0x18, 0x18, 0x18
    };

    ClearPersistedService();
    PersistNewService(0x18B4300100000001ULL, dummyAccountId, strlen(dummyAccountId), dummyServiceConfig, sizeof(dummyServiceConfig));
}

WEAVE_ERROR MockServiceProvisioningServer::HandleRegisterServicePairAccount(RegisterServicePairAccountMessage& msg)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    char ipAddrStr[64];
    mCurClientOp->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr));

    // NOTE: The arguments to HandleRegisterServicePairAccount() are temporary copies which
    // must be copied or discarded by the time the function returns.

    printf("RegisterServicePairAccount request received from node %" PRIX64 " (%s)\n", mCurClientOp->PeerNodeId, ipAddrStr);
    printf("  Service Id: %016" PRIX64 "\n", msg.ServiceId);
    printf("  Account Id: "); fwrite(msg.AccountId, 1, msg.AccountIdLen, stdout); printf("\n");
    printf("  Service Config (%d bytes): \n", (int)msg.ServiceConfigLen);
    DumpMemory(msg.ServiceConfig, msg.ServiceConfigLen, "    ", 16);
    printf("  Pairing Token (%d bytes): \n", (int)msg.PairingTokenLen);
    DumpMemory(msg.PairingToken, msg.PairingTokenLen, "    ", 16);
    printf("  Pairing Init Data (%d bytes): \n", (int)msg.PairingInitDataLen);
    DumpMemory(msg.PairingInitData, msg.PairingInitDataLen, "    ", 16);

    // Verify that the new service id does not match an existing service.
    //
    // Services cannot be re-registered; they must be updated or unregistered.
    if (mPersistedServiceId == msg.ServiceId)
    {
        SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_ServiceAlreadyRegistered);
        ExitNow();
    }

    // If we've reached the maximum number of provisioned services return a TooManyServices error.
    //
    // The Mock device only supports a single provisioned service. This will be true for Topaz 1.0 as well. However other
    // types of devices may support multiple provisioned services up to some limit.
    if (mPersistedServiceConfig != NULL)
    {
        SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_TooManyServices);
        ExitNow();
    }

    // Validate the service config. We don't want to get any further along before making sure the data is good.
    if (!ServiceProvisioningServer::IsValidServiceConfig(msg.ServiceConfig, msg.ServiceConfigLen))
    {
        SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_InvalidServiceConfig);
        ExitNow();
    }

    if (kPairingTransport_TCP == PairingTransport)
    {
        // At this point, the device must send a PairDeviceToAccount request to the service endpoint that handles
        // device pairing.  The process for doing this is roughly as follows...
        //
        //    1 - Use the directory endpoint address in the service config to connect and authenticate to the service's
        //        directory server.  Once connected, request the pairing service endpoint using the Directory Protocol.
        //
        //    2 - Connect and authenticate to the pairing server and issue a PairDeviceToAccount request containing:
        //           -- Account Id
        //           -- Device's Fabric Id
        //           -- Service Pairing Token
        //           -- Pairing Initialization Data
        //
        //    3 - Pairing service will respond with a StatusReport message indicating success or error. If an error is
        //        returned, the StatusReport is returned to the application that made the RegisterServicePairAccount
        //        request.
        //
        // NOTE that the steps above that require authentication will require the device to extract and use the service
        // CA certificates contained in the supplied service configuration data.

        // Initiate a connection to the configured pairing server.
        err = StartConnectToPairingServer();
        SuccessOrExit(err);
    }
    else if (kPairingTransport_WRM == PairingTransport)
    {
        err = PrepareBindingForPairingServer();
        SuccessOrExit(err);
    }
    else
    {
        err = WEAVE_ERROR_INCORRECT_STATE;
    }

exit:
    return err;
}

WEAVE_ERROR MockServiceProvisioningServer::PrepareBindingForPairingServer()
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    IPAddress endPointAddr;

    VerifyOrExit(IPAddress::FromString(PairingServerAddr, endPointAddr), err = WEAVE_ERROR_INVALID_ADDRESS);

    mPairingServerBinding = ExchangeMgr->NewBinding(HandlePairingServerBindingEvent, this);
    VerifyOrExit(mPairingServerBinding != NULL, err = WEAVE_ERROR_NO_MEMORY);

    // Prepare the binding. Will finish asynchronously.
    // TODO: [TT] PairingEndPointId appears to default to the local node id.
    //            Shouldn't it default to kServiceEndpoint_ServiceProvisioning instead,
    //            if this is how it's used?
    err = mPairingServerBinding->BeginConfiguration()
            .Target_NodeId(PairingEndPointId)
            .TargetAddress_IP(endPointAddr)
            .Transport_UDP_WRM()
            .Security_None()
            .PrepareBinding();
    SuccessOrExit(err);

exit:
    if (err != WEAVE_NO_ERROR)
    {
        if (mPairingServerBinding != NULL)
        {
            mPairingServerBinding->Release();
            mPairingServerBinding = NULL;
        }
    }
    return err;
}

void MockServiceProvisioningServer::HandlePairingServerBindingEvent(void *const appState,
                                                                    const nl::Weave::Binding::EventType event,
                                                                    const nl::Weave::Binding::InEventParam &inParam,
                                                                    nl::Weave::Binding::OutEventParam &outParam)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    WeaveDeviceDescriptor deviceDesc;
    uint8_t deviceInitData[256];
    uint32_t deviceInitDataLen;
    MockServiceProvisioningServer *server = (MockServiceProvisioningServer *) appState;

    // Retrieve the original RegisterServicePairAccount message from the client.
    RegisterServicePairAccountMessage &msg = server->mCurClientOpMsg.RegisterServicePairAccount;

    switch (event)
    {
    case nl::Weave::Binding::kEvent_BindingReady:
        printf("Pairing server binding ready\n");
        // Continues below.
        break;
    case nl::Weave::Binding::kEvent_PrepareFailed:
        printf("Pairing server binding prepare failed: %s\n", nl::ErrorStr(inParam.PrepareFailed.Reason));
        ExitNow(err = inParam.PrepareFailed.Reason);
        break;
    case nl::Weave::Binding::kEvent_BindingFailed:
        printf("Pairing server binding failed: %s\n", nl::ErrorStr(inParam.BindingFailed.Reason));
        ExitNow(err = inParam.BindingFailed.Reason);
        break;
    default:
        nl::Weave::Binding::DefaultEventHandler(appState, event, inParam, outParam);
        ExitNow(err = WEAVE_NO_ERROR);
        break;
    }

    printf("Sending WRM PairDeviceToAccount request to pairing server\n");

    // Encode device descriptor and send as device init data.
    gDeviceDescOptions.GetDeviceDesc(deviceDesc);
    WeaveDeviceDescriptor::EncodeTLV(deviceDesc, deviceInitData, sizeof(deviceInitData), deviceInitDataLen);

    // Send a PairDeviceToAccount request to the pairing server via WRM.
    err = server->SendPairDeviceToAccountRequest(server->mPairingServerBinding,
        msg.ServiceId, server->FabricState->FabricId,
        msg.AccountId, msg.AccountIdLen,
        msg.PairingToken, msg.PairingTokenLen,
        msg.PairingInitData, msg.PairingInitDataLen,
        deviceInitData, deviceInitDataLen);
    SuccessOrExit(err);

exit:
    if (err != WEAVE_NO_ERROR)
    {
        server->SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_PairingServerError, err);
        if (server->mPairingServerBinding != NULL)
        {
            server->mPairingServerBinding->Release();
            server->mPairingServerBinding = NULL;
        }
    }
}

WEAVE_ERROR MockServiceProvisioningServer::StartConnectToPairingServer()
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    WeaveConnection *con = NULL;
    IPAddress endPointAddr;

    printf("Initiating connection to pairing server at %s\n", PairingServerAddr);

    if (!IPAddress::FromString(PairingServerAddr, endPointAddr))
        ExitNow(err = WEAVE_ERROR_INVALID_ADDRESS);

    con = ExchangeMgr->MessageLayer->NewConnection();
    VerifyOrExit(con != NULL, err = WEAVE_ERROR_TOO_MANY_CONNECTIONS);

    con->AppState = this;
    con->OnConnectionComplete = HandlePairingServerConnectionComplete;
    con->OnConnectionClosed = HandlePairingServerConnectionClosed;

    // TODO: [TT] PairingEndPointId appears to default to the local node id.
    //            Shouldn't it default to kServiceEndpoint_ServiceProvisioning instead,
    //            if this is how it's used?
    err = con->Connect(PairingEndPointId, endPointAddr);
    SuccessOrExit(err);

    mPairingServerCon = con;
    con = NULL;

exit:
    if (con != NULL)
        con->Close();
    return err;
}

void MockServiceProvisioningServer::HandlePairingServerConnectionComplete(WeaveConnection *con, WEAVE_ERROR conErr)
{
    WEAVE_ERROR err;
    MockServiceProvisioningServer *server = (MockServiceProvisioningServer *) con->AppState;

    // If the connection failed, clean-up and deliver a failure back to the client.
    if (conErr != WEAVE_NO_ERROR)
    {
        printf("Connection to pairing server failed: %s\n", nl::ErrorStr(conErr));

        server->mPairingServerCon->Close();
        server->mPairingServerCon = NULL;
        server->SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_PairingServerError, conErr);
        return;
    }

    printf("Connection to pairing server established\n");

    // Retrieve the original RegisterServicePairAccount message from the client.
    RegisterServicePairAccountMessage &clientMsg = server->mCurClientOpMsg.RegisterServicePairAccount;

    printf("Sending TCP PairDeviceToAccount request to pairing server\n");

    // Encode device descriptor and send as device init data.
    WeaveDeviceDescriptor deviceDesc;
    gDeviceDescOptions.GetDeviceDesc(deviceDesc);
    uint8_t deviceInitData[256];
    uint32_t deviceInitDataLen;
    WeaveDeviceDescriptor::EncodeTLV(deviceDesc, deviceInitData, sizeof(deviceInitData), deviceInitDataLen);

    // Send a PairDeviceToAccount request to the pairing server.
    err = server->SendPairDeviceToAccountRequest(server->mPairingServerCon, clientMsg.ServiceId, server->FabricState->FabricId,
            clientMsg.AccountId, clientMsg.AccountIdLen,
            clientMsg.PairingToken, clientMsg.PairingTokenLen,
            clientMsg.PairingInitData, clientMsg.PairingInitDataLen,
            deviceInitData, deviceInitDataLen
            );

    if (err != WEAVE_NO_ERROR)
    {
        server->mPairingServerCon->Close();
        server->mPairingServerCon = NULL;
        server->SendStatusReport(kWeaveProfile_Common, Common::kStatus_InternalError, err);
        return;
    }
}

void MockServiceProvisioningServer::HandlePairDeviceToAccountResult(WEAVE_ERROR err, uint32_t serverStatusProfileId, uint16_t serverStatusCode)
{
    if (mPairingServerCon)
    {
        // The server operation is now complete so close the connection.
        mPairingServerCon->Close();
        mPairingServerCon = NULL;
    }
    else if (mPairingServerBinding)
    {
        // The server operation is now complete, so release the binding.
        mPairingServerBinding->Release();
        mPairingServerBinding = NULL;
    }

    // If the PairDeviceToAccount request was successful...
    if (err == WEAVE_NO_ERROR)
    {
        printf("Received success response from pairing server\n");

        // Retrieve the original RegisterServicePairAccount message from the client.
        RegisterServicePairAccountMessage &clientMsg = mCurClientOpMsg.RegisterServicePairAccount;

        // Save the service information in device persistent storage.
        // (On the mock device we merely store it in memory).
        //
        err = PersistNewService(clientMsg.ServiceId, clientMsg.AccountId, clientMsg.AccountIdLen, clientMsg.ServiceConfig, clientMsg.ServiceConfigLen);
        if (err != WEAVE_NO_ERROR)
        {
            SendStatusReport(kWeaveProfile_Common, Common::kStatus_InternalError, err);
            return;
        }

        SendSuccessResponse();
    }

    // Otherwwise, relay the result from the pairing server back to the client.
    else if (err == WEAVE_ERROR_STATUS_REPORT_RECEIVED)
    {
        printf("Received StatusReport from pairing server: %s\n", nl::StatusReportStr(serverStatusProfileId, serverStatusCode));
        SendStatusReport(serverStatusProfileId, serverStatusCode, WEAVE_NO_ERROR);
    }
    else
    {
        printf("Error talking to pairing server: %s\n", nl::ErrorStr(err));
        SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_PairingServerError, err);
    }
}

void MockServiceProvisioningServer::EnforceAccessControl(nl::Weave::ExchangeContext *ec, uint32_t msgProfileId, uint8_t msgType,
            const nl::Weave::WeaveMessageInfo *msgInfo, AccessControlResult& result)
{
    if (sSuppressAccessControls)
    {
        result = kAccessControlResult_Accepted;
    }

    ServiceProvisioningDelegate::EnforceAccessControl(ec, msgProfileId, msgType, msgInfo, result);
}

bool MockServiceProvisioningServer::IsPairedToAccount() const
{
    return (gCASEOptions.ServiceConfig != NULL);
}

void MockServiceProvisioningServer::HandlePairingServerConnectionClosed(WeaveConnection *con, WEAVE_ERROR conErr)
{
    MockServiceProvisioningServer *server = (MockServiceProvisioningServer *) con->AppState;
    if (server->mPairingServerCon != NULL)
    {
        server->mPairingServerCon->Close();
        server->mPairingServerCon = NULL;
    }
}

WEAVE_ERROR MockServiceProvisioningServer::HandleUpdateService(UpdateServiceMessage& msg)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    char ipAddrStr[64];
    mCurClientOp->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr));

    // NOTE: The arguments to HandleUpdateService() are temporary copies which
    // must be copied or discarded by the time the function returns.

    printf("UpdateService request received from node %" PRIX64 " (%s)\n", mCurClientOp->PeerNodeId, ipAddrStr);
    printf("  Service Id: %016" PRIX64 "\n", msg.ServiceId);
    printf("  Service Config (%d bytes): \n", (int)msg.ServiceConfigLen);
    DumpMemory(msg.ServiceConfig, msg.ServiceConfigLen, "    ", 16);

    // Verify that the service id matches an existing service.
    //
    if (mPersistedServiceId != msg.ServiceId)
    {
        SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_NoSuchService);
        ExitNow();
    }

    // Validate the service config. We don't want to get any further along before making sure the data is good.
    if (!ServiceProvisioningServer::IsValidServiceConfig(msg.ServiceConfig, msg.ServiceConfigLen))
    {
        SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_InvalidServiceConfig);
        ExitNow();
    }

    // Save the new service configuration in device persistent storage, replacing the existing value.
    // (On the mock device we merely store it in memory).
    err = UpdatedPersistedService(msg.ServiceConfig, msg.ServiceConfigLen);
    SuccessOrExit(err);

    // Send a success StatusReport back to the requestor.
    err = SendSuccessResponse();
    SuccessOrExit(err);

exit:
    return err;
}

WEAVE_ERROR MockServiceProvisioningServer::HandleUnregisterService(uint64_t serviceId)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    char ipAddrStr[64];
    mCurClientOp->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr));

    printf("UnregisterService request received from node %" PRIX64 " (%s)\n", mCurClientOp->PeerNodeId, ipAddrStr);
    printf("  Service Id: %016" PRIX64 "\n", serviceId);

    // Verify that the service id matches an existing service.
    //
    if (mPersistedServiceId != serviceId)
    {
        SendStatusReport(kWeaveProfile_ServiceProvisioning, kStatusCode_NoSuchService);
        ExitNow();
    }

    // Clear the persisted service.
    ClearPersistedService();

    // Send a success StatusReport back to the requestor.
    err = SendSuccessResponse();
    SuccessOrExit(err);

exit:
    return err;
}

WEAVE_ERROR MockServiceProvisioningServer::PersistNewService(uint64_t serviceId,
                                                             const char *accountId, uint16_t accountIdLen,
                                                             const uint8_t *serviceConfig, uint16_t serviceConfigLen)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    char *accountIdCopy = NULL;
    uint8_t *serviceConfigCopy = NULL;

    accountIdCopy = (char *)malloc(accountIdLen + 1);
    VerifyOrExit(accountIdCopy != NULL, err = WEAVE_ERROR_NO_MEMORY);
    memcpy(accountIdCopy, accountId, accountIdLen);
    accountIdCopy[accountIdLen] = 0;

    serviceConfigCopy = (uint8_t *)malloc(serviceConfigLen);
    VerifyOrExit(serviceConfigCopy != NULL, err = WEAVE_ERROR_NO_MEMORY);
    memcpy(serviceConfigCopy, serviceConfig, serviceConfigLen);

    mPersistedServiceId = serviceId;
    mPersistedAccountId = accountIdCopy;
    mPersistedServiceConfig = serviceConfigCopy;
    mPersistedServiceConfigLen = serviceConfigLen;

    // Setup to use service config in subsequence CASE sessions.
    gCASEOptions.ServiceConfig = mPersistedServiceConfig;
    gCASEOptions.ServiceConfigLength = mPersistedServiceConfigLen;

exit:
    if (err != WEAVE_NO_ERROR)
    {
        if (accountIdCopy != NULL)
            free(accountIdCopy);
        if (serviceConfigCopy != NULL)
            free(serviceConfigCopy);
    }
    return err;
}

WEAVE_ERROR MockServiceProvisioningServer::UpdatedPersistedService(const uint8_t *serviceConfig, uint16_t serviceConfigLen)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    uint8_t *serviceConfigCopy = NULL;

    serviceConfigCopy = (uint8_t *)malloc(serviceConfigLen);
    VerifyOrExit(serviceConfigCopy != NULL, err = WEAVE_ERROR_NO_MEMORY);
    memcpy(serviceConfigCopy, serviceConfig, serviceConfigLen);

    free(mPersistedServiceConfig);
    mPersistedServiceConfig = serviceConfigCopy;
    mPersistedServiceConfigLen = serviceConfigLen;

    // Setup to use service config in subsequence CASE sessions.
    gCASEOptions.ServiceConfig = mPersistedServiceConfig;
    gCASEOptions.ServiceConfigLength = mPersistedServiceConfigLen;

exit:
    if (err != WEAVE_NO_ERROR && serviceConfigCopy != NULL)
        free(serviceConfigCopy);
    return err;
}

void MockServiceProvisioningServer::ClearPersistedService()
{
    mPersistedServiceId = 0;
    if (mPersistedAccountId != NULL)
    {
        free(mPersistedAccountId);
        mPersistedAccountId = NULL;
    }
    if (mPersistedServiceConfig != NULL)
    {
        free(mPersistedServiceConfig);
        mPersistedServiceConfig = NULL;
    }
    mPersistedServiceConfigLen = 0;

    gCASEOptions.ServiceConfig = NULL;
    gCASEOptions.ServiceConfigLength = 0;
}

WEAVE_ERROR MockServiceProvisioningServer::SendStatusReport(uint32_t statusProfileId, uint16_t statusCode, WEAVE_ERROR sysError)
{
    if (statusProfileId == kWeaveProfile_Common && statusCode == Common::kStatus_Success)
        printf("Sending StatusReport: Success\n");
    else
    {
        printf("Sending StatusReport: %s\n", nl::StatusReportStr(statusProfileId, statusCode));
        if (sysError != WEAVE_NO_ERROR)
            printf("   System error: %s\n", nl::ErrorStr(sysError));
    }
    return this->ServiceProvisioningServer::SendStatusReport(statusProfileId, statusCode, sysError);
}