usocutils.c

Go to the documentation of this file.

#include <string.h>

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

enum HIPC_errno
hipcUsocWriteMsgd(struct HIPC_usoc *const so_p,
                  hipc_msgd const *const md_p)
{
    enum HIPC_errno retval;

    retval = hipcUsocWrite(so_p, hipcMsgdHdrPtr(md_p), HIPC_MSGHDR_SIZE);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval =
        hipcUsocWrite(so_p, hipcMsgdBdyPtr(md_p), hipcMsgdBdySize(md_p));
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    return HIPC_SUCCESS;
}

static enum HIPC_errno
hipcUsocSendSysmsg(struct HIPC_usoc *const so_p,
                   const struct HIPC_scfg *const cfg_p)
{
    enum HIPC_errno retval;
    unsigned int i;

    for (i = 0; i < (cfg_p)->n_sysmsg; ++i) {
        retval = hipcUsocWrite(so_p,
                               (cfg_p)->sysmsg_p[i].ptr,
                               (cfg_p)->sysmsg_p[i].size);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
    }

    return HIPC_SUCCESS;
}

enum HIPC_errno
hipcUsocAccept(struct HIPC_usoc *const so_p,
               const struct HIPC_scfg * *const cfg_pp,
               const struct HIPC_scfg *const *const cfg_ary,
               const unsigned int n_cfg,
               unsigned char *const buf, const size_t buf_size)
{
    enum HIPC_errno retval;
    unsigned char body_size;
    unsigned int i;

    *cfg_pp = NULL;

    if (NULL == cfg_ary) {
        return HIPC_ERR_S_INV_NULL;
    }

    /* receive cfgid */
    if (HIPC_MSGHDR_SIZE > buf_size) {
        return HIPC_ERR_S_BUF_SHTG;
    }
    retval = hipcUsocRead(so_p, buf, HIPC_MSGHDR_SIZE);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    body_size = hipcMsghdrBdysize(buf);
    if ((HIPC_MSGHDR_SIZE + (size_t) body_size) > buf_size) {
        return HIPC_ERR_S_BUF_SHTG;
    }
    retval = hipcUsocRead(so_p, buf + HIPC_MSGHDR_SIZE, body_size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    /* find cfgid */
    for (i = 0; i < n_cfg; ++i) {
        if (NULL == cfg_ary[i]) {
            return HIPC_ERR_S_INV_NULL;
        }
        if (0 != memcmp(cfg_ary[i]->cfgid_header, buf, HIPC_MSGHDR_SIZE)) {
            continue;
        }
        if (0 ==
            memcmp(cfg_ary[i]->cfgid, buf + HIPC_MSGHDR_SIZE, body_size)) {
            *cfg_pp = cfg_ary[i];
            break;
        }
    }
    if (NULL == *cfg_pp) {
        return HIPC_ERR_S_INV_CFG;
    }

    hipcScfgInit(*cfg_pp);
    retval = hipcUsocSendSysmsg(so_p, *cfg_pp);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    return hipcScfgCheckStrusize(*cfg_pp);
}

enum HIPC_errno
hipcUsocAcceptSimple(struct HIPC_usoc *const so_p,
                     const struct HIPC_scfg *const cfg_p)
{
    enum HIPC_errno retval;
    unsigned char body_size;
    unsigned char c;
    unsigned char i;

    if (NULL == cfg_p) {
        return HIPC_ERR_S_INV_NULL;
    }

    for (i = 0; i < HIPC_MSGHDR_SIZE; ++i) {
        retval = hipcUsocRead(so_p, &c, 1);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        if (cfg_p->cfgid_header[i] != c) {
            return HIPC_ERR_S_INV_CFG;
        }
    }

    body_size = hipcMsghdrBdysize(cfg_p->cfgid_header);
    for (i = 0; i < body_size; ++i) {
        retval = hipcUsocRead(so_p, &c, 1);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        if (cfg_p->cfgid[i] != c) {
            return HIPC_ERR_S_INV_CFG;
        }
    }

    hipcScfgInit(cfg_p);
    retval = hipcUsocSendSysmsg(so_p, cfg_p);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    return hipcScfgCheckStrusize(cfg_p);
}