aguard.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME "AGuard.c"
 
/* LABEL-END */
 
#include "common.h"
 
#define META_CONTEXT_S mqctx
 
#define ENCRYPT true
#define DECRYPT false
 
#if defined(MQ_BUILD_EXAMPLE)
  #define IDENT "AGuard"
static void guard_crypt (register MK_BINN data, MK_SIZE size, bool const flag) {
  // this is the tunnel entry
}
#else
  #include "aguard_crypt.h"
#endif
 
static MK_TYP AGuardTT = NULL;
#define AGuardT ((typeof(MqContextC_T)) AGuardTT)
 
// select features to test
//#define USE_BG_ERROR
 
/*****************************************************************************/
/*                                                                           */
/*                               Request Handler                             */
/*                                                                           */
/*****************************************************************************/
 
#define check_MqError(E) if (MkErrorCheckI(E))
 
struct AGuardCtxS {
  struct MqContextS      mqctx;
  struct MqDumpS  *dump;
};
 
#define myctx ((struct AGuardCtxS*)META_CONTEXT_S)
 
static enum MkErrorE
sProxySubCall ( MK_RT_ARGS MQ_CTX const targetCtx, MK_PTR const data) 
{
  MQ_CTX sourceCtx = (MQ_CTX ) data;
  if (strncmp(MqServiceTokenGet (targetCtx), "_RSB",5) == 0) {
    sourceCtx->link.protect.handShake = MQ_HANDSHAKE_START;
    MkErrorCheck (MqProxyPackage (targetCtx, sourceCtx, NULL));
    MkErrorCheck (MqSendRETURN_SUB(sourceCtx));
  }
  return MK_OK;
error:
  MqContextErrorCopy(targetCtx, sourceCtx);
  return MkErrorStack_1X(targetCtx);
}
 
inline static enum MkErrorE
MqReadDump (
  MK_RT_ARGS MQ_CTX const mqctx,
  struct MqDumpS ** dumpP
) {
  MkBinaryR out;
  enum MkErrorE ret = MqReadBIN (mqctx, &out);
  *dumpP = (struct MqDumpS *)out.data;
  MkErrorReturn (ret);
}
 
#define MqReadDump_E(mqctx,dumpP) if (MkErrorCheckI(MqReadDump( MK_RT_CALL mqctx,dumpP))) goto error
 
