abrain.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME "abrain.c"
 
/* LABEL-END */
 
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <ctype.h>
 
#include "sqlite3.h"
#include "msgque_mq.h"
#include "debug_mq.h"
 
static MK_TYP BrainTT = NULL;
#define BrainT ((typeof(MqContextST)) BrainTT)
#define BRAINCTX ((struct BrainCtxS*const)mqctx)
#define MQCTX ((MQ_CTX*const)brain)
#define META_CONTEXT_S mqctx
#define SETUP_brain struct BrainCtxS*const brain = BRAINCTX
#define SETUP_db sqlite3*const db = brain->db
#define SETUP_W(sh) \
  SETUP_brain; \
  MK_I64 key; \
  register sqlite3_stmt *hdl= brain->sh
#define SETUP_C(sh) \
  SETUP_brain; \
  MK_STRN key; MK_SIZE klen; \
  register sqlite3_stmt *hdl= brain->sh
#define DbErrorCheck(f) \
  if (unlikely((f) != SQLITE_OK)) { \
    MkErrorSetC_4M (mqctx, sqlite3_errmsg(brain->db), __func__, sqlite3_extended_errcode(brain->db)); \
    goto error; \
  }
#define CHECK_ARGS(s) \
  if (MqReadGetNumItems(mqctx))  { \
    return MkErrorSetV_4M (mqctx, __func__, SQLITE_ERROR, "usage: %s (%s)\n", __func__, s); \
  }
#define check_sqlite(E) \
  if (unlikely((E) != SQLITE_OK))
#define check_NULL(E) \
  if (unlikely((E) == NULL))
 
#define DB_PREPARE_MAX 100
 
struct BrainCtxS {
  MQ_CTXR       mqctx;                      
  MK_STRN       storage;                    
  sqlite3       *db;                        
  sqlite3_stmt  *prepStmt[DB_PREPARE_MAX];  
  MK_STR        inType[DB_PREPARE_MAX];     
  MK_STR        inEnd[DB_PREPARE_MAX];      
  MK_STR        outType[DB_PREPARE_MAX];    
  MK_STR        outEnd[DB_PREPARE_MAX];     
  MK_I32        prepare_start;              
  MK_BUF        buf;                        
};
 
/*****************************************************************************/
/*                                                                           */
/*                               Request Handler                             */
/*                                                                           */
/*****************************************************************************/
 
static void __attribute__ ((noreturn))
BrainHelp (const char * base)
{
  fprintf (stderr, "usage: %s [OPTION]... [ARGUMENT]...\n", base);
  fputs   ("\n", stderr);
  fputs   ("  This tool is the database server of NHI1.\n", stderr);
  fputs   ("    main: https://theBrain.nhi1.de\n", stderr);
  fputs   ("    tool: https://thebrain.nhi1.de/theBrain.htm\n", stderr);
  fputs   ("\n", stderr);
  fprintf (stderr, "  %s [ARGUMENT]... syntax:\n", base);
  fprintf (stderr, "    aclient [OPTION]... %c %s [OPTION]... [ARGUMENT]\n", MK_ALFA, base);
  fputs   ("\n", stderr);
  fputs   (MqHelp (NULL), stderr);
  fputs   ("\n", stderr);
  fprintf (stderr,"  %s [OPTION]:\n", base);
  fputs   ("    -h, --help       print this help\n", stderr);
  fputs   ("\n", stderr);
 
  exit(EXIT_SUCCESS);
}
 
#define READ_C(n) MK_STRN n; MkErrorCheck(MqReadSTR(mqctx,&n))
 
/*****************************************************************************/
/*                                                                           */
/*                                  Helper                                   */
/*                                                                           */
/*****************************************************************************/
 
static enum MkErrorE IdxGet_RT ( MK_RT_ARGS MQ_CTX const mqctx, MK_I32 *pidx ) {
  MkErrorCheck (MqReadI32 (mqctx, pidx));
  if (*pidx < 0 || *pidx > DB_PREPARE_MAX-1) {
    MkErrorSetV_4M (mqctx, __func__, SQLITE_ERROR, "prepare index out of range: 0 <= idx <= %i", DB_PREPARE_MAX-1);
    goto error;
  }
  return MK_OK;
error:
  return MkErrorStack_1X(mqctx);
}
 
#define IdxGet(...) IdxGet_RT(MK_RT_CALL __VA_ARGS__)
 
inline static enum MkErrorE IdxFinalize_RT ( MK_RT_ARGS MQ_CTX const mqctx, MK_I32 idx ) {
  SETUP_brain;
  if (brain->prepStmt[idx] != NULL) {
    DbErrorCheck(sqlite3_finalize(brain->prepStmt[idx]));
    brain->prepStmt[idx] = NULL;
    MkSysFree(brain->inType[idx]);
    brain->inEnd[idx] = NULL;
    MkSysFree(brain->outType[idx]);
    brain->outEnd[idx] = NULL;
  }
  return MK_OK;
error:
  return MkErrorStack_1X(mqctx);
}
 
#define IdxFinalize(...) IdxFinalize_RT(MK_RT_CALL __VA_ARGS__)
 
inline static enum MkErrorE HdlGet_RT ( 
  MK_RT_ARGS
  MQ_CTX const mqctx, 
  sqlite3_stmt **phdl, 
  MK_STRN *pInType,
  MK_STRN *pInEnd,
  MK_STRN *pOutType, 
  MK_STRN *pOutEnd 
) {
  SETUP_brain;
  MK_I32 idx;
  MkErrorCheck (IdxGet (mqctx, &idx));
  check_NULL(*phdl = brain->prepStmt[idx]) {
    MkErrorSetV_4M (mqctx, __func__, SQLITE_ERROR, "the prepare-index '%i' was NOT defined", idx);
    goto error;
  }
  *pInType = brain->inType[idx];
  *pInEnd = brain->inEnd[idx];
  *pOutType = brain->outType[idx];
  *pOutEnd = brain->outEnd[idx];
  return MK_OK;
error:
  return MkErrorStack_1X(mqctx);
}
 
#define HdlGet(...) HdlGet_RT(MK_RT_CALL __VA_ARGS__)
 
static enum MkErrorE ctxCleanup_RT ( MK_RT_ARGS MQ_CTX const mqctx ) {
  SETUP_brain;
  MkSysFree (brain->storage);
  if (brain->db != NULL) {
    for (MK_I32 idx=0; idx<brain->prepare_start; idx++) {
      MkErrorCheck (IdxFinalize (mqctx, idx));
    }
    brain->prepare_start=0;
    DbErrorCheck(sqlite3_close(brain->db))
    brain->db=NULL;
  }
  return MK_OK;
error:
  brain->db = NULL;
  return MkErrorStack_1X(mqctx);
}
 
#define ctxCleanup(...) ctxCleanup_RT(MK_RT_CALL __VA_ARGS__)
 
/*****************************************************************************/
/*                                                                           */
/*                               Service Handler                             */
/*                                                                           */
/*****************************************************************************/
 
inline static enum MkTypeE GetTypeE ( MK_STRB t ) {
  switch (t) {
    case 'C': return MK_STRT;
    case 'I': return MK_I32T;
    case 'D': return MK_DBLT;
    case 'W': return MK_I64T;
    case 'B': return MK_BINT;
    case 'Y': return MK_I8T;
    case 'O': return MK_BOLT;
    case 'S': return MK_I16T;
    case 'F': return MK_FLTT;
    case 'L': return MK_LSTT;
  }
  return MK_STRT;
}
 
inline static MK_STRB GetTypeS ( enum MkTypeE const ntype ) {
  switch (ntype) {
    case MK_STRT: return 'C';
    case MK_I32T: return 'I';
    case MK_DBLT: return 'D';
    case MK_I64T: return 'W';
    case MK_BINT: return 'B';
    case MK_I8T:  return 'Y';
    case MK_BOLT: return 'O';
    case MK_I16T: return 'S';
    case MK_FLTT: return 'F';
    case MK_LSTT: return 'L';
  }
  return '*';
}
 
inline static enum MkTypeE GetTypeD ( sqlite3_stmt *hdl, MK_I32 idx ) {
  switch (sqlite3_column_type(hdl,idx)) {
    case SQLITE_INTEGER:
      switch (sqlite3_column_bytes(hdl,idx)) {
        case 1: return MK_I8T;
        case 2: return MK_I16T;
        case 3: 
        case 4: return MK_I32T;
        case 6: 
        case 8: return MK_I64T;
      }
      break;
    case SQLITE_FLOAT: return MK_DBLT;
    case SQLITE_BLOB:  return MK_BINT;
    case SQLITE_TEXT:  return MK_STRT;
    case SQLITE_NULL:  return MK_BINT;
  }
  return MK_BINT;
}
 
#define case1(t,f,c) \
  case t##T: { \
    t dat; \
    MkErrorCheck(MkBufferGet ## c(buf,&dat)); \
    DbErrorCheck(f(hdl,idx,dat)); \
    break; \
  }
 
inline static enum MkErrorE GetFromDBnat_RT ( 
  MK_RT_ARGS
  MQ_CTX const mqctx, 
  enum MkTypeE ntype,
  sqlite3_stmt *hdl, 
  MK_I32 idx
) {
  switch (ntype) {
    case MK_STRT: return MqSendSTR(mqctx,(MK_STRN)sqlite3_column_text(hdl,idx));
    case MK_I32T: return MqSendI32(mqctx,(MK_I32)sqlite3_column_int(hdl,idx));
    case MK_I16T: return MqSendI16(mqctx,(MK_I16)sqlite3_column_int(hdl,idx));
    case MK_I8T: return MqSendI8(mqctx,(MK_I8)sqlite3_column_int(hdl,idx));
    case MK_BOLT: return MqSendBOL(mqctx,(MK_BOL)sqlite3_column_int(hdl,idx));
    case MK_I64T: return MqSendI64(mqctx,(MK_I64)sqlite3_column_int64(hdl,idx));
    case MK_DBLT: return MqSendDBL(mqctx,(MK_DBL)sqlite3_column_double(hdl,idx));
    case MK_FLTT: return MqSendFLT(mqctx,(MK_FLT)sqlite3_column_double(hdl,idx));
    case MK_BINT: return MqSendBIN(mqctx,MkBinaryCreate(sqlite3_column_bytes(hdl,idx),sqlite3_column_blob(hdl,idx)));
    case MK_LSTT: 
      return MkErrorSetV_4M (mqctx, __func__, SQLITE_ERROR, "invalid protocoll item '%c'", GetTypeS(ntype));
  }
  return MK_BINT;
}
 
#define GetFromDBnat(...) GetFromDBnat_RT(MK_RT_CALL __VA_ARGS__)
 
inline static enum MkErrorE GetFromDBary_RT ( 
  MK_RT_ARGS
  MQ_CTX const mqctx, 
  enum MkTypeE ntype,
  sqlite3_stmt *hdl, 
  MK_I32 idx
) {
  switch (ntype) {
    case MK_BINT:
      MqSendBIN_E(mqctx,MkBinaryCreate(sqlite3_column_bytes(hdl,idx),sqlite3_column_blob(hdl,idx)));
      break;
    case MK_STRT:
      MqSendSTR_E(mqctx,(MK_STRN)sqlite3_column_text(hdl,idx));
      break;
    default:
      MkBufferCastTo_E( MkBufferSetSTR(BRAINCTX->buf, (MK_STRN)sqlite3_column_text(hdl, idx)), ntype);
      MqSendBUF_E(mqctx, BRAINCTX->buf);
      break;
  }
  return MK_OK;
error:
  return MkErrorStack_1X(mqctx);
}
 
#define GetFromDBary(...) GetFromDBary_RT(MK_RT_CALL __VA_ARGS__)
 
static enum MkErrorE STEP ( MQ_SERVICE_CALL_ARGS ) {
  SETUP_brain;
  MK_I32 idx=0;
  MK_BUF buf;
  sqlite3_stmt *hdl=NULL;
  MK_STRN inType=NULL,  inEnd=NULL;
  MK_STRN outType=NULL, outEnd=NULL;
  enum MkTypeE ntype;
 
  MkErrorCheck(HdlGet(mqctx, &hdl, &inType, &inEnd, &outType, &outEnd));
  DbErrorCheck(sqlite3_reset(hdl));
 
  MqSendSTART(mqctx);
  while (MqReadItemExists(mqctx)) {
    idx+=1;
    MkErrorCheck(MqReadBUF(mqctx,&buf));
    if (inType && inType < inEnd) {
      ntype = GetTypeE(*inType);
      if (buf->var.type != ntype && buf->var.type != MK_STRT) {
        MkErrorSetV_4M(mqctx,__func__,SQLITE_ERROR,
          "the buffer type '%c' does not match database type '%c'", 
            MkBufferGetType1(buf), *inType);
        goto error;
      }
      inType++;
    } else {
      ntype = buf->var.type;
    }
    switch (buf->var.type) {
      case MK_I8T:  DbErrorCheck(sqlite3_bind_int(hdl,idx,buf->storage.first.A->I8)); break;
      case MK_BOLT: DbErrorCheck(sqlite3_bind_int(hdl,idx,buf->storage.first.A->BOL)); break;
      case MK_I16T: DbErrorCheck(sqlite3_bind_int(hdl,idx,buf->storage.first.A->I16)); break;
      case MK_I32T: DbErrorCheck(sqlite3_bind_int(hdl,idx,buf->storage.first.A->I32)); break;
      case MK_I64T: DbErrorCheck(sqlite3_bind_int64(hdl,idx,buf->storage.first.A->I64)); break;
      case MK_FLTT: DbErrorCheck(sqlite3_bind_double(hdl,idx,buf->storage.first.A->FLT)); break;
      case MK_DBLT: DbErrorCheck(sqlite3_bind_double(hdl,idx,buf->storage.first.A->DBL)); break;
      case MK_STRT: 
        switch (ntype) {
          case1(MK_I8,sqlite3_bind_int,I8)
          case1(MK_BOL,sqlite3_bind_int,BOL)
          case1(MK_I16,sqlite3_bind_int,I16)
          case1(MK_I32,sqlite3_bind_int,I32)
          case1(MK_I64,sqlite3_bind_int64,I64)
          case1(MK_FLT,sqlite3_bind_double,FLT)
          case1(MK_DBL,sqlite3_bind_double,DBL)
          case MK_STRT: 
            DbErrorCheck(sqlite3_bind_text (hdl,idx,buf->storage.first.C,(int)buf->storage.size,SQLITE_TRANSIENT)); 
            break;
          case MK_BINT: 
            if (buf->storage.size == 0) {
              DbErrorCheck (sqlite3_bind_null (hdl,idx));
            } else {
              DbErrorCheck (sqlite3_bind_blob (hdl,idx,buf->storage.first.B,(int)buf->storage.size,SQLITE_TRANSIENT));
            }
            break;
          case MK_LSTT:
            MkErrorSetV_4M (mqctx, __func__, SQLITE_ERROR, "invalid protocoll item '%c'", GetTypeS(ntype));
        }
        break;
      case MK_BINT:
        if (buf->storage.size == 0) {
          DbErrorCheck (sqlite3_bind_null (hdl,idx));
        } else {
          DbErrorCheck (sqlite3_bind_blob (hdl,idx,buf->storage.first.B,(int)buf->storage.size,SQLITE_TRANSIENT));
        }
        break;
      case MK_LSTT:
        MkErrorSetV_4M (mqctx, __func__, SQLITE_ERROR, "invalid protocoll item '%c'", GetTypeS(ntype));
        break;
    }
  }
 
  MK_STRN pos;
  MqSendSTART(mqctx);
  while (true) {
    switch (sqlite3_step(hdl)) {
      case SQLITE_ROW: {
        MqSendL_START(mqctx);
        for (idx=0,pos=outType; idx<sqlite3_column_count(hdl); idx++,pos++) {
          ntype = pos && pos < outEnd ? GetTypeE(*pos) : GetTypeD(hdl,idx);
          switch (sqlite3_column_type(hdl,idx)) {
            case SQLITE_INTEGER:
            case SQLITE_FLOAT:
            case SQLITE_NULL:
              MkErrorCheck(GetFromDBnat(mqctx, ntype, hdl, idx));
              break;
            case SQLITE_BLOB:
            case SQLITE_TEXT:
              MkErrorCheck(GetFromDBary(mqctx, ntype, hdl, idx));
              break;
          }
        }
        MqSendL_END(mqctx);
        continue;
        break;
      }
      case SQLITE_DONE:
        goto error;
      case SQLITE_LOCKED:
      case SQLITE_BUSY:
        continue;
      default:
        MkErrorSetC_4M (mqctx, sqlite3_errmsg(brain->db), __func__, sqlite3_extended_errcode(brain->db));
        DbErrorCheck(sqlite3_reset(hdl));
        goto error;
    }
  }
 
error:
  sqlite3_reset(hdl);
  return MqSendRETURN(mqctx);
}
 
static enum MkErrorE EXEC ( MQ_SERVICE_CALL_ARGS ) {
  SETUP_brain;
  MK_STRN sql;
  MkErrorCheck(MqReadSTR(mqctx,&sql));
  DbErrorCheck(sqlite3_exec(brain->db,sql, NULL, NULL, NULL));
 
error:
  return MqSendRETURN(mqctx);
}
 
static enum MkErrorE PREP ( MQ_SERVICE_CALL_ARGS ) {
  SETUP_brain;
  MK_STRN sql,end,type,start;
  MK_I32 idx;
  MK_BUF buf;
 
  // parse prefix
  MkErrorCheck(MqReadBUF(mqctx,&buf));
  if (buf->var.type == MK_I32T) {
    MkErrorCheck(MkBufferGetI32(buf,&idx));
    MkErrorCheck(IdxFinalize(mqctx, idx));
    MkErrorCheck(MqReadBUF(mqctx,&buf));
  } else {
    idx = brain->prepare_start;
  }
  MkErrorCheck(MkBufferGetSTR(buf,&sql));
  end = sql + buf->storage.size;
 
  // process values
  MqSendSTART(mqctx);
  while (sql != NULL && *sql != '\0') {
    // get the index
    for (; idx<DB_PREPARE_MAX && brain->prepStmt[idx]!=NULL; idx++);
    if (idx >= DB_PREPARE_MAX) {
      MkErrorSetV_4M (mqctx, __func__, SQLITE_ERROR, "unable to find a free prepare entry - only '%i' entries are allowed.", DB_PREPARE_MAX);
      goto error;
    }
    // find 'in:???' prefix
    brain->inType[idx]  = NULL;
    brain->inEnd[idx]   = NULL;
    brain->outType[idx] = NULL;
    brain->outEnd[idx]  = NULL;
    // 1. search for '/' as beginn of comment
    for (start=sql; start<end && *start != '/' && *start != ';'; start++);
    // 2. '/*' as 2cnd char
    if (start == end || *start++ != '/' || *start++ != '*') goto update;
 
  // find 'in:???' prefix
    // in1. 'WS' before "TYPE:???"
    for (; start<end && isspace(*start); start++);
    // in2. 'in:' the prefix
    if (start >= end-3 || strncmp(start, "in:", 3)) goto out;
    start+=3;
    // in3. 'ASCII' as beginn of comment
    for (type=start; start<end && isupper(*start); start++); 
    if (start == end) goto out;
    // in4. we have everything
    brain->inType[idx] = MkSysStrNDup(MkOBJ(mqctx), type, (start-type));
    brain->inEnd[idx] = brain->inType[idx] + (start-type);
    *brain->inEnd[idx] = '\0';
 
out:
  // find 'out:???' prefix
    // out1. 'WS' before "TYPE:???"
    for (; start<end && isspace(*start); start++);
    // out2. 'out:' the prefix
    if (start >= end-4 || strncmp(start, "out:", 4)) goto update;
    start+=4;
    // out3. 'ASCII' as beginn of comment
    for (type=start; start<end && isupper(*start); start++); 
    if (start == end) goto update;
    // out4. we have everything
    brain->outType[idx] = MkSysStrNDup(MkOBJ(mqctx), type, (start-type));
    brain->outEnd[idx] = brain->outType[idx] + (start-type);
    *brain->outEnd[idx] = '\0';
 
update:
    // update the database
    brain->prepare_start=idx+1;
    DbErrorCheck(sqlite3_prepare_v2(brain->db, sql, -1, &brain->prepStmt[idx], &sql));
    MqSendI32(mqctx, idx);
  }
error:
/*
printLC(brain->inType[idx])
printLC(brain->inEnd[idx])
printLC(brain->outType[idx])
printLC(brain->outEnd[idx])
*/
  return MqSendRETURN(mqctx);
}
 
static enum MkErrorE FINA ( MQ_SERVICE_CALL_ARGS ) {
  MK_I32 idx;
  MkErrorCheck(IdxGet(mqctx, &idx));
  MkErrorCheck(IdxFinalize(mqctx, idx));
error:
  return MqSendRETURN(mqctx);
}
 
static enum MkErrorE OPEN ( MQ_SERVICE_CALL_ARGS );
 
static enum MkErrorE CLOS ( MQ_SERVICE_CALL_ARGS ) {
  MkErrorCheck (ctxCleanup(mqctx));
  MkErrorCheck (MqServiceDelete (mqctx, "-ALL"));
  MkErrorCheck (MqServiceCreate (mqctx, "OPEN", OPEN, NULL, NULL, NULL));
 
error:
  return MqSendRETURN(mqctx);
}
 
static enum MkErrorE OPEN ( MQ_SERVICE_CALL_ARGS ) {
  SETUP_brain;
 
  // open storage
  {
    MK_STRN dbstorage;
    MkErrorCheck(MqReadSTR(mqctx,&dbstorage));
 
    if (dbstorage == NULL) {
      return MkErrorSetC_4M (mqctx, "storage-file is empty or invalid", __func__, SQLITE_ERROR);
    }
 
    MkDLogV(mqctx,5,"try to open database '%s'\n", dbstorage);
 
    // open the database
    DbErrorCheck (sqlite3_open(dbstorage, &brain->db));
  }
 
  // add/remove services
  MkErrorCheck (MqServiceDelete (mqctx, "OPEN"));
 
  MkErrorCheck (MqServiceCreate (mqctx, "CLOS", CLOS, NULL, NULL, NULL));
  MkErrorCheck (MqServiceCreate (mqctx, "EXEC", EXEC, NULL, NULL, NULL));
  MkErrorCheck (MqServiceCreate (mqctx, "PREP", PREP, NULL, NULL, NULL));
  MkErrorCheck (MqServiceCreate (mqctx, "FINA", FINA, NULL, NULL, NULL));
  MkErrorCheck (MqServiceCreate (mqctx, "STEP", STEP, NULL, NULL, NULL));
 
  MqSendSTART(mqctx);
error:
  return MqSendRETURN(mqctx);
}
 
/*****************************************************************************/
/*                                                                           */
/*                                context_init                               */
/*                                                                           */
/*****************************************************************************/
 
static enum MkErrorE
BrainCleanup ( MQ_SERVICE_CALL_ARGS )
{
  SETUP_brain;
  MkBufferDelete(brain->buf);
  MkErrorCheck(ctxCleanup(mqctx));
 
  return MK_OK;
error:
  return MkErrorStack_1X(mqctx);
}
 
static enum MkErrorE
BrainSetup ( MQ_SERVICE_CALL_ARGS )
{
  SETUP_brain;
  brain->prepare_start=0;
  brain->buf = MkBufferCreate(MkBuffer1024STT,10);
  MkErrorCheck (MqServiceCreate (mqctx, "OPEN", OPEN, NULL, NULL, NULL));
 
  return MK_OK;
error:
  return MkErrorStack_1X(mqctx);
}
 
/*****************************************************************************/
/*                                                                           */
/*                                  main                                     */
/*                                                                           */
/*****************************************************************************/
 
static enum MkErrorE
BrainFactory ( MQ_CALLBACK_FACTORY_CTOR_ARGS )
{
  MQ_CTX const mqctx = *contextP = MqContextCreate(BrainTT,tmpl);
 
  mqctx->setup.isServer             = true;
  mqctx->setup.ServerSetup.fCall    = BrainSetup;
  mqctx->setup.ServerCleanup.fCall  = BrainCleanup;
 
  return MK_OK;
}
 
 
int
main (
  const int argc,
  MK_STRN argv[]
)
{
  MqSetup();
  AllRtSetup_NULL;
 
  // define the new type
  BrainTT = MkTypeDup2(MqContextSTT, "BrainTT");
  BrainTT->objsize = sizeof(struct BrainCtxS);
  BrainT->fHelp = BrainHelp;
 
  // parse the command-line
  MK_BFL args = MkBufferListCreateVC (argc, argv);
  MQ_CTX mqctx = NULL;
 
  // call Factory
  MQ_FCT fct = MqFactoryAdd_2(BrainFactory, "abrain");
  MqFactoryNew_E (fct, NULL, &mqctx);
 
  // create the ServerCtxS
  MqLinkCreate_E (mqctx, args);
 
  // start event-loop and wait forever
  MqProcessEvent_E (mqctx, MQ_WAIT_FOREVER, MK_TIMEOUT_DEFAULT);
 
  // finish and exit
error:
  MkBufferListDelete(args);
  MqExit_1 (mqctx);
}