client.c

Go to the documentation of this file.

#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <hipc/client.h>

static const char *hipc_errstr[HIPC_N_ERR] = {
    "HIPC_SUCCESS: No error",

    "HIPC_ERR_S_INV_UDATA: Invalid user data",
    "HIPC_ERR_S_INV_MSG_TYPE: Invalid message type",
    "HIPC_ERR_S_INV_STRUNO: Invalid structure number",
    "HIPC_ERR_S_INV_RW_RANGE: Invalid read/write range",
    "HIPC_ERR_S_V_UNINIT_MSG: Virtually uninitialized HIPC message",
    "HIPC_ERR_S_IO_READ: I/O read error",
    "HIPC_ERR_S_IO_WRITE: I/O write error",
    "HIPC_ERR_S_INV_CFG: Invalid Configuration",
    "HIPC_ERR_S_INV_NULL: Invalid NULL value",
    "HIPC_ERR_S_BUF_SHTG: Buffer shortage",
    "HIPC_ERR_S_OVERSIZED_STRU: Oversized structure size",
    "HIPC_ERR_S_PBANK_STAT_MISMATCH: pbank status mismatch",

    "HIPC_ERR_C_STD: C standard library error",
    "HIPC_ERR_INTERNAL_ERROR: Internal error in HIPC library",
    "HIPC_ERR_IO_READ: I/O read error",
    "HIPC_ERR_IO_WRITE: I/O write error",
    "HIPC_ERR_PROTOCOL_VIOLATION: Protocol violation",
    "HIPC_ERR_INV_ENDIAN: Invalid endian",
    "HIPC_ERR_INV_ID_STR: Invalid ID string",
    "HIPC_ERR_INV_BASE_CLIENT: Invalid base client",
    "HIPC_ERR_MBR_SIZE_MISMATCH: Structure member size mismatch",
    "HIPC_ERR_SESS_STATE_MISMATCH: Session state mismatch",

    "HIPC_ERR_FOR_TESTING: Error only for testing",
    "HIPC_ERR_TEST_LIB_INTERNAL: Internal error in a library only for testing",
};

static void *hipcClientMalloc(struct HIPC_client *const cl_p, size_t size)
{
    struct HIPC_ptr_link_list *pllist_p;
    void *tmp_p;

    tmp_p = malloc(size);
    if (NULL == tmp_p) {
        cl_p->std_errno = errno;
        cl_p->hipc_errno = HIPC_ERR_C_STD;
        return NULL;
    }

    pllist_p = malloc(sizeof(struct HIPC_ptr_link_list));
    if (NULL == pllist_p) {
        cl_p->std_errno = errno;
        cl_p->hipc_errno = HIPC_ERR_C_STD;
        return NULL;
    }

    pllist_p->ptr = tmp_p;
    pllist_p->next = cl_p->pllist_p;
    cl_p->pllist_p = pllist_p;

    return tmp_p;
}

static void *hipcClientCalloc(struct HIPC_client *const cl_p, size_t nmemb,
                              size_t size)
{
    struct HIPC_ptr_link_list *pllist_p;
    void *tmp_p;

    tmp_p = calloc(nmemb, size);
    if (NULL == tmp_p) {
        cl_p->std_errno = errno;
        cl_p->hipc_errno = HIPC_ERR_C_STD;
        return NULL;
    }

    pllist_p = malloc(sizeof(struct HIPC_ptr_link_list));
    if (NULL == pllist_p) {
        cl_p->std_errno = errno;
        cl_p->hipc_errno = HIPC_ERR_C_STD;
        return NULL;
    }

    pllist_p->ptr = tmp_p;
    pllist_p->next = cl_p->pllist_p;
    cl_p->pllist_p = pllist_p;

    return tmp_p;
}

void hipcClientSetStdErrno(struct HIPC_client *const cl_p)
{
    cl_p->std_errno = errno;
    return;
}

int hipcClientGetStdErrno(const struct HIPC_client *const cl_p)
{
    return cl_p->std_errno;
}

enum HIPC_errno
hipcClientGetHipcErrno(const struct HIPC_client *const cl_p)
{
    return cl_p->hipc_errno;
}

const char *hipcClientGetErrStr(const struct HIPC_client *const cl_p)
{
    if (0 <= cl_p->hipc_errno && HIPC_N_ERR > cl_p->hipc_errno) {
        return hipc_errstr[cl_p->hipc_errno];
    } else {
        return "Unknown HIPC errorno value";
    }
}

const char *hipcClientGetErrDtlStr(const struct HIPC_client *const cl_p)
{
    return cl_p->err_detail_str;
}