static enum MkErrorE
PkgToGrx2 (
  MK_RT_ARGS MQ_CTX const  mqctx,
  MQ_TOK const  token,
  MQ_CTX const  otherCtx,
  MQ_LTR        otherLId
)
{
  enum MqHandShakeE hs      = mqctx->link.protect.handShake;
  enum MqTransTypeE tt      = mqctx->link.protect.transType;
  enum MkErrorE     ret     = MK_OK;
  MkBinaryR         bdat    = {0};
 
/*
->GONE by split PRIVATE and PUBLIC
 
  if (otherCtx->link.send == NULL) {
    return MkErrorSetV_1XS("the '%s' object link is '%s' connected", "msgque", "not");
  }
*/
 
//printLV("objsize=%zd, dump=%p\n",mqctx->obj.type->objsize, myctx->dump)
 
  MqDumpExport_E          (mqctx, &myctx->dump);
 
  MkBinaryR bin =         MqDumpBinGet(myctx->dump);
 
  guard_crypt             (bin.data, bin.size, ENCRYPT);
  MqSendSTART_E           (otherCtx);
  MqSendSetHandShake_E    (otherCtx, hs);
 
  if (tt == MQ_TRANS_TYPE_TRANS) {
    // in a "longterm-transaction" with "MqProxyForward" and "MqSendRETURN"…
    // we DONT want any additional message from "MqSendRETURN" send to the "client".
    // with "link.protect.bits.LIdLck = true" the shortterm-transaction will be deleted in
    // "MqSendRETURN->sSendEND" → same as in "MqStorageInsert" or "MqDumpExport"
    //
    //  client.exe
    //    Send("T"…) ->
    //      Filter.exe
    //        Send("R"…) <- ANSWER database INSERT
    //          EventProc
    //            MqProxyForward  // forward to "targetctx"
    //              …
    //            MqSendRETURN    // THIS is the problem, we DON'T want ANY package from there send to client.exe
    //
    mqctx->link.protect.bits.LIdLck = true;
 
    // set the "transLId"
    MqSendLTR_E           (otherCtx, otherLId);
  }
 
  MqSendBIN_E               (otherCtx, bin);
 
  // direction: client -> server = call a service
  if (hs == MQ_HANDSHAKE_START) {
 
    // basically… MqSendEND_AND_WAIT can fail if an ASYNCRONE error arrive… even if
    // LTT was successfull send… if "refCount" will be incr AFTER send… an final "+TRT" will NOT find
    // the according transaction… and will create an ERROR
    if (tt == MQ_TRANS_TYPE_TRANS) {
      MkErrorCheck(MqStorageIncrRef(mqctx,otherLId));
    }
 
    if (mqctx->link.protect.transSId != 0) { // shortterm-transaction
 
      // direction: mqctx -> otherCtx
      switch (tt) {
        case MQ_TRANS_TYPE_CB:
        case MQ_TRANS_TYPE_WAIT:
          ret = MqSendEND_AND_WAIT (otherCtx, token, MK_TIMEOUT_DEFAULT);
          break;
        case MQ_TRANS_TYPE_SUB:
          ret = MqSendEND_AND_SUB (otherCtx, token, sProxySubCall, mqctx, NULL, MK_TIMEOUT_DEFAULT);
          break;
        case MQ_TRANS_TYPE_TRANS:
          ret = MqSendEND_AND_TRANSACTION (otherCtx, token, NULL, MK_TIMEOUT_DEFAULT);
          break;
        default:
          ret = MkErrorSetV_1XS("protocol-error -> invalid transaction-type: %s", MqTransTypeE_ToString(tt));
          break;
      }
      MkErrorCheck (ret);
 
      // start the answer
      MqSendSTART_E (mqctx);
 
      // Forward the "answer" of a STT… but only if "other-context" expect an answer
      if (tt != MQ_TRANS_TYPE_TRANS) {
 
        // read the answer
        MqReadBIN_E             (otherCtx, &bdat);
 
        guard_crypt           (bdat.data, bdat.size, DECRYPT);
 
        // copy the answer from "otherCtx" to "mqctx"
        MqProxyPackage_E      (otherCtx, mqctx, (struct MqDumpS *) bdat.data);
      }
    } else { // transSId == 0
      // direction: mqctx -> otherCtx
      switch (tt) {
        case MQ_TRANS_TYPE_NO:
          ret = MqSendEND (otherCtx, token, MK_TIMEOUT_DEFAULT);
          break;
        case MQ_TRANS_TYPE_TRANS:
          ret = MqSendEND_AND_TRANSACTION (otherCtx, token, NULL, 0);
          break;
        default:
          ret = MkErrorSetV_1XS("protocol-error -> invalid transaction-type: %s", MqTransTypeE_ToString(tt));
          break;
      }
      MkErrorCheck (ret);
    }
 
  // direction: client <- server = answer from the service → handShake "O" or "E"
  } else {
 
    if (mqctx->link.protect.transSId != 0) {  // shortterm-transaction, this is only valid for "+TRT"
      switch (tt) {
        case MQ_TRANS_TYPE_TRANS:
          ret = MqSendEND_AND_TRANSACTION (otherCtx, token, NULL, MK_TIMEOUT_DEFAULT);
          break;
        default:
          ret = MkErrorSetV_1XS("protocol-error -> invalid transaction-type: %s", MqTransTypeE_ToString(tt));
          break;
      }
    } else {                                  // everything NOT "+TRT"
      switch (tt) {
        case MQ_TRANS_TYPE_NO:
          ret = MqSendEND (otherCtx, token, MK_TIMEOUT_DEFAULT);
          break;
        case MQ_TRANS_TYPE_TRANS:
          ret = MqSendEND_AND_TRANSACTION (otherCtx, token, NULL, 0);
          break;
        default:
          ret = MkErrorSetV_1XS("protocol-error -> invalid transaction-type: %s", MqTransTypeE_ToString(tt));
          break;
      }
    }
    MkErrorCheck (ret);
  }
 
done:
  return MkErrorGetCode_0E();
 
error:
  MqContextErrorCopy(mqctx, otherCtx);
  MkErrorStack_1X(mqctx);
  goto done;
}
 
