hipcsvs_rt.c

Go to the documentation of this file.

#include <string.h>

#include <hipc/scfg.h>
#include <hipc/usoc.h>
#include <hipc/usocutils.h>

#include "CFGrt.h"
#include "CFGrt_scfg.h"
#include "hipcsvs_rt.h"

#define PBANK_PAGE_SIZE sizeof(struct STRUprm)
#define QUEUE_ITEM_SIZE sizeof(struct STRUlog)
#define QUEUE_N_SLOT 4

struct HIPC_pbank hipcsvsRt_pbank;
struct HIPC_queue hipcsvsRt_queue;

void hipcsvsRtInit(void)
{
    static struct STRUprm bufprm[2];
    static struct STRUlog buflog[QUEUE_N_SLOT];

    bufprm[0].size = 0;
    hipcPbankInit(&hipcsvsRt_pbank, bufprm, PBANK_PAGE_SIZE);

    hipcQueueInit(&hipcsvsRt_queue, buflog, QUEUE_ITEM_SIZE,
                  QUEUE_N_SLOT);

    return;
}

static enum HIPC_errno send_cast(struct HIPC_usoc *const so_p)
{
    enum HIPC_errno retval;
    const struct STRUlog *log_p;
    struct HIPC_queue *const queue_p = &hipcsvsRt_queue;
    static const unsigned char loghdr[HIPC_MSGHDR_SIZE] = {
        HIPC_MESSAGE_TYPE_CAST, HIPCUD_STRUlog, 0, QUEUE_ITEM_SIZE
    };

    retval = HIPC_SUCCESS;

    log_p = hipcQueueEmpty(queue_p);
    if (NULL != log_p) {
        retval = hipcUsocWrite(so_p, loghdr, HIPC_MSGHDR_SIZE);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        retval = hipcUsocWrite(so_p, log_p, QUEUE_ITEM_SIZE);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        hipcQueuePop(queue_p);
    }
    return retval;
}

enum HIPC_errno hipcsvsRtRun(struct HIPC_usoc *const so_p,
                             hipc_msgd * const mdq_p)
{
    hipc_msgd mdR;
    hipc_msgd mdS;
    enum HIPC_errno retval;
    struct HIPC_pbank *const pbank_p = &hipcsvsRt_pbank;
    struct STRUprm *prm_p;
    int rready;
    uint8_t i;

    for (;;) {
        do {
            rready = hipcUsocReadReady(so_p);
            if (-1 == rready) {
                return hipcGenmdQuit(mdq_p, HIPC_ERR_S_IO_READ, "Ready");
            }
            if (0 == rready) {
                retval = send_cast(so_p);
                if (HIPC_SUCCESS != retval) {
                    return hipcGenmdQuit(mdq_p, retval, "CAST0");
                }
            }
        } while (0 == rready);

        retval =
            hipcUsocRead(so_p, hipcMsgdHdrPtr(&mdR), HIPC_MSGHDR_SIZE);
        if (HIPC_SUCCESS != retval) {
            return hipcGenmdQuit(mdq_p, retval, "Header");
        }

        switch (hipcMsgdType(&mdR)) {
        case HIPC_MESSAGE_TYPE_BYE:
            return hipcGenmdQuit(mdq_p, HIPC_SUCCESS, NULL);
        case HIPC_MESSAGE_TYPE_GET:
            if (HIPCUD_STRUprm != hipcMsgdStruno(&mdR)) {
                return hipcGenmdQuit(mdq_p, HIPC_ERR_S_INV_STRUNO,
                                     "GETc0");
            }
            if (HIPC_PBANK_STAT_GROUND != hipcPbankGetStat(pbank_p)) {
                return hipcGenmdQuit(mdq_p, HIPC_ERR_S_PBANK_STAT_MISMATCH,
                                     "GETc1");
            }
            retval =
                hipcGenmdSuccessToGet(&mdS, &mdR,
                                      hipcPbankGetWritablePage(pbank_p),
                                      PBANK_PAGE_SIZE);
            if (HIPC_SUCCESS != retval) {
                return hipcGenmdQuit(mdq_p, retval, "GETr");
            }
            break;
        case HIPC_MESSAGE_TYPE_PUT:
            if (HIPCUD_STRUprm != hipcMsgdStruno(&mdR)) {
                return hipcGenmdQuit(mdq_p, HIPC_ERR_S_INV_STRUNO,
                                     "PUTc0");
            }
            if (HIPC_PBANK_STAT_GROUND != hipcPbankGetStat(pbank_p)) {
                return hipcGenmdQuit(mdq_p, HIPC_ERR_S_PBANK_STAT_MISMATCH,
                                     "PUTc1");
            }

            prm_p = hipcPbankGetWritablePage(pbank_p);
            retval = hipcMsgdSetBdyForPut(&mdR, prm_p, PBANK_PAGE_SIZE);
            if (HIPC_SUCCESS != retval) {
                return hipcGenmdQuit(mdq_p, retval, "PUTs");
            }
            retval = hipcUsocRead(so_p, hipcMsgdBdyPtr(&mdR),
                                  hipcMsgdBdySize(&mdR));
            if (HIPC_SUCCESS != retval) {
                return hipcGenmdQuit(mdq_p, retval, "PUTb");
            }

            if (PTRN_SIZE_MAX < prm_p->size) {
                return hipcGenmdQuit(mdq_p, HIPC_ERR_S_INV_UDATA,
                                     "PTRN_SIZE_MAX");
            }
            for (i = 0; i < prm_p->size; ++i) {
                if (1 < prm_p->pattern[i]) {
                    return hipcGenmdQuit(mdq_p, HIPC_ERR_S_INV_UDATA,
                                         "1 < prm_p->pattern[i]");
                }
            }

            retval = hipcPbankSwitchRequest(pbank_p);
            if (HIPC_SUCCESS != retval) {
                return hipcGenmdQuit(mdq_p, retval, "pbank0");
            }
            while (HIPC_PBANK_STAT_REQUESTED == hipcPbankGetStat(pbank_p)) {
                retval = send_cast(so_p);
                if (HIPC_SUCCESS != retval) {
                    return hipcGenmdQuit(mdq_p, retval, "CAST1");
                }
            }
            retval = hipcPbankSwitchComplete(pbank_p);
            if (HIPC_SUCCESS != retval) {
                return hipcGenmdQuit(mdq_p, retval, "pbank1");
            }

            hipcGenmdSuccess(&mdS);
            break;
        default:
            return hipcGenmdQuit(mdq_p, HIPC_ERR_S_INV_MSG_TYPE, NULL);
        }
        retval = hipcUsocWriteMsgd(so_p, &mdS);
        if (HIPC_SUCCESS != retval) {
            return hipcGenmdQuit(mdq_p, retval, "RESP");
        }
    }
}

void hipcMain(struct HIPC_usoc *const so_p)
{
    hipc_msgd mdQ;
    enum HIPC_errno retval;

    hipcGenmdQuit(&mdQ, HIPC_ERR_S_V_UNINIT_MSG, NULL);

    retval = hipcUsocAcceptSimple(so_p, &HIPCUD_CFGrt_SCFG);
    if (HIPC_SUCCESS != retval) {
        hipcGenmdQuit(&mdQ, retval, "Failed to accept");
    } else {
        retval = hipcsvsRtRun(so_p, &mdQ);
    }

    if ((HIPC_ERR_S_IO_READ != retval) && (HIPC_ERR_S_IO_WRITE != retval)) {
        hipcUsocWriteMsgd(so_p, &mdQ);
    }

    return;
}