static void
hipcClientSetErrDtlStr(struct HIPC_client *const cl_p,
                       char const *const str0,
                       char const *const str1, size_t ls1)
{
    size_t ls0;

    if (NULL == str0) {
        return;
    }

    ls0 = strlen(str0);

    if (ls0 >= sizeof(cl_p->err_detail_str)) {
        memcpy(cl_p->err_detail_str, str0,
               sizeof(cl_p->err_detail_str) - 1);
        cl_p->err_detail_str[sizeof(cl_p->err_detail_str) - 1] = '\0';
    } else {
        memcpy(cl_p->err_detail_str, str0, ls0 + 1);
        if (NULL != str1) {
            if (0 == ls1) {
                ls1 = strlen(str1);
            }
            if (ls0 + ls1 >= sizeof(cl_p->err_detail_str)) {
                memcpy(cl_p->err_detail_str + ls0,
                       str1, sizeof(cl_p->err_detail_str) - ls0 - 1);
                cl_p->err_detail_str[sizeof(cl_p->err_detail_str) - 1] =
                    '\0';
            } else {
                memcpy(cl_p->err_detail_str + ls0, str1, ls1);
                cl_p->err_detail_str[ls0 + ls1] = '\0';
            }
        }
    }
    return;
}

enum HIPC_errno hipcClientSetError(struct HIPC_client *const cl_p,
                                   enum HIPC_errno hipc_errno,
                                   char const *const str)
{
    cl_p->hipc_errno = hipc_errno;
    hipcClientSetErrDtlStr(cl_p, str, NULL, 0);

    return hipc_errno;
}

void
hipcClientSetCimg(struct HIPC_client *const cl_p,
                  const unsigned char struno, void *cimg_p)
{
    assert(NULL != cl_p->cimg_pp);
    cl_p->cimg_pp[struno] = cimg_p;

    return;
}

void
hipcClientSetHandler(struct HIPC_client *const cl_p,
                     const unsigned char struno,
                     enum HIPC_errno (*hndlr_p) (struct HIPC_client *,
                                                 const hipc_msg, void *,
                                                 void *), void *const arg)
{
    assert(NULL != cl_p->hndlr_pp);
    assert(NULL != cl_p->hdarg_pp);
    cl_p->hndlr_pp[struno] = hndlr_p;
    cl_p->hdarg_pp[struno] = arg;

    return;
}

enum HIPC_errno
hipcClientCallHandler(struct HIPC_client *const cl_p,
                      const unsigned char struno, const hipc_msg msgR)
{
    enum HIPC_errno retval;

    assert(NULL != cl_p->hndlr_pp);
    assert(NULL != cl_p->cimg_pp);

    retval = HIPC_SUCCESS;
    if (NULL != cl_p->hndlr_pp[struno]) {
        retval =
            cl_p->hndlr_pp[struno] (cl_p, msgR, cl_p->cimg_pp[struno],
                                    cl_p->hdarg_pp[struno]);
    }
    return retval;
}

unsigned char hipcClientGetNsysmsg(struct HIPC_client const *const cl_p)
{
    return cl_p->indp_p->n_sysmsg;
}

enum HIPC_errno
hipcClientInit(struct HIPC_client *const cl_p,
               struct HIPC_client const *const clbase_p)
{
    void *tmp_p;
    unsigned int i;

    if (NULL == clbase_p) {
        cl_p->pllist_p = NULL;  /* hipcClientTerminate() may be called. */
        return hipcClientSetError(cl_p, HIPC_ERR_INV_BASE_CLIENT,
                                  "clbase_p is NULL");
    }
    *cl_p = *clbase_p;

    cl_p->std_errno = 0;
    cl_p->hipc_errno = HIPC_SUCCESS;
    cl_p->err_detail_str[0] = '\0';

    cl_p->pllist_p = NULL;

    if (NULL == cl_p->indp_p) {
        return hipcClientSetError(cl_p, HIPC_ERR_INV_BASE_CLIENT,
                                  "cl_p->indp_p is NULL");
    }
    if (NULL == cl_p->cmdp_p) {
        return hipcClientSetError(cl_p, HIPC_ERR_INV_BASE_CLIENT,
                                  "cl_p->cmdp_p is NULL");
    }
    cl_p->cmdp_p->endian = hipcEndian();
    if (0x6f /* 'o' */  == cl_p->cmdp_p->endian) {
        return hipcClientSetError(cl_p, HIPC_ERR_INV_ENDIAN,
                                  "cl_p->cmdp_p->endian is 'o'");
    }

    cl_p->cimg_pp =
        hipcClientCalloc(cl_p,
                         cl_p->indp_p->n_struct, sizeof(*(cl_p->cimg_pp)));
    if (NULL == cl_p->cimg_pp) {
        return cl_p->hipc_errno;
    }

    tmp_p = hipcClientCalloc(cl_p, cl_p->indp_p->n_struct,
                             sizeof(*(cl_p->simg_pp)));
    if (NULL == tmp_p) {
        return cl_p->hipc_errno;
    }
    cl_p->simg_pp = tmp_p;