static enum MkErrorE
PkgToGrp ( MQ_SERVICE_CALL_ARGS )
{
  enum MkErrorE ret;
 
  MQ_CTX otherCtx = MqSlaveGetProxy_e (mqctx, MQ_SLAVE_OTHER);
  MqEnvProtect(otherCtx);
  ret = PkgToGrx2 ( MK_RT_CALL mqctx, "+GRP", otherCtx, mqctx->link.protect.transLId);
  MqEnvRestore(otherCtx);
  MkErrorCheck (ret);
 
done:
  return MqSendRETURN(mqctx);
error:
  MkErrorStack_1X(mqctx);
  goto done;
}
 
// this code is used on a client to read the answer of a \e longterm-transaction
static enum MkErrorE
TrtToGrt ( MQ_SERVICE_CALL_ARGS )
{
  MQ_LTR rmtTransLIdOrig = mqctx->link.protect.rmtTransLId;
 
  MkDLogV(mqctx,6,"work on 'transLId=" MK_FORMAT_T "'\n", rmtTransLIdOrig);
 
  if (rmtTransLIdOrig < 0) {
 
    MkErrorSetC_1XS ("internal-error: unable to GUARD a SEND-LTT");
    goto error;
 
  } else if (rmtTransLIdOrig > 0) {
    MQ_LTR        otherLId;
    MQ_CTX otherCtx;
    enum MkErrorE ret;
 
    // step 1. -> get the "original" transaction of "mqctx->link.protect.rmtTransLId" from DB
    MkErrorCheck (MqStorageResolve (mqctx, &otherCtx, &otherLId));
 
    // step 2. -> send data
    MqEnvProtect(otherCtx);
    ret = PkgToGrx2 ( MK_RT_CALL mqctx, "+GRT", otherCtx, otherLId);
    MqEnvRestore(otherCtx);
    MkErrorCheck (ret);
 
  } else {
    MkPanicSYS (mqctx);
  }
 
done:
  MqStorageDelete (mqctx, &mqctx->link.protect.transLId);
  return MqSendRETURN(mqctx);
error:
  MkErrorStack_1X (mqctx);
  goto done;
}
 
// goal is to "RETURN" an Error in an encrypted package.
static enum MkErrorE
GrxToPkgError (
  MK_RT_ARGS MQ_CTX const  mqctx
) {
  if (MkErrorIsEXIT_0E()) {
    return MkErrorGetCode_0E();
  } else {
 
    // goal → make a "guard" error package
    check_MqError   (MqDumpError          (mqctx, &myctx->dump))  goto error_in_error;
 
    MkBinaryR bin = MqDumpBinGet          (myctx->dump);
 
    // encrypt
                    guard_crypt           (bin.data, bin.size, ENCRYPT);
 
    // prepare binary package
    check_MqError   (MqSendSTART (mqctx))                 goto error_in_error;
    check_MqError   (MqSendBIN              (mqctx, bin))   goto error_in_error;
    return MK_CONTINUE;
  }
 
error_in_error:
  MkErrorPrintln_1M (mqctx);
  return MK_OK;
}
 
#define GuardReturn(PROC) \
switch (PROC) {\
  case MK_OK:       return MK_OK; \
  case MK_CONTINUE: goto done; \
  default:          return MkErrorStack_1X (META_CONTEXT_S); \
}
 
static enum MkErrorE
GrxToPkg2 (
  MK_RT_ARGS MQ_CTX const  mqctx,
  MQ_TOK const  intoken,
  MQ_CTX const  otherCtx,
  MQ_LTR        otherLId
) {
  enum MqHandShakeE hs        = mqctx->link.protect.handShake;
  enum MqTransTypeE tt        = mqctx->link.protect.transType;
  struct MqDumpS    *dump     = NULL;
  enum MkErrorE     ret       = MK_OK;
  MK_STRB           token[5]  = "";
  MkBinaryR         bdat      = {0};
 
/*
->GONE by split PRIVATE and PUBLIC
  if (otherCtx->link.send == NULL) {
    return MkErrorSetV_1XS("the '%s' object link is '%s' connected", "msgque", "not");
  } else 
*/
  if (strncmp (intoken, MqServiceTokenGet(mqctx), 5) != 0) {
    return MkErrorSetV_1XS("expect token '%s' but got token '%s", intoken, MqServiceTokenGet(mqctx));
  }
 
  MqReadBIN_E               (mqctx, &bdat);
  guard_crypt             (bdat.data, bdat.size, DECRYPT);
  MqSendSTART_E           (otherCtx);
 
  if (tt == MQ_TRANS_TYPE_TRANS) {
    // in a "longterm-transaction" with "MqProxyForward" and "MqSendRETURN"…
    // we DONT want any additional message from "MqSendRETURN" send to the "client".
    // with "link.protect.bits.LIdLck = true" the shortterm-transaction will be deleted in
    // "MqSendRETURN->sSendEND" → same as in "MqStorageInsert" or "MqDumpExport"
    //
    //  client.exe
    //    Send("T"…) ->
    //      Filter.exe
    //        Send("R"…) <- ANSWER database INSERT
    //          EventProc
    //            MqProxyForward  // forward to "targetctx"
    //              …
    //            MqSendRETURN    // THIS is the problem, we DON'T want ANY package from there send to client.exe
    //
    mqctx->link.protect.bits.LIdLck = true;
  }  
 
  // the "Dump" is from an other "filter"… the environment is WRONG
  dump =                  (struct MqDumpS*) bdat.data;
 
  MqDumpTransLIdSet       (dump,  mqctx->link.protect.transLId);
  MqDumpRmtTransLIdSet    (dump,  mqctx->link.protect.rmtTransLId);
  strncpy                 (token, MqDumpTokenGet(dump), 4);
  token[4] = '\0';
 
  // this code write the "transLId" also
  MqProxyPackage_E        (mqctx, otherCtx, dump);
 
  if (hs == MQ_HANDSHAKE_START) {
 
    // basically… MqSendEND_AND_WAIT can fail if an ASYNCRONE error arrive… even if
    // LTT was successfull send… if "refCount" will be incr AFTER send… an final "+TRT" will NOT find
    // the according transaction… and will create an ERROR
    if (tt == MQ_TRANS_TYPE_TRANS) {
      MkErrorCheck(MqStorageIncrRef(mqctx,otherLId));
    }
 
    if (mqctx->link.protect.transSId > 0) { // shortterm-transaction
 
      // direction: mqctx -> otherCtx
      switch (tt) {
        case MQ_TRANS_TYPE_CB:
        case MQ_TRANS_TYPE_WAIT:
          ret = MqSendEND_AND_WAIT (otherCtx, token, MK_TIMEOUT_DEFAULT);
          break;
        case MQ_TRANS_TYPE_SUB:
          // protecting of "mqctx" using "refCount" is dangerous… every error break refCount
          ret = MqSendEND_AND_SUB (otherCtx, token, sProxySubCall, mqctx, NULL, MK_TIMEOUT_DEFAULT);
          break;
        case MQ_TRANS_TYPE_TRANS:
          ret = MqSendEND_AND_TRANSACTION (otherCtx, token, NULL, MK_TIMEOUT_DEFAULT);
          break;
        default:
          ret = MkErrorSetV_1XS("protocol-error -> invalid transaction-type: %s", MqTransTypeE_ToString(tt));
          break;
      }
      MkErrorCheck (ret);
 
      // start the answer
      MqSendSTART_E           (mqctx);
 
      // Forward the "answer" of a STT… but only if "other-context" expect an answer
      if (tt != MQ_TRANS_TYPE_TRANS) {
        // answer
        MqDumpExport_E        (otherCtx, &myctx->dump);
        MkBinaryR bin =       MqDumpBinGet(myctx->dump);
 
        // encrypt
        guard_crypt           (bin.data, bin.size, ENCRYPT);
        // prepare binary package
        MqSendBIN_E             (mqctx, bin);
      }
 
    } else { // transSId == 0
      // direction: mqctx -> otherCtx
      switch (tt) {
        case MQ_TRANS_TYPE_NO:
          ret = MqSendEND (otherCtx, token, MK_TIMEOUT_DEFAULT);
          break;
        case MQ_TRANS_TYPE_TRANS:
          ret = MqSendEND_AND_TRANSACTION (otherCtx, token, NULL, 0);
          break;
        default:
          ret = MkErrorSetV_1XS("protocol-error -> invalid transaction-type: %s", MqTransTypeE_ToString(tt));
          break;
      }
      MkErrorCheck (ret);
    }
 
  // direction: client <- server = answer from the service → handShake "O" or "E"
  } else {
    if (mqctx->link.protect.transSId > 0) { // shortterm-transaction, this is only valid for "+TRT"
      switch (tt) {
        case MQ_TRANS_TYPE_TRANS:
          ret = MqSendEND_AND_TRANSACTION (otherCtx, token, NULL, MK_TIMEOUT_DEFAULT);
          break;
        default:
          ret = MkErrorSetV_1XS("protocol-error -> invalid transaction-type: %s", MqTransTypeE_ToString(tt));
          break;
      }
    } else {                                // everything NOT "+TRT"
      switch (tt) {
        case MQ_TRANS_TYPE_NO:
          ret = MqSendEND (otherCtx, token, MK_TIMEOUT_DEFAULT);
          break;
        case MQ_TRANS_TYPE_TRANS:
          ret = MqSendEND_AND_TRANSACTION (otherCtx, token, NULL, 0);
          break;
        default:
          ret = MkErrorSetV_1XS("protocol-error -> invalid transaction-type: %s", MqTransTypeE_ToString(tt));
          break;
      }
    }
    MkErrorCheck (ret);
  }
 
  return MK_OK;
 
error:
  MqContextErrorCopy(mqctx, otherCtx);
  return MkErrorStack_1X(mqctx);
}
 
static enum MkErrorE
GrpToPkg ( MQ_SERVICE_CALL_ARGS )
{
  MQ_CTX otherCtx;
 
  MkErrorCheck (MqSlaveGetProxy (mqctx, MQ_SLAVE_OTHER, &otherCtx));
  MkErrorCheck (GrxToPkg2 ( MK_RT_CALL mqctx, "+GRP", otherCtx, mqctx->link.protect.transLId));
 
done:
  return MqSendRETURN(mqctx);
error:
  MkErrorStack_1X(mqctx);
  GuardReturn(GrxToPkgError( MK_RT_CALL mqctx));
}
 
// this code is used on a client to read the answer of a \e longterm-transaction
static enum MkErrorE
GrtToTrt ( MQ_SERVICE_CALL_ARGS )
{
  MQ_LTR rmtTransLIdOrig = mqctx->link.protect.rmtTransLId;
 
  MkDLogV(mqctx,6,"work on 'transLId=" MK_FORMAT_T "'\n", rmtTransLIdOrig);
 
  if (rmtTransLIdOrig < 0) {
 
    MkErrorSetC_1XS ("internal-error: unable to GUARD a SEND-LTT");
    goto error;
 
  } else if (rmtTransLIdOrig > 0) {
 
    MQ_CTX otherCtx;
    MQ_LTR        otherLId;
 
    // step 1. -> get the "original" transaction of "mqctx->link.protect.rmtTransLId" from DB
    MkErrorCheck (MqStorageResolve (mqctx, &otherCtx, &otherLId));
 
    // step 2. -> "MqSendSTART" use "link.protect.rmtTransLId" to add the LTT to the data-package
    mqctx->link.protect.rmtTransLId = otherLId;
 
    // step 3. -> send data
    MkErrorCheck (GrxToPkg2 ( MK_RT_CALL mqctx, "+GRT", otherCtx, mqctx->link.protect.rmtTransLId));
 
  } else {
    MkErrorSetC_1XS ("internal-error: transLId = 0");
    goto error;
  }
 
done:
  MqStorageDelete (mqctx, &mqctx->link.protect.transLId);
  return MqSendRETURN(mqctx);
error:
  MqStorageDelete (mqctx, &mqctx->link.protect.transLId);
  MkErrorStack_1X (mqctx);
  GuardReturn(GrxToPkgError( MK_RT_CALL mqctx));
}
 
/*****************************************************************************/
/*                                                                           */
/*                                context_init                               */
/*                                                                           */
/*****************************************************************************/
 
#if defined(MQ_BUILD_EXAMPLE)
static void __attribute__ ((noreturn))
FilterHelp (const char * base)
{
  fputs("\n", stderr);
  fprintf(stderr, "usage: %s [OPTION]... [ARGUMENT]...\n", base);
  fputs("\n", stderr);
  fputs("  This tool is the data protection filter of NHI1.\n", stderr);
  fputs("\n", stderr);
  fprintf(stderr, "  %s [ARGUMENT]... syntax:\n", base);
  fprintf(stderr, "    aclient... %c %s ... [tunnel] ... %c %s ... %c aserver\n", MK_ALFA, base, MK_ALFA, base, MK_ALFA);
  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);
}
#endif
 
static enum MkErrorE
FilterCleanup ( MQ_SERVICE_CALL_ARGS )
{
  MqDumpDelete(myctx->dump);
  return MK_OK;
}
 
static enum MkErrorE
FilterSetup ( MQ_SERVICE_CALL_ARGS )
{
  MQ_CTX ftrctx = MqSlaveGetFilter_e (mqctx);
 
  myctx->dump = NULL; 
 
  // SERVER: every token (+ALL) have to be "guard_encrypted"
  MkErrorCheck (MqServiceCreate (mqctx, "+ALL",   PkgToGrp, NULL, NULL, NULL));
  // SERVER: but "+TRT" is special
  MkErrorCheck (MqServiceCreate (mqctx, "+TRT",   TrtToGrt, NULL, NULL, NULL));
  // SERVER: only the "+GR?" token is "guard_decrypted"
  MkErrorCheck (MqServiceCreate (mqctx, "+GRP",   GrpToPkg, NULL, NULL, NULL));
  MkErrorCheck (MqServiceCreate (mqctx, "+GRT",   GrtToTrt, NULL, NULL, NULL));
 
  // CLIENT: every token (+ALL) have to be "guard_encrypted"
  MkErrorCheck (MqServiceCreate (ftrctx, "+ALL",  PkgToGrp, NULL, NULL, NULL));
  // CLIENT: but "+TRT" is special
  MkErrorCheck (MqServiceCreate (ftrctx, "+TRT",  TrtToGrt, NULL, NULL, NULL));
  // CLIENT: only the "+GR?" token is "guard_decrypted"
  MkErrorCheck (MqServiceCreate (ftrctx, "+GRP",  GrpToPkg, NULL, NULL, NULL));
  MkErrorCheck (MqServiceCreate (ftrctx, "+GRT",  GrtToTrt, NULL, NULL, NULL));
 
  return MK_OK;
error:
  return MkErrorStack_1X(mqctx);
}
 
#if defined(USE_BG_ERROR)
static enum MkErrorE
FilterError ( MQ_SERVICE_CALL_ARGS )
{
  // the error-package has the source-context of the error at "MkErrorTLS.errctx"
  // the "other-side" is the target
  MQ_CTX ftrctx = NULL;
  MQ_CTX errctx = MkErrorGetContextI(mqctx);
 
  check_MqError (MqSlaveGetProxy (errctx, MQ_SLAVE_OTHER, &ftrctx)) {
    MqContextErrorCopy(mqctx,errctx);
    return MkErrorStack_1X(mqctx);
  }
 
  // 1. if "ftrctx" != "mqctx"… Master "BgError" was called on slave "_ERR" (token.c)
  // 2. if "ftrctx" == "mqctx"… Master get "_ERR" from client
 
  // shift the error to the "other-side"
  MqContextErrorCopy(ftrctx,mqctx);
  // the "_ERR" has an EMPTY environment… the "MqContextErrorCopy" preserve the LOCAL environment
  // let the environment be EMPTY again
  MkErrorEnvReset();
 
  if (mqctx->link.bits.onCreateEnd == 1) {
 
    // during normal processing
    switch (GrxToPkgError( MK_RT_CALL ftrctx)) {
      case MK_CONTINUE:  MqSendEND (ftrctx, "+GRP", MK_TIMEOUT_DEFAULT);
      case MK_OK:        break;
      case MK_ERROR:     break;
    }
  } else {
    // early startup... services are NOT available…
    return MqSendERROR(ftrctx);
  }
 
  // has "MqSendEND" from abova an error ?
  MqContextErrorCopy(mqctx,ftrctx);
  return MkErrorStack_1X(mqctx);
}
#endif
 
/*****************************************************************************/
/*                                                                           */
/*                                  main                                     */
/*                                                                           */
/*****************************************************************************/
 
static enum MkErrorE
FilterFactory ( MQ_CALLBACK_FACTORY_CTOR_ARGS )
{
  MQ_CTX const mqctx = *contextP = MqContextCreate(AGuardTT,tmpl);
 
  mqctx->setup.isServer             = true;
  mqctx->setup.ServerSetup.fCall    = FilterSetup;
  mqctx->setup.ServerCleanup.fCall  = FilterCleanup;
#if defined(USE_BG_ERROR)
  mqctx->setup.BgError.fCall        = FilterError;
#endif
 
  return MK_OK;
}
 
#if defined(MQ_BUILD_EXAMPLE)
static enum MkErrorE
FilterArgs (MK_RT_ARGS MQ_CTX mqctx, MK_BFL args)
{ 
  return MK_OK;
}
#endif
 
int main ( const int argc, MK_STRN argv[]) 
{
  AllRtSetup_NULL;
 
  // define the new type
  AGuardTT = MkTypeDup2(MqContextC_TT, IDENT "TT");
  AGuardTT->objsize = sizeof(struct AGuardCtxS);
  AGuardT->fHelp = FilterHelp;
 
  // parse the command-line
  MK_BFL args = MkBufferListCreateVC (argc, argv);
  MQ_CTX mqctx = NULL;
 
  // call Factory
  MQ_FCT fct = MqFactoryAdd(MK_ERROR_PANIC, FilterFactory, NULL, NULL, NULL, NULL, NULL, NULL, NULL, IDENT);
  MqFactoryNew_E (fct, NULL, &mqctx);
 
  // filter args
  MkContinueCheck(FilterArgs(MK_RT_CALL mqctx,args));
 
  // create the Link
  MqLinkCreate_E (mqctx, args);
 
  // start event-loop and wait forever
  MqProcessEvent_E (mqctx, MQ_WAIT_FOREVER, MK_TIMEOUT_DEFAULT);
 
  // finish and exit
cont:
error:
  MkBufferListDelete(args);
  MqExit_1 (mqctx);
}