session.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <hipc/session.h>

void hipcERRCHECK(const hipc_session * const sess_p,
                  const char *const filename, const int lineno)
{
    int std_errno;
    const char *errdtlstr;

    if (NULL == sess_p) {
        fprintf(stderr, "%s:%d:sess_p is NULL.\n", filename, lineno);
        exit(EXIT_FAILURE);
    }

    if (HIPC_SUCCESS != hipcClientGetHipcErrno(&(sess_p->cl))) {
        fprintf(stderr, "%s:%d:%s\n",
                filename, lineno, hipcClientGetErrStr(&(sess_p->cl)));

        std_errno = hipcClientGetStdErrno(&(sess_p->cl));
        if (0 != std_errno) {
            fprintf(stderr, "std_errno:%d:%s\n", std_errno,
                    strerror(std_errno));
        }

        errdtlstr = hipcClientGetErrDtlStr(&(sess_p->cl));
        if ('\0' != errdtlstr[0]) {
            fprintf(stderr, "ErrorDetail:%s\n", errdtlstr);
        }

        exit(EXIT_FAILURE);
    }

    return;
}

enum HIPC_errno hipcRecvMsg(hipc_session * const sess_p, hipc_msg msgR)
{
    enum HIPC_errno retval;

    retval = sess_p->rfnc_p(sess_p->rarg, msgR);
    if (HIPC_SUCCESS != retval) {
        hipcClientSetStdErrno(&sess_p->cl);
        hipcClientSetError(&sess_p->cl, retval,
                           "Failed to receive a message");
    }
    return retval;
}

enum HIPC_errno hipcSendMsg(hipc_session * const sess_p, hipc_msg msgS)
{
    enum HIPC_errno retval;

    retval = sess_p->wfnc_p(sess_p->warg, msgS);
    if (HIPC_SUCCESS != retval) {
        hipcClientSetStdErrno(&sess_p->cl);
        hipcClientSetError(&sess_p->cl, retval,
                           "Failed to send a message");
    }
    return retval;
}

enum HIPC_errno hipcWaitReturn(hipc_session * const sess_p, hipc_msg msgR)
{
    int f_end;
    enum HIPC_errno retval;

    if (HIPC_SESS_ESTABLISHED != sess_p->state) {
        return hipcClientSetError(&sess_p->cl,
                                  HIPC_ERR_SESS_STATE_MISMATCH,
                                  "Not established session");
    }

    f_end = 0;
    do {
        retval = hipcRecvMsg(sess_p, msgR);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        /* fprintf(stderr, "MsgType: %d\n", hipcMsgType(msgR)); */
        switch (hipcMsgType(msgR)) {
        case HIPC_MESSAGE_TYPE_SUCCESS:
            if (HIPC_UNSTRU == hipcMsgStruno(msgR)) {
                retval = HIPC_SUCCESS;
            } else {
                retval = hipcClientFeedStrumsg(&sess_p->cl, msgR);
            }
            f_end = 1;
            break;
        case HIPC_MESSAGE_TYPE_QUIT:
            sess_p->state = HIPC_SESS_QUITTED;
            retval = hipcClientFeedUnstrumsgAsError(&sess_p->cl, msgR);
            f_end = 1;
            break;
        case HIPC_MESSAGE_TYPE_CAST:
            retval = hipcClientFeedStrumsg(&sess_p->cl, msgR);
            if (HIPC_SUCCESS != retval) {
                return retval;
            }
            retval = hipcClientUnpack(&sess_p->cl,
                                      hipcMsgStruno(msgR),
                                      hipcMsgOffset(msgR),
                                      hipcMsgRngsize(msgR), NULL, NULL);
            if (HIPC_SUCCESS != retval) {
                return retval;
            }
            retval = hipcClientCallHandler(&sess_p->cl,
                                           hipcMsgStruno(msgR), msgR);
            if (HIPC_SUCCESS != retval) {
                if (HIPC_SUCCESS == hipcClientGetHipcErrno(&sess_p->cl)) {
                    hipcClientSetError(&sess_p->cl, retval,
                                       "Handler returned an error.");
                }
                return retval;
            }
            break;
        default:
            return hipcClientSetError(&sess_p->cl,
                                      HIPC_ERR_PROTOCOL_VIOLATION,
                                      "INVALID_MSG_TYPE: Type must be SUCEESS, CAST, or QUIT");
        }
    } while (0 == f_end);

    return retval;
}

enum HIPC_errno
hipcSetHandler(hipc_session * const sess_p,
               char const *const str,
               void *const cimg,
               enum HIPC_errno (*hndlr_p) (struct HIPC_client *,
                                           const hipc_msg, void *, void *),
               void *const arg)
{
    unsigned char struno;
    size_t offset;
    size_t size;
    enum HIPC_errno retval;

    if (HIPC_SESS_ESTABLISHED != sess_p->state) {
        return hipcClientSetError(&sess_p->cl,
                                  HIPC_ERR_SESS_STATE_MISMATCH,
                                  "Not established session");
    }

    retval = hipcClientGetStrutpl(&sess_p->cl, str,
                                  &struno, &offset, &size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    hipcClientSetCimg(&sess_p->cl, struno, cimg);
    hipcClientSetHandler(&sess_p->cl, struno, hndlr_p, arg);

    return HIPC_SUCCESS;
}

enum HIPC_errno
hipcOpen(hipc_session * const sess_p,
         struct HIPC_client const *const clbase_p,
         enum HIPC_errno (*rfnc_p) (void *, hipc_msg), void *rarg,
         enum HIPC_errno (*wfnc_p) (void *, const hipc_msg), void *warg)
{
    int i;
    hipc_msg msgS;
    hipc_msg msgR;
    enum HIPC_errno retval;

    sess_p->rfnc_p = rfnc_p;
    sess_p->rarg = rarg;
    sess_p->wfnc_p = wfnc_p;
    sess_p->warg = warg;
    sess_p->state = HIPC_SESS_QUITTED;
    retval = hipcClientInit(&sess_p->cl, clbase_p);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    hipcGenmsgHello(msgS, &sess_p->cl);
    retval = hipcSendMsg(sess_p, msgS);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    for (i = 0; i < hipcClientGetNsysmsg(&sess_p->cl); ++i) {
        retval = hipcRecvMsg(sess_p, msgR);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
        if (HIPC_MESSAGE_TYPE_QUIT == hipcMsgType(msgR)) {
            /* the state has been already HIPC_SESS_QUITTED
               because it was set at the begging of this function */
            return hipcClientFeedUnstrumsgAsError(&sess_p->cl, msgR);
        }
        retval = hipcClientFeedSysmsg(&sess_p->cl, msgR);
        if (HIPC_SUCCESS != retval) {
            return retval;
        }
    }
    retval = hipcClientCheckMbrSize(&sess_p->cl);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }

    sess_p->state = HIPC_SESS_ESTABLISHED;

    return HIPC_SUCCESS;
}

enum HIPC_errno hipcClose(hipc_session * const sess_p)
{
    hipc_msg msgS;
    hipc_msg msgR;
    enum HIPC_errno retval;

    retval = HIPC_SUCCESS;
    if (HIPC_SESS_ESTABLISHED == sess_p->state) {
        hipcGenmsgBye(msgS);
        retval = hipcSendMsg(sess_p, msgS);
        if (HIPC_SUCCESS == retval) {
            retval = hipcWaitReturn(sess_p, msgR);
        }
    }

    hipcClientTerminate(&sess_p->cl);

    sess_p->rfnc_p = NULL;
    sess_p->rarg = NULL;
    sess_p->wfnc_p = NULL;
    sess_p->warg = NULL;
    sess_p->state = HIPC_SESS_TERMINATED;

    return retval;
}

enum HIPC_errno
hipcGet(hipc_session * const sess_p,
        char const *const str, void *const cimg)
{
    hipc_msg msgS;
    hipc_msg msgR;
    unsigned char struno;
    size_t offset;
    size_t size;
    int retval;

    if (HIPC_SESS_ESTABLISHED != sess_p->state) {
        return hipcClientSetError(&sess_p->cl,
                                  HIPC_ERR_SESS_STATE_MISMATCH,
                                  "Not established session");
    }

    retval = hipcClientGetStrutpl(&sess_p->cl, str,
                                  &struno, &offset, &size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval = hipcGenmsgGet(msgS, &sess_p->cl, struno, offset, size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval = hipcSendMsg(sess_p, msgS);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval = hipcWaitReturn(sess_p, msgR);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval =
        hipcClientUnpack(&sess_p->cl, struno, offset, size, NULL, cimg);

    return retval;
}

enum HIPC_errno
hipcPut(hipc_session * const sess_p,
        char const *const str, void *const cimg)
{
    hipc_msg msgS;
    hipc_msg msgR;
    unsigned char struno;
    size_t offset;
    size_t size;
    int retval;

    if (HIPC_SESS_ESTABLISHED != sess_p->state) {
        return hipcClientSetError(&sess_p->cl,
                                  HIPC_ERR_SESS_STATE_MISMATCH,
                                  "Not established session");
    }

    retval = hipcClientGetStrutpl(&sess_p->cl, str,
                                  &struno, &offset, &size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval = hipcClientPack(&sess_p->cl, struno, offset, size, NULL, cimg);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval = hipcGenmsgPut(msgS, &sess_p->cl, struno, offset, size);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval = hipcSendMsg(sess_p, msgS);
    if (HIPC_SUCCESS != retval) {
        return retval;
    }
    retval = hipcWaitReturn(sess_p, msgR);

    return retval;
}