    cl_p->hndlr_pp =
        hipcClientCalloc(cl_p,
                         cl_p->indp_p->n_struct,
                         sizeof(*(cl_p->hndlr_pp)));
    if (NULL == cl_p->hndlr_pp) {
        return cl_p->hipc_errno;
    }

    tmp_p = hipcClientCalloc(cl_p, cl_p->indp_p->n_struct,
                             sizeof(*(cl_p->hdarg_pp)));
    if (NULL == tmp_p) {
        return cl_p->hipc_errno;
    }
    cl_p->hdarg_pp = tmp_p;

    if (NULL == clbase_p->smdp_p) {
        cl_p->smdp_p =
            hipcClientCalloc(cl_p, 1, sizeof(struct HIPC_cl_dp));
        if (NULL == cl_p->smdp_p) {
            return cl_p->hipc_errno;
        }
        cl_p->smdp_p->struct_p =
            hipcClientCalloc(cl_p, cl_p->indp_p->n_struct,
                             sizeof(struct HIPC_cl_dp_stru));
        if (NULL == cl_p->smdp_p->struct_p) {
            return cl_p->hipc_errno;
        }
    } else {
        if (cl_p->smdp_p->endian == cl_p->cmdp_p->endian) {
            cl_p->endian_convert = 0;
        } else {
            cl_p->endian_convert = 1;
        }

        for (i = 0; i < cl_p->indp_p->n_struct; ++i) {
            assert(NULL != cl_p->smdp_p->struct_size_p);
            tmp_p = hipcClientMalloc(cl_p, cl_p->smdp_p->struct_size_p[i]);
            if (NULL == tmp_p) {
                return cl_p->hipc_errno;
            }
            cl_p->simg_pp[i] = tmp_p;
        }
    }

    return HIPC_SUCCESS;
}

void hipcClientTerminate(struct HIPC_client *const cl_p)
{
    struct HIPC_ptr_link_list *pllist_p;

    while (NULL != cl_p->pllist_p) {
        pllist_p = cl_p->pllist_p;
        cl_p->pllist_p = pllist_p->next;
        free(pllist_p->ptr);
        free(pllist_p);
    }
    return;
}

enum HIPC_errno hipcClientCheckMbrSize(struct HIPC_client *const cl_p)
{
    unsigned int i;
    unsigned int j;
    const struct HIPC_cl_indp_stru *mis_p;

    assert(NULL != cl_p->smdp_p->struct_p);
    for (j = 0; j < cl_p->indp_p->n_struct; ++j) {
        assert(NULL != cl_p->smdp_p->struct_p[j].size_p);
        mis_p = &(cl_p->indp_p->struct_p[j]);
        for (i = 0; i < mis_p->n_member; ++i) {
            if (HIPC_MBR_SIMPLE == mis_p->mbr_p[i].type ||
                (HIPC_MBR_ARRAY == mis_p->mbr_p[i].type &&
                 HIPC_MBR_SIMPLE == mis_p->mbr_p[i].elm_type)) {
                if (cl_p->cmdp_p->struct_p[j].size_p[i] !=
                    cl_p->smdp_p->struct_p[j].size_p[i]) {
#ifdef DEBUG
                    fprintf(stderr,
                            "MBR_SIZE_MISMATCH: "
                            "%s.%s; "
                            "struno/mbrnum %d/%d; "
                            "client-side size/server-side size %d/%d\n",
                            mis_p->name,
                            mis_p->mbr_p[i].name,
                            j, i,
                            cl_p->cmdp_p->struct_p[j].size_p[i],
                            cl_p->smdp_p->struct_p[j].size_p[i]);
#endif
                    hipcClientSetErrDtlStr(cl_p,
                                           "The member size in server is not the same as the size in client; member name: ",
                                           mis_p->mbr_p[i].name, 0);
                    cl_p->hipc_errno = HIPC_ERR_MBR_SIZE_MISMATCH;
                    return cl_p->hipc_errno;
                }
            }
        }
    }
    return HIPC_SUCCESS;
}

enum HIPC_errno
hipcClientCheckStrutpl(struct HIPC_client *const cl_p,
                       const unsigned char struno,
                       const size_t offset, const size_t rngsize)
{
    if (struno >= cl_p->indp_p->n_struct) {
#ifdef DEBUG
        fprintf(stderr,
                "INV_STRUNO: (struno=)%d >= %d(=cl_p->indp_p->n_struct)\n",
                struno, cl_p->indp_p->n_struct);

#endif
        return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INV_STRUNO: The structure number is equal to or more than cl_p->indp_p->n_struct");
    }
    if (offset >= cl_p->smdp_p->struct_size_p[struno]) {
#ifdef DEBUG
        fprintf(stderr,
                "INV_OFFSET: (offset=)%ld >= %d(=cl_p->smdp_p->struct_size_p[struno])\n",
                offset, cl_p->smdp_p->struct_size_p[struno]);
#endif
        return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INV_OFFSET: The offest value is equal to or more than cl_p->smdp_p->struct_size_p[struno]");
    }
    if (rngsize > cl_p->smdp_p->struct_size_p[struno]) {
#ifdef DEBUG
        fprintf(stderr,
                "INV_SIZE: (rngsize=)%ld > %d(=cl_p->smdp_p->struct_size_p[struno])\n",
                rngsize, cl_p->smdp_p->struct_size_p[struno]);
#endif
        return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INV_RNGSIZE: The rngsize is more than cl_p->smdp_p->struct_size_p[struno]");
    }
    if (offset + rngsize > cl_p->smdp_p->struct_size_p[struno]) {
#ifdef DEBUG
        fprintf(stderr,
                "INV_OFFSET_RNGSIZE: (offset=)%ld+(rngsize=)%ld > %d(=ccl_p->smdp_p->struct_size_p[struno])\n",
                offset, rngsize, cl_p->smdp_p->struct_size_p[struno]);
#endif
        return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INV_OFFSET_SIZE: The sum of offset and rngsizeis is more than cl_p->smdp_p->struct_size_p[struno]");
    }

    return HIPC_SUCCESS;
}

static enum HIPC_errno
GetStrutpl_mbr(struct HIPC_client *const cl_p,
               char const *const str, struct HIPC_cl_indp_mbr
               const *const mbr_p, size_t * offset_p, size_t * size_p)
{
    size_t n;
    unsigned long ary_idx;
    enum HIPC_errno retval;
    unsigned int i;
    char *end_p;
    struct HIPC_cl_indp_stru const *indstc_p;
    struct HIPC_cl_dp_stru const *rmdstc_p;
    struct HIPC_cl_indp_mbr nxtmbr;

    switch (mbr_p->type) {
    case HIPC_MBR_SIMPLE:
        hipcClientSetErrDtlStr(cl_p, "Inappropriate string: ", str, 0);
        cl_p->hipc_errno = HIPC_ERR_INV_ID_STR;
        return cl_p->hipc_errno;
        break;
    case HIPC_MBR_STRUCT:
        if ('.' != str[0]) {
            hipcClientSetErrDtlStr(cl_p,
                                   "No period before the member name: ",
                                   str, 0);
            cl_p->hipc_errno = HIPC_ERR_INV_ID_STR;
            return cl_p->hipc_errno;
        }

        n = strcspn(str + 1, ".[");

        indstc_p = &cl_p->indp_p->struct_p[mbr_p->struno];
        rmdstc_p = &cl_p->smdp_p->struct_p[mbr_p->struno];
        for (i = 0;; ++i) {
            if (i >= indstc_p->n_member) {
                hipcClientSetErrDtlStr(cl_p, "Unknown member name: ",
                                       str + 1, n);
                cl_p->hipc_errno = HIPC_ERR_INV_ID_STR;
                return cl_p->hipc_errno;
            }
            if (0 == strncmp(str + 1, indstc_p->mbr_p[i].name, n)) {
                break;
            }
        }

        *offset_p += rmdstc_p->offset_p[i];
        *size_p = rmdstc_p->size_p[i];
        if ('\0' == str[n + 1]) {
            return HIPC_SUCCESS;
        }

        retval =
            GetStrutpl_mbr(cl_p, &str[n + 1], &indstc_p->mbr_p[i],
                           offset_p, size_p);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        break;
    case HIPC_MBR_ARRAY:
        if ('[' != str[0]) {
            hipcClientSetErrDtlStr(cl_p,
                                   "No left bracket following the array name: ",
                                   str, 0);
            cl_p->hipc_errno = HIPC_ERR_INV_ID_STR;
            return cl_p->hipc_errno;
        }
        ary_idx = strtoul(&str[1], &end_p, 10);
        if (ULONG_MAX == ary_idx || &str[1] == end_p) {
            hipcClientSetErrDtlStr(cl_p,
                                   "Failed to extract index from: ",
                                   str, 0);
            cl_p->hipc_errno = HIPC_ERR_INV_ID_STR;
            return cl_p->hipc_errno;
        }
        if (']' != *end_p) {
            hipcClientSetErrDtlStr(cl_p,
                                   "No right bracket following the index number: ",
                                   str, 0);
            cl_p->hipc_errno = HIPC_ERR_INV_ID_STR;
            return cl_p->hipc_errno;
        }

        if (0 == mbr_p->ary_dim) {
            return hipcClientSetError(cl_p, HIPC_ERR_INTERNAL_ERROR,
                                      "Number of dimensions is zero: mbr_p->ary_dim is zero");
        }
        if (ary_idx >= mbr_p->ary_max_idxs[mbr_p->ary_dim - 1]) {
            hipcClientSetErrDtlStr(cl_p,
                                   "The index is out of range: ", str, 0);
            cl_p->hipc_errno = HIPC_ERR_INV_ID_STR;
            return cl_p->hipc_errno;
        }

        *size_p /= mbr_p->ary_max_idxs[mbr_p->ary_dim - 1];
        *offset_p += (*size_p) * ary_idx;
        if ('\0' == *(end_p + 1)) {
            return HIPC_SUCCESS;
        }

        if (1 == mbr_p->ary_dim) {
            nxtmbr.type = mbr_p->elm_type;
            nxtmbr.struno = mbr_p->elm_struno;
        } else {
            nxtmbr = *mbr_p;
            nxtmbr.ary_dim -= 1;
        }

        retval =
            GetStrutpl_mbr(cl_p, &str[(end_p - str) + 1], &nxtmbr,
                           offset_p, size_p);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        break;
    default:
        return hipcClientSetError(cl_p, HIPC_ERR_INTERNAL_ERROR,
                                  "Invalid member type: invalid value in mbr_p->type");
        break;
    }

    return HIPC_SUCCESS;
}

enum HIPC_errno
hipcClientGetStrutpl(struct HIPC_client *const cl_p,
                     char const *const str,
                     unsigned char *struno_p,
                     size_t * offset_p, size_t * size_p)
{
    unsigned int i;
    size_t n;
    struct HIPC_cl_indp_mbr mbr;
    enum HIPC_errno retval;

    n = strcspn(str, ".");

    for (i = 0;; ++i) {
        if (i >= cl_p->indp_p->n_struct) {
            hipcClientSetErrDtlStr(cl_p, "Unknown structure name: ",
                                   str, n);
            cl_p->hipc_errno = HIPC_ERR_INV_ID_STR;
            return cl_p->hipc_errno;
        }
        if (0 == strncmp(str, cl_p->indp_p->struct_p[i].name, n)) {
            break;
        }
    }

    *struno_p = i;
    if ('\0' == str[n]) {
        *offset_p = 0;
        *size_p = cl_p->smdp_p->struct_size_p[i];
    } else {
        mbr.type = HIPC_MBR_STRUCT;
        mbr.struno = i;
        *offset_p = 0;

        retval = GetStrutpl_mbr(cl_p, str + n, &mbr, offset_p, size_p);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
    }

    return hipcClientCheckStrutpl(cl_p, *struno_p, *offset_p, *size_p);
}

enum HIPC_errno
hipcClientEachMbr(struct HIPC_client *const cl_p,
                  struct HIPC_cl_indp_mbr const *const
                  mbr_p,
                  unsigned char *const begin, unsigned char *const end,
                  unsigned char *const scur_p, unsigned char *const ccur_p,
                  const size_t ssize, const size_t csize,
                  void (*fnc_p) (void *const ccur_p, void *const scur_p,
                                 const size_t n))
{
    size_t i;
    struct HIPC_cl_indp_stru const *indstc_p;
    struct HIPC_cl_dp_stru const *rmdstc_p;
    struct HIPC_cl_dp_stru const *lmdstc_p;
    struct HIPC_cl_indp_mbr elm;
    unsigned char *stmp_p;
    unsigned char *ctmp_p;
    size_t celm_size;
    size_t selm_size;
    enum HIPC_errno retval;

    switch (mbr_p->type) {
    case HIPC_MBR_SIMPLE:
        if ((begin <= scur_p) && (end >= scur_p + ssize)) {
            fnc_p(scur_p, ccur_p, ssize);
        }
        break;
    case HIPC_MBR_STRUCT:
        indstc_p = &cl_p->indp_p->struct_p[mbr_p->struno];
        rmdstc_p = &cl_p->smdp_p->struct_p[mbr_p->struno];
        lmdstc_p = &cl_p->cmdp_p->struct_p[mbr_p->struno];
        for (i = 0; i < indstc_p->n_member; ++i) {
            if (end <= scur_p + rmdstc_p->offset_p[i]) {
                return HIPC_SUCCESS;
            }
            if ((end > scur_p + rmdstc_p->offset_p[i]) &&
                (begin <
                 scur_p + rmdstc_p->offset_p[i] + rmdstc_p->size_p[i])) {
                retval =
                    hipcClientEachMbr(cl_p, &indstc_p->mbr_p[i],
                                      begin, end,
                                      scur_p + rmdstc_p->offset_p[i],
                                      ccur_p + lmdstc_p->offset_p[i],
                                      rmdstc_p->size_p[i],
                                      lmdstc_p->size_p[i], fnc_p);
                if (HIPC_SUCCESS != retval) {
                    return retval;
                }
            }
        }
        break;
    case HIPC_MBR_ARRAY:
        celm_size = csize;
        selm_size = ssize;
        for (i = 0; i < mbr_p->ary_dim; ++i) {
            celm_size /= mbr_p->ary_max_idxs[i];
            selm_size /= mbr_p->ary_max_idxs[i];
        }
        if (0 == celm_size) {
            return hipcClientSetError(cl_p, HIPC_ERR_INTERNAL_ERROR,
                                      "ZERO_SIZE: celm_size is zero");
        }
        if (0 == selm_size) {
            return hipcClientSetError(cl_p, HIPC_ERR_INTERNAL_ERROR,
                                      "ZERO_SIZE: selm_size is zero");
        }
        elm.type = mbr_p->elm_type;
        elm.struno = mbr_p->elm_struno;

        if (begin <= scur_p) {
            stmp_p = scur_p;
            ctmp_p = ccur_p;
        } else {
            stmp_p = begin - ((begin - scur_p) % selm_size);
            ctmp_p =
                ccur_p + (((stmp_p - scur_p) / selm_size) * celm_size);
        }
        while (end > stmp_p && scur_p + ssize > stmp_p) {
            retval = hipcClientEachMbr(cl_p, &elm, begin, end,
                                       stmp_p, ctmp_p, selm_size,
                                       celm_size, fnc_p);
            if (HIPC_SUCCESS != retval) {
                return retval;
            }
            stmp_p += selm_size;
            ctmp_p += celm_size;
        }
        break;
    default:
        return hipcClientSetError(cl_p, HIPC_ERR_INTERNAL_ERROR,
                                  "Invalid member type: invalid value in mbr_p->type");
        break;
    }

    return HIPC_SUCCESS;
}

static void memcpy_wrapper(void *const scur_p, void *const ccur_p,
                           const size_t n)
{
    memcpy(scur_p, ccur_p, n);
    return;
}

static void contra_memcpy(void *const scur_p, void *const ccur_p,
                          const size_t n)
{
    memcpy(ccur_p, scur_p, n);
    return;
}

static void convert_endian(void *const scur_p, void *const ccur_p,
                           const size_t n)
{
    size_t i;

    for (i = 0; i < n; ++i) {
        ((unsigned char *) scur_p)[i] =
            ((unsigned char *) ccur_p)[n - 1 - i];
    }

    return;
}

static void contra_convert_endian(void *const scur_p, void *const ccur_p,
                                  const size_t n)
{
    size_t i;

    for (i = 0; i < n; ++i) {
        ((unsigned char *) ccur_p)[i] =
            ((unsigned char *) scur_p)[n - 1 - i];
    }

    return;
}

enum HIPC_errno
hipcClientUnpack(struct HIPC_client *const cl_p,
                 const unsigned char struno, const size_t offset,
                 const size_t size, void *simg, void *cimg)
{
    struct HIPC_cl_indp_mbr mbr;
    void (*fnc_p) (void *const ccur_p, void *const scur_p, const size_t n);
    enum HIPC_errno retval;

    retval = hipcClientCheckStrutpl(cl_p, struno, offset, size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    if (NULL == cimg) {
        if (NULL == cl_p->cimg_pp[struno]) {
            return HIPC_SUCCESS;
        } else {
            cimg = cl_p->cimg_pp[struno];
        }
    }
    if (NULL == simg) {
        simg = cl_p->simg_pp[struno];
    }

    mbr.type = HIPC_MBR_STRUCT;
    mbr.struno = struno;

    if (0 == cl_p->endian_convert) {
        fnc_p = contra_memcpy;
    } else {
        fnc_p = contra_convert_endian;
    }
    return hipcClientEachMbr(cl_p, &mbr,
                             (unsigned char *) simg + offset,
                             (unsigned char *) simg + offset + size,
                             simg, cimg, 0, 0, fnc_p);
}

enum HIPC_errno
hipcClientPack(struct HIPC_client *const cl_p,
               const unsigned char struno,
               const size_t offset, const size_t size,
               void *simg, void *cimg)
{
    struct HIPC_cl_indp_mbr mbr;
    void (*fnc_p) (void *const scur_p, void *const ccur_p, const size_t n);
    enum HIPC_errno retval;

    retval = hipcClientCheckStrutpl(cl_p, struno, offset, size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    if (NULL == cimg) {
        if (NULL == cl_p->cimg_pp[struno]) {
            return HIPC_SUCCESS;
        } else {
            cimg = cl_p->cimg_pp[struno];
        }
    }
    if (NULL == simg) {
        simg = cl_p->simg_pp[struno];
    }

    mbr.type = HIPC_MBR_STRUCT;
    mbr.struno = struno;

    if (0 == cl_p->endian_convert) {
        fnc_p = memcpy_wrapper;
    } else {
        fnc_p = convert_endian;
    }
    return hipcClientEachMbr(cl_p, &mbr,
                             (unsigned char *) simg + offset,
                             (unsigned char *) simg + offset + size,
                             simg, cimg, 0, 0, fnc_p);
}

enum HIPC_errno
hipcClientFeedUnstrumsgAsError(struct HIPC_client *const cl_p,
                               const hipc_msg msgR)
{
    if (HIPC_UNSTRU != msgR[HIPC_MSGHDR_BYTE_STRUNO]) {
        return hipcClientSetError(cl_p,
                                  HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INVALID_MSGBDY_TYPE: A message fed to hipcClientFeedUnstrumsgAsError() must have an unstructured body");
    }

    cl_p->hipc_errno = msgR[HIPC_MSGHDR_BYTE_OFFSET];
    assert(HIPC_IMG_ALLOCSIZE > msgR[HIPC_MSGHDR_SIZE]);
    memcpy(cl_p->err_detail_str, &msgR[HIPC_MSGHDR_SIZE],
           msgR[HIPC_MSGHDR_BYTE_BDYSZ]);
    cl_p->err_detail_str[msgR[HIPC_MSGHDR_BYTE_BDYSZ]] = '\0';

    return cl_p->hipc_errno;
}

static enum HIPC_errno
FeedSysmsg_OFFSET_SIZE(struct HIPC_client *const cl_p,
                       const hipc_msg msg, unsigned char **const tgtadr)
{
    void *tmp_p;
    const unsigned char struno = msg[HIPC_MSGHDR_BYTE_STRUNO];
    const unsigned char bdysz = msg[HIPC_MSGHDR_BYTE_BDYSZ];

    if (cl_p->indp_p->n_struct <= struno) {
#ifdef DEBUG
        fprintf(stderr,
                "INV_STRUNO: (cl_p->indp_p->n_struct=)%d <= %d(=struno)\n",
                cl_p->indp_p->n_struct, struno);
#endif
        return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INV_STRUNO: The structure number in the system message is over cl_p->indp_p->n_struct");
    }

    if (cl_p->indp_p->struct_p[struno].n_member != bdysz) {
#ifdef DEBUG
        fprintf(stderr,
                "INV_N_MEMBER: (cl_p->indp_p->struct_p[struno].n_member=)%d != %d(=bdysz)\n",
                cl_p->indp_p->struct_p[struno].n_member, bdysz);
#endif
        return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INV_N_MEMBER: The number of members in the system message is not same as the number in cl_p");
    }

    tmp_p = hipcClientMalloc(cl_p, bdysz);
    if (NULL == tmp_p) {
        return cl_p->hipc_errno;
    }
    memcpy(tmp_p, &msg[HIPC_MSGHDR_SIZE], bdysz);
    if (NULL != *tgtadr) {
        return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INVALID_SYSMSG: The information has been already set in cl_p");
    }
    *tgtadr = tmp_p;

    return HIPC_SUCCESS;
}

enum HIPC_errno
hipcClientFeedSysmsg(struct HIPC_client *const cl_p, const hipc_msg msgR)
{
    unsigned int i;
    void *tmp_p;
    enum HIPC_errno retval;
    unsigned char **tgtadr;
    const unsigned char struno = msgR[HIPC_MSGHDR_BYTE_STRUNO];
    const unsigned char bdysz = msgR[HIPC_MSGHDR_BYTE_BDYSZ];

    if (HIPC_MESSAGE_TYPE_SYS != msgR[HIPC_MSGHDR_BYTE_TYPE]) {
        return hipcClientSetError(cl_p,
                                  HIPC_ERR_PROTOCOL_VIOLATION,
                                  "INVALID_MSG_TYPE: Type must be SYS or QUIT");
    }

    switch (msgR[HIPC_MSGHDR_BYTE_OFFSET]) {
    case HIPC_SYSMSG_TYPE_OVERVIEW:
        cl_p->smdp_p->endian = struno;
        if ((0x42 /* 'B' */  != cl_p->smdp_p->endian) &&
            (0x6c /* 'l' */  != cl_p->smdp_p->endian)) {
            return hipcClientSetError(cl_p, HIPC_ERR_INV_ENDIAN,
                                      "cl_p->smdp_p->endian is not 'B' nor 'l'");
        }

        if (cl_p->smdp_p->endian == cl_p->cmdp_p->endian) {
            cl_p->endian_convert = 0;
        } else {
            cl_p->endian_convert = 1;
        }
        if (cl_p->indp_p->n_struct != bdysz) {
#ifdef DEBUG
            fprintf(stderr,
                    "UNMATCHED_SYSMSG: (cl_p->indp_p->n_struct=)%d != %d(=bdysz)\n",
                    cl_p->indp_p->n_struct, bdysz);
#endif
            return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                      "UNMATCHED_SYSMSG: cl_p->indp_p->n_struct is not the same as the number in the system message");
        }
        tmp_p =
            hipcClientMalloc(cl_p,
                             sizeof(unsigned char) *
                             (cl_p->indp_p->n_struct));
        if (NULL == tmp_p) {
            return cl_p->hipc_errno;
        }
        memcpy(tmp_p, &msgR[HIPC_MSGHDR_SIZE], bdysz);
        cl_p->smdp_p->struct_size_p = tmp_p;
        for (i = 0; i < cl_p->indp_p->n_struct; ++i) {
            tmp_p = hipcClientMalloc(cl_p, cl_p->smdp_p->struct_size_p[i]);
            if (NULL == tmp_p) {
                return cl_p->hipc_errno;
            }
            cl_p->simg_pp[i] = tmp_p;
        }
        break;
    case HIPC_SYSMSG_TYPE_OFFSET:
        tgtadr = &(cl_p->smdp_p->struct_p[struno].offset_p);
        retval = FeedSysmsg_OFFSET_SIZE(cl_p, msgR, tgtadr);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        break;
    case HIPC_SYSMSG_TYPE_SIZE:
        tgtadr = &(cl_p->smdp_p->struct_p[struno].size_p);
        retval = FeedSysmsg_OFFSET_SIZE(cl_p, msgR, tgtadr);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        break;
    default:
        return hipcClientSetError(cl_p, HIPC_ERR_PROTOCOL_VIOLATION,
                                  "Invalid system message");
        break;
    }

    return HIPC_SUCCESS;
}

enum HIPC_errno
hipcClientFeedStrumsg(struct HIPC_client *const cl_p, const hipc_msg msgR)
{
    enum HIPC_errno retval;

    retval = hipcClientCheckStrutpl(cl_p,
                                    msgR[HIPC_MSGHDR_BYTE_STRUNO],
                                    msgR[HIPC_MSGHDR_BYTE_OFFSET],
                                    msgR[HIPC_MSGHDR_BYTE_BDYSZ]);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    if (0 != msgR[HIPC_MSGHDR_BYTE_BDYSZ]) {
        memcpy(cl_p->simg_pp[msgR[HIPC_MSGHDR_BYTE_STRUNO]] +
               msgR[HIPC_MSGHDR_BYTE_OFFSET],
               &msgR[HIPC_MSGHDR_SIZE], msgR[HIPC_MSGHDR_BYTE_BDYSZ]);
    }

    return HIPC_SUCCESS;
}

void hipcGenmsgHello(hipc_msg msg, const struct HIPC_client *const cl_p)
{
    msg[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_HELLO;
    msg[HIPC_MSGHDR_BYTE_OFFSET] = 0;
    msg[HIPC_MSGHDR_BYTE_STRUNO] = HIPC_UNSTRU;
    msg[HIPC_MSGHDR_BYTE_BDYSZ] = cl_p->indp_p->cfgid_size;
    memcpy(&msg[HIPC_MSGHDR_SIZE],
           cl_p->indp_p->cfgid, msg[HIPC_MSGHDR_BYTE_BDYSZ]);
    return;
}

enum HIPC_errno
hipcGenmsgGet(hipc_msg msg, struct HIPC_client *const cl_p,
              const unsigned char struno,
              const size_t offset, const size_t size)
{
    enum HIPC_errno retval;

    retval = hipcClientCheckStrutpl(cl_p, struno, offset, size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    msg[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_GET;
    msg[HIPC_MSGHDR_BYTE_OFFSET] = offset;
    msg[HIPC_MSGHDR_BYTE_STRUNO] = struno;
    msg[HIPC_MSGHDR_BYTE_BDYSZ] = size;

    return HIPC_SUCCESS;
}

enum HIPC_errno
hipcGenmsgPut(hipc_msg msg, struct HIPC_client *const cl_p,
              const unsigned char struno,
              const size_t offset, const size_t size)
{
    enum HIPC_errno retval;

    retval = hipcClientCheckStrutpl(cl_p, struno, offset, size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    msg[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_PUT;
    msg[HIPC_MSGHDR_BYTE_OFFSET] = offset;
    msg[HIPC_MSGHDR_BYTE_STRUNO] = struno;
    msg[HIPC_MSGHDR_BYTE_BDYSZ] = size;

    memcpy(&msg[HIPC_MSGHDR_SIZE], cl_p->simg_pp[struno] + offset, size);

    return HIPC_SUCCESS;
}

void hipcGenmsgBye(hipc_msg msg)
{
    msg[HIPC_MSGHDR_BYTE_TYPE] = HIPC_MESSAGE_TYPE_BYE;
    msg[HIPC_MSGHDR_BYTE_OFFSET] = 0;
    msg[HIPC_MSGHDR_BYTE_STRUNO] = HIPC_UNSTRU;
    msg[HIPC_MSGHDR_BYTE_BDYSZ] = 0;

    return;
}