daemon/Registry/Registry.cpp

/** Mobicore Driver Registry Interface
 *
 * Implements the MobiCore registry interface for the ROOT-PA
 *
 * @file
 * @ingroup MCD_MCDIMPL_DAEMON_REG
 */

/* <!-- Copyright Giesecke & Devrient GmbH 2009 - 2012 -->
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdlib.h>
#include <dirent.h>
#include <stdio.h>
#include <sys/stat.h>
#include <assert.h>
#include <string>
#include <cstring>
#include <cstddef>
#include "mcLoadFormat.h"
#include "mcSpid.h"
#include "mcVersionHelper.h"

#include "log.h"

#include "MobiCoreRegistry.h"
#include "MobiCoreDriverCmd.h"

#include "Connection.h"

#define DAEMON_TIMEOUT 30

using namespace std;


static mcResult_t writeBlobData(void *buff, uint32_t len)
{
    Connection con;
    mcDrvResponseHeader_t rsp = { responseId : MC_DRV_ERR_INVALID_PARAMETER };
    if (!con.connect(SOCK_PATH)) {
        LOG_E("Failed to connect to daemon!");
        return MC_DRV_ERR_DAEMON_SOCKET;
    }

    if (con.writeData(buff, len) <= 0) {
        LOG_E("Failed to send daemon to data!");
        return MC_DRV_ERR_DAEMON_SOCKET;
    }

    if (con.readData(&rsp, sizeof(rsp), DAEMON_TIMEOUT) <= 0) {
        LOG_E("Failed to get answer from daemon!");
        return MC_DRV_ERR_DAEMON_SOCKET;
    }

    return rsp.responseId;
}

static mcResult_t readBlobData(void *buff, uint32_t len, void *rbuff, uint32_t *rlen)
{
    Connection con;
    int32_t size;
    mcDrvResponseHeader_t rsp = { responseId : MC_DRV_ERR_INVALID_PARAMETER };
    if (*rlen == 0) {
        LOG_E("Invalid buffer length!");
        return MC_DRV_ERR_DAEMON_SOCKET;
    }
    
    if (!con.connect(SOCK_PATH)) {
        LOG_E("Failed to connect to daemon!");
        return MC_DRV_ERR_DAEMON_SOCKET;
    }

    if (con.writeData(buff, len) <= 0) {
        LOG_E("Failed to send daemon to data!");
        return MC_DRV_ERR_DAEMON_SOCKET;
    }

    // First read the response
    if (con.readData(&rsp, sizeof(rsp), DAEMON_TIMEOUT) <= 0) {
        LOG_E("Failed to get answer from daemon!");
        return MC_DRV_ERR_DAEMON_SOCKET;
    }

    //Then read the actual data
    size = con.readData(rbuff, *rlen, DAEMON_TIMEOUT);
    if(size <= 0) {
        LOG_E("Failed to get answer from daemon!");
        return MC_DRV_ERR_DAEMON_SOCKET;
    }
    // Return also the read buf size
    *rlen = (uint32_t)size;

    return rsp.responseId;
}

//------------------------------------------------------------------------------
mcResult_t mcRegistryStoreAuthToken(void *so, uint32_t size)
{
    typedef struct {
        uint32_t commandId;
        uint32_t soSize;
        uint8_t so;
    } storeCmd;

    mcResult_t ret;
    storeCmd *cmd = (storeCmd*)malloc(sizeof(storeCmd) + size - 1);

    cmd->commandId = MC_DRV_REG_STORE_AUTH_TOKEN;
    cmd->soSize = size;
    memcpy(&cmd->so, so, size);
    ret = writeBlobData(cmd, sizeof(storeCmd) + size - 1);
    free(cmd);
    return ret;
}


//------------------------------------------------------------------------------
mcResult_t mcRegistryReadAuthToken(void *so, uint32_t *size)
{
    mcDrvCommandHeader_t cmd = { commandId : MC_DRV_REG_READ_AUTH_TOKEN };
    uint32_t rsize;
    mcResult_t ret;
    // we expect to max read what the user has allocated
    rsize = *size;
    ret = readBlobData(&cmd, sizeof(cmd), so, &rsize);
    // return the actual read size
    *size = rsize;
    return ret;
}

//------------------------------------------------------------------------------
mcResult_t mcRegistryDeleteAuthToken(void)
{
    mcDrvCommandHeader_t cmd = { commandId : MC_DRV_REG_DELETE_AUTH_TOKEN };
    return writeBlobData(&cmd, sizeof(cmd));
}


//------------------------------------------------------------------------------
mcResult_t mcRegistryStoreRoot(void *so, uint32_t size)
{
    typedef struct {
        uint32_t commandId;
        uint32_t soSize;
        uint8_t so;
    } storeCmd;
    mcResult_t ret;
    storeCmd *cmd = (storeCmd*)malloc(sizeof(storeCmd) + size - 1);

    cmd->commandId = MC_DRV_REG_WRITE_ROOT_CONT;
    cmd->soSize = size;
    memcpy(&cmd->so, so, size);
    ret = writeBlobData(cmd, sizeof(storeCmd) + size - 1);
    free(cmd);
    return ret;
}


//------------------------------------------------------------------------------
mcResult_t mcRegistryReadRoot(void *so, uint32_t *size)
{
    mcDrvCommandHeader_t cmd = { commandId : MC_DRV_REG_READ_ROOT_CONT };
    uint32_t rsize;
    mcResult_t ret;

    rsize = *size;
    ret = readBlobData(&cmd, sizeof(cmd), so, &rsize);
    *size = rsize;
    return ret;
}

//------------------------------------------------------------------------------
mcResult_t mcRegistryCleanupRoot(void)
{
    mcDrvCommandHeader_t cmd = { commandId : MC_DRV_REG_DELETE_ROOT_CONT };
    return writeBlobData(&cmd, sizeof(cmd));
}

//------------------------------------------------------------------------------
mcResult_t mcRegistryStoreSp(mcSpid_t spid, void *so, uint32_t size)
{
    typedef struct {
        uint32_t commandId;
        uint32_t soSize;
        mcSpid_t spid;
        uint8_t so;
    } storeCmd;
    
    mcResult_t ret;
    storeCmd *cmd = (storeCmd*)malloc(sizeof(storeCmd) + size - 1);

    cmd->commandId = MC_DRV_REG_WRITE_SP_CONT;
    cmd->soSize = size;
    cmd->spid = spid;
    memcpy(&cmd->so, so, size);

    ret = writeBlobData(cmd, sizeof(storeCmd) + size - 1);
    free(cmd);
    return ret; 
}


//------------------------------------------------------------------------------
mcResult_t mcRegistryReadSp(mcSpid_t spid, void *so, uint32_t *size)
{
    struct {
        uint32_t commandId;
        mcSpid_t spid;
    } cmd;
    uint32_t rsize;
    mcResult_t ret;
    cmd.commandId = MC_DRV_REG_READ_SP_CONT;
    cmd.spid = spid;

    rsize = *size;
    ret = readBlobData(&cmd, sizeof(cmd), so, &rsize);
    *size = rsize;

    return ret;
}

//------------------------------------------------------------------------------
mcResult_t mcRegistryCleanupSp(mcSpid_t spid)
{
    struct {
        uint32_t commandId;
        mcSpid_t spid;
    } cmd;

    cmd.commandId = MC_DRV_REG_DELETE_SP_CONT;
    cmd.spid = spid;

    return writeBlobData(&cmd, sizeof(cmd));
}

//------------------------------------------------------------------------------
mcResult_t mcRegistryStoreTrustletCon(const mcUuid_t *uuid, void *so, uint32_t size)
{
    typedef struct {
        uint32_t commandId;
        uint32_t soSize;
        mcUuid_t uuid;
        uint8_t so;
    } storeCmd;

    mcResult_t ret;
    storeCmd *cmd = (storeCmd*)malloc(sizeof(storeCmd) + size - 1);
    
    cmd->commandId = MC_DRV_REG_WRITE_TL_CONT;
    cmd->soSize = size;
    memcpy(&cmd->uuid, uuid, sizeof(mcUuid_t));
    memcpy(&cmd->so, so, size);

    ret = writeBlobData(cmd, sizeof(storeCmd) + size - 1);
    free(cmd);
    return ret;
}


//------------------------------------------------------------------------------
mcResult_t mcRegistryReadTrustletCon(const mcUuid_t *uuid, void *so, uint32_t *size)
{
    struct {
        uint32_t commandId;
        mcUuid_t uuid;
    } cmd;
    mcResult_t ret;
    uint32_t rsize;
    cmd.commandId = MC_DRV_REG_READ_TL_CONT;
    memcpy(&cmd.uuid, uuid, sizeof(mcUuid_t));

    rsize = *size;
    ret = readBlobData(&cmd, sizeof(cmd), so, &rsize);
    *size = rsize;
    return ret;
}

//------------------------------------------------------------------------------
mcResult_t mcRegistryCleanupTrustlet(const mcUuid_t *uuid)
{
    struct {
        uint32_t commandId;
        mcUuid_t uuid;
    } cmd;

    cmd.commandId = MC_DRV_REG_DELETE_TL_CONT;
    memcpy(&cmd.uuid, uuid, sizeof(mcUuid_t));

    return writeBlobData(&cmd, sizeof(cmd));
}

//------------------------------------------------------------------------------
mcResult_t mcRegistryStoreData(void *so, uint32_t size)
{
    typedef struct {
        uint32_t commandId;
        uint32_t soSize;
        uint8_t so;
    } storeCmd;

    mcResult_t ret;
    storeCmd *cmd = (storeCmd*)malloc(sizeof(storeCmd) + size - 1);

    cmd->commandId = MC_DRV_REG_WRITE_SO_DATA;
    cmd->soSize = size;
    memcpy(&cmd->so, so, size);

    ret = writeBlobData(cmd, sizeof(storeCmd) + size - 1);
    free(cmd);
    return ret;
}


//------------------------------------------------------------------------------
mcResult_t mcRegistryReadData(uint32_t context, const mcCid_t *cid, mcPid_t pid,
    mcSoDataCont_t *so, uint32_t maxLen)
{
    return MC_DRV_ERR_INVALID_PARAMETER;
}

/** @} */