aguard.c File Reference

aguard.c - 25 Aug 2024 - aotto1968 More...

#include "common.h"
#include "aguard_crypt.h"

Include dependency graph for aguard.c:

Go to the source code of this file.

Data Structures
struct	AGuardCtxS

Macros
#define	META_FILE_NAME   "AGuard.c"
#define	META_CONTEXT_S   mqctx
#define	ENCRYPT   true
#define	DECRYPT   false
#define	AGuardT   ((typeof(MqContextC_T)) AGuardTT)
#define	check_MqError(E)
#define	myctx   ((struct AGuardCtxS*)META_CONTEXT_S)
#define	MqReadDump_E(mqctx, dumpP)
#define	GuardReturn(PROC)

Functions
static enum MkErrorE	sProxySubCall (MK_RT mkrt, MQ_CTX const targetCtx, MK_PTR const data)
static enum MkErrorE	MqReadDump (MK_RT mkrt, MQ_CTX const mqctx, struct MqDumpS **dumpP)
static enum MkErrorE	PkgToGrx2 (MK_RT mkrt, MQ_CTX const mqctx, MQ_TOK const token, MQ_CTX const otherCtx, MQ_LTR otherLId)
static enum MkErrorE	PkgToGrp (MQ_SERVICE_CALL_ARGS)
static enum MkErrorE	TrtToGrt (MQ_SERVICE_CALL_ARGS)
static enum MkErrorE	GrxToPkgError (MK_RT mkrt, MQ_CTX const mqctx)
static enum MkErrorE	GrxToPkg2 (MK_RT mkrt, MQ_CTX const mqctx, MQ_TOK const intoken, MQ_CTX const otherCtx, MQ_LTR otherLId)
static enum MkErrorE	GrpToPkg (MQ_SERVICE_CALL_ARGS)
static enum MkErrorE	GrtToTrt (MQ_SERVICE_CALL_ARGS)
static enum MkErrorE	FilterCleanup (MQ_SERVICE_CALL_ARGS)
static enum MkErrorE	FilterSetup (MQ_SERVICE_CALL_ARGS)
static enum MkErrorE	FilterFactory (MQ_CALLBACK_FACTORY_CTOR_ARGS)
int	main (const int argc, MK_STRN argv[])

Variables
static MK_TYP	AGuardTT = NULL

Detailed Description

aguard.c - 25 Aug 2024 - aotto1968

Copyright

(C) NHI - #1 - Project - Group This software has NO permissions to copy, please contact AUTHOR for additional information

Version

c3b28928437a81158df1f3cafe23fbded7b34813

Date

Sun Aug 25 22:59:57 2024 +0200

Author

aotto1968 aotto.nosp@m.1968.nosp@m.@t-on.nosp@m.line.nosp@m..de

Definition in file aguard.c.

Macro Definition Documentation

AGuardT

#define AGuardT   ((typeof(MqContextC_T)) AGuardTT)

Definition at line 35 of file aguard.c.

check_MqError

#define check_MqError

(

E

)

Value:

if (MkErrorCheckI(E))

Definition at line 46 of file aguard.c.

DECRYPT

#define DECRYPT   false

Definition at line 23 of file aguard.c.

ENCRYPT

#define ENCRYPT   true

Definition at line 22 of file aguard.c.

GuardReturn

#define GuardReturn

(

PROC

)

Value:

switch (PROC) {\
  case MK_OK:       return MK_OK; \
  case MK_CONTINUE: goto done; \
  default:          return MkErrorStack_1X (META_CONTEXT_S); \
}

Definition at line 319 of file aguard.c.

#define GuardReturn(PROC) \
switch (PROC) {\
  case MK_OK:       return MK_OK; \
  case MK_CONTINUE: goto done; \
  default:          return MkErrorStack_1X (META_CONTEXT_S); \
}

META_CONTEXT_S

#define META_CONTEXT_S   mqctx

Definition at line 20 of file aguard.c.

META_FILE_NAME

#define META_FILE_NAME   "AGuard.c"

Definition at line 14 of file aguard.c.

MqReadDump_E

#define MqReadDump_E	(		mqctx,
			dumpP )

Value:

if (MkErrorCheckI(MqReadDump( MK_RT_CALL mqctx,dumpP))) goto error

Definition at line 81 of file aguard.c.

myctx

#define myctx   ((struct AGuardCtxS*)META_CONTEXT_S)

Definition at line 53 of file aguard.c.

Function Documentation

FilterCleanup()

static enum MkErrorE FilterCleanup ( MQ_SERVICE_CALL_ARGS )

static

Definition at line 563 of file aguard.c.

{
  MqDumpDelete(myctx->dump);
  return MK_OK;
}

Here is the caller graph for this function:

FilterFactory()

static enum MkErrorE FilterFactory ( MQ_CALLBACK_FACTORY_CTOR_ARGS )

static

Definition at line 646 of file aguard.c.

{
  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;
}

Here is the caller graph for this function:

FilterSetup()

static enum MkErrorE FilterSetup ( MQ_SERVICE_CALL_ARGS )

static

Definition at line 570 of file aguard.c.

{
  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);
}

Here is the caller graph for this function:

GrpToPkg()

static enum MkErrorE GrpToPkg ( MQ_SERVICE_CALL_ARGS )

static

Definition at line 479 of file aguard.c.

{
  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));
}

Here is the caller graph for this function:

GrtToTrt()

static enum MkErrorE GrtToTrt ( MQ_SERVICE_CALL_ARGS )

static

Definition at line 495 of file aguard.c.

{
  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));
}

Here is the caller graph for this function:

GrxToPkg2()

static enum MkErrorE GrxToPkg2 ( MK_RT mkrt, MQ_CTX const mqctx, MQ_TOK const intoken, MQ_CTX const otherCtx, MQ_LTR otherLId )

static

Definition at line 327 of file aguard.c.

  {
  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);
}

Here is the caller graph for this function:

GrxToPkgError()

static enum MkErrorE GrxToPkgError ( MK_RT mkrt, MQ_CTX const mqctx )

static

Definition at line 293 of file aguard.c.

  {
  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;
}

Here is the caller graph for this function:

main()

int main	(	const int	argc,
		MK_STRN	argv[] )

Definition at line 668 of file aguard.c.

{
  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);
}

MqReadDump()

static enum MkErrorE MqReadDump ( MK_RT mkrt, MQ_CTX const mqctx, struct MqDumpS ** dumpP )

inlinestatic

Definition at line 71 of file aguard.c.

  {
  MkBinaryR out;
  enum MkErrorE ret = MqReadBIN (mqctx, &out);
  *dumpP = (struct MqDumpS *)out.data;
  MkErrorReturn (ret);
}

PkgToGrp()

static enum MkErrorE PkgToGrp ( MQ_SERVICE_CALL_ARGS )

static

Definition at line 235 of file aguard.c.

{
  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;
}

Here is the caller graph for this function:

PkgToGrx2()

static enum MkErrorE PkgToGrx2 ( MK_RT mkrt, MQ_CTX const mqctx, MQ_TOK const token, MQ_CTX const otherCtx, MQ_LTR otherLId )

static

Definition at line 84 of file aguard.c.

{
  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;
}

Here is the caller graph for this function:

sProxySubCall()

static enum MkErrorE sProxySubCall ( MK_RT mkrt, MQ_CTX const targetCtx, MK_PTR const data )

static

Definition at line 56 of file aguard.c.

{
  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);
}

Here is the caller graph for this function:

TrtToGrt()

static enum MkErrorE TrtToGrt ( MQ_SERVICE_CALL_ARGS )

static

Definition at line 254 of file aguard.c.

{
  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;
}

Here is the caller graph for this function:

Variable Documentation

AGuardTT

MK_TYP AGuardTT = NULL

static

Definition at line 34 of file aguard.c.