/*****************************************************************************/
/*
                                 Watch.h
*/
/*****************************************************************************/

#ifndef WATCH_H_LOADED
#define WATCH_H_LOADED 1

#include "wasd.h"
#include <stdarg.h>

/**********/
/* macros */
/**********/

/*
   True should cause the compiler to include the module watch statements.
   False should cause the compile to optimize the module statements out.
   This would confer some (perhaps limited) performance benefits.
*/

/* unless otherwise specified the default for category WATCHing is AVAILABLE */
#ifndef WATCH_CAT
#  define WATCH_CAT 1
#endif
/* unless otherwise specified the default for module WATCHing is NONE */
#ifndef WATCH_MOD
#  define WATCH_MOD 0
#endif
/* cannot have WATCH_MOD without WATCH_CAT !!! */
#if WATCH_MOD
#  undef WATCH_CAT
#  define WATCH_CAT 1
#endif

/* number of decimal digits displayed for WATCH item (must be 4, 6, 8, etc.) */
#define WATCH_ITEM_DIGITS 8

/* generate a new item number */
#define WATCH_NEW_ITEM -1
#define WATCH_NEW_TRIGGER -2

/* all WATCH category/module bits set */
#define WATCH_THIS 0xffffffff

/* for the above examples will be 100, 1000, 10000, etc. &/
#define WATCH_ITEM_STREAMID ((int)(pow(10.0,((double)WATCH_ITEM_DIGITS)/2.0)))

/* watch on all occasions */
#define WATCHALL -1, FI_LI

/* test whether this is being WATCHed */
#define WATCHPNT(ptr) (ptr != NULL && (ptr)->WatchItem)

/* test whether this and category item(s) is being WATCHed */
#define WATCHING(ptr,itm) (WATCH_CAT && \
                          (ptr) != NULL && \
                          (ptr)->WatchItem && \
                          (Watch.Category & (itm)))
                          
/* test whether this and module item(s) is being WATCHed */
#define WATCHMOD(ptr,itm) (WATCH_MOD && \
                           (ptr) != NULL && \
                           (ptr)->WatchItem && \
                           ((Watch.Module & (itm)) == itm))

/* dereference the WATCH item number (Include FI_LI) */
#define WATCHITM(ptr) (ptr != NULL ? (ptr)->WatchItem : 0), FI_LI

/* watching the HTTP/2 stream */
#define WATCHING2(ptr) (WATCH_CAT && \
                        (ptr) != NULL && \
                        ((ptr)->WatchItem & WATCH_ITEM_HTTP2_FLAG))

/* watching the one (shot) request */
#define WATCHING1S(ptr) (WATCH_CAT && \
                         (ptr) != NULL && \
                         ((ptr)->WatchItem & WATCH_ITEM_ONE_SHOT_FLAG))

/* dereference the WATCH item number (Exclude FI_LI) */
#define WATCH_ITM(ptr) (ptr != NULL ? (ptr)->WatchItem : 0)

/* bit set in the item number indicates WATCHing the HTTP/2 connection */
#define WATCH_ITEM_HTTP2_FLAG   0x20000000  /* 32 bit */

/* bit set in the item number indicates one-shot WATCHing the request */
#define WATCH_ITEM_ONE_SHOT_FLAG   0x10000000  /* 32 bit */

/* mask off the item number from the flag bits */
#define WATCH_ITEM_NUMBER_MASK 0x0fffffff  /* 32 bit */

#define WATCH_CATEGORY(itm) (WATCH_CAT && (Watch.Category & itm))
#define WATCH_MODULE(itm) (WATCH_MOD && ((Watch.Module & itm) == itm))

#define WATCH_CONNECT                   0x01
#define WATCH_REQUEST                   0x02
#define WATCH_REQUEST_BODY              0x04
#define WATCH_REQUEST_HEADER            0x08
#define WATCH_RESPONSE                 0x010
#define WATCH_RESPONSE_BODY            0x020
#define WATCH_RESPONSE_HEADER          0x040
#define WATCH_MAPPING                  0x080
#define WATCH_AUTH                    0x0100
#define WATCH_ERROR                   0x0200
#define WATCH_NETWORK                 0x0400
#define WATCH_NETWORK_OCTETS          0x0800
#define WATCH_INTERNAL               0x01000
#define WATCH_LOG                    0x02000
#define WATCH_SESOLA                 0x04000
#define WATCH_CGI                    0x08000
#define WATCH_DCL                   0x010000
#define WATCH_DECNET                0x020000
#define WATCH_FILTER                0x040000
#define WATCH_PROXY                 0x080000
#define WATCH_PROXY_REQU_HDR       0x0100000
#define WATCH_PROXY_REQU_BDY       0x0200000
#define WATCH_PROXY_RESP_HDR       0x0400000
#define WATCH_PROXY_RESP_BDY       0x0800000
#define WATCH_PROXY_REWORK        0x01000000
#define WATCH_SCRIPT              0x02000000
#define WATCH_HTTP2               0x04000000
#define WATCH_WEBDAV              0x08000000
#define WATCH_MATCH               0x10000000
#define unused_one                0x20000000
#define unused_two                0x40000000
/* then two reserved bits and ... */
#define WATCH_ONE_SHOT_FLAG       0x80000000

#define WATCH_NOT_ONE_SHOT(cat) (cat && !(cat & WATCH_ONE_SHOT_FLAG))

#define WATCH_CAT_MASK            0x1fffffff
#define WATCH_MOD_MASK            0x7fffffff

/* indicates this is a module not a category item */
#define WATCH_MODULE_FLAG         0x80000000

#define WATCH_MOD_FILE                 (0x01 | WATCH_MODULE_FLAG)
#define WATCH_MOD_CACHE                (0x02 | WATCH_MODULE_FLAG)
#define WATCH_MOD_ODS                  (0x04 | WATCH_MODULE_FLAG)
#define WATCH_MOD_REQUEST              (0x08 | WATCH_MODULE_FLAG)
#define WATCH_MOD_VM                  (0x010 | WATCH_MODULE_FLAG)
#define WATCH_MOD_SSI                 (0x020 | WATCH_MODULE_FLAG)
#define WATCH_MOD_DCL                 (0x040 | WATCH_MODULE_FLAG)
#define WATCH_MOD_DIR                 (0x080 | WATCH_MODULE_FLAG)
#define WATCH_MOD_AUTH               (0x0100 | WATCH_MODULE_FLAG)
#define WATCH_MOD_FAO                (0x0200 | WATCH_MODULE_FLAG)
#define WATCH_MOD_THROTTLE           (0x0400 | WATCH_MODULE_FLAG)
#define WATCH_MOD_INSTANCE           (0x0800 | WATCH_MODULE_FLAG)
#define WATCH_MOD_MAPURL            (0x01000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_PROXY             (0x02000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_NET               (0x04000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_SESOLA            (0x08000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_CGI              (0x010000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_WEBDAV           (0x020000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_HTADMIN          (0x040000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_DECNET           (0x080000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_UPD             (0x0100000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_PUT             (0x0200000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_MSG             (0x0400000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_SERVICE         (0x0800000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_CONFIG         (0x01000000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_METACON        (0x02000000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_RESPONSE       (0x04000000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_BODY           (0x08000000 | WATCH_MODULE_FLAG)
#define WATCH_MOD_HTTP2          (0x10000000 | WATCH_MODULE_FLAG)
#define WATCH_MOD__DETAIL        (0x20000000 | WATCH_MODULE_FLAG)
#define WATCH_MOD__OTHER         (0x40000000 | WATCH_MODULE_FLAG)

#define WATCH_CATEGORY_LIST_SIZE 1024
#define WATCH_FILTER_SIZE 64
#define WATCH_NAME_SIZE 64
#define WATCH_NAME_DEFAULT "WASD_SERVER_LOGS:WATCH_DEFAULT.LOG"
#define WATCH_TRIGGER_SIZE 64

/*************/
/* structure */
/*************/

typedef struct WatchEnableStruct WATCH_STRUCT;

struct WatchEnableStruct
{
   BOOL  CliEnabled,
         CliNoStartup,
         Disabled,
         DoPeek,
         DoWatch,
         EndWatch,
         FilterHttp09,
         FilterHttp10,
         FilterHttp11,
         FilterHttp2,
         FilterSet,
         FilterOutClient,
         FilterOutHttp,
         FilterOutRealm,
         FilterOutRequest,
         FilterOutService,
         FilterOutURI,
         FilterOutUser,
         TriggerPlus;

   int  ByteCount,
        ConnectNumber,
        DurationSeconds,
        FilterStatus,
        ItemCount,
        ItemDigits,
        ItemPower2,
        ItemWidth,
        LogFile,
        SecondsToGo,
        TriggerRxCount,
        TriggerTxCount;

   /* 64 bits but only 32 currently in use */
   int64  Category,
          Category2,
          Module,
          Module2;

   char  LogFileName [WATCH_NAME_SIZE],
         FilterClient [WATCH_FILTER_SIZE],
         FilterRealm [WATCH_FILTER_SIZE],
         FilterRequest [WATCH_FILTER_SIZE],
         FilterService [WATCH_FILTER_SIZE],
         FilterUri [WATCH_FILTER_SIZE],
         FilterUser [WATCH_FILTER_SIZE],
         TriggerRx [WATCH_TRIGGER_SIZE],
         TriggerTx [WATCH_TRIGGER_SIZE];

   STR_DSC  BufferDsc;

   /* when non-NULL WATCH has an outstanding AST */
   REQUEST_AST  AstInUse;

   HTTP2_STRUCT  *Http2Ptr;
   REQUEST_STRUCT  *RequestPtr;

   FILE  *LogFileOut;
};

/***********************/
/* function prototypes */
/***********************/

void WatchAlertQuotas ();
void WatchBegin (REQUEST_STRUCT*);
void WatchBegin2 (REQUEST_STRUCT*);
void WatchBreakDetect (REQUEST_STRUCT*);
BOOL WatchCliParse (char*);
void WatchCliSettings (BOOL);
void WatchData (char*, int);
void WatchDataDump (char*, int);
void WatchDataDumpAt (char*, int, int);
void WatchDataFormatted (char*, ...);
void WatchDuration (int64*, char*, int);
void WatchEnd ();
void WatchModuleLine (char*, int);
#define WATCHMOLI WatchModuleLine (WASD_MODULE, __LINE__)
void WatchFilterAdd (REQUEST_STRUCT*, char*);
void WatchFilterClientService (REQUEST_STRUCT*);
void WatchFilterDrop (REQUEST_STRUCT*, char*);
void WatchFilterHttpProtocol (REQUEST_STRUCT*);
void WatchFilterHttpStatus (REQUEST_STRUCT*);
void WatchFilterPathTrack (REQUEST_STRUCT*);
void WatchFilterRealmUser (REQUEST_STRUCT*);
void WatchFilterRequestHeader (REQUEST_STRUCT*);
char* WatchFunction (void*);
BOOL WatchInUse (REQUEST_STRUCT*);
void WatchItemSize (REQUEST_STRUCT*);
void WatchNewLog (REQUEST_STRUCT*);
char* WatchNewLogName ();
void WatchNone (int);
void WatchPeek (REQUEST_STRUCT*, REQUEST_STRUCT*);
void WatchPeekNetIo (REQUEST_STRUCT*, NETIO_STRUCT*, char*);
void WatchPeekDcl (REQUEST_STRUCT*, DCL_TASK*);
void WatchPeekHttp2 (REQUEST_STRUCT*, HTTP2_STRUCT*, char*);
int WatchRabitHole ();
void WatchReport (REQUEST_STRUCT*);
void WatchReportStruct (REQUEST_STRUCT*);
void WatchReset ();
char* WatchServerQuotas (int);
void WatchServerAlertQuotas ();
int WatchSetTrigger (NETIO_STRUCT*);
int WatchSetWatch (REQUEST_STRUCT*, int);
void WatchShowCluster (REQUEST_STRUCT*);
void WatchShowEnd (REQUEST_STRUCT*);
void WatchShowProcess (REQUEST_STRUCT*, char*, char*);
void WatchShowProcessDeleteEnd (REQUEST_STRUCT*);
void WatchShowSystem (REQUEST_STRUCT*);
void WatchThis (int, char*, int, int64, char*, ...);
void WatchTimeStamp (int, char*, int);
char* WatchToGo (int);
BOOL WatchTrigger (char*, int, char*);
int WatchVmWrite (struct dsc$descriptor*, REQUEST_STRUCT*);
void WatchVmZone (REQUEST_STRUCT*, ulong);
char* WatchWhatCategory (int64);
char* WatchWhatModule (int64);
void WatchWrite (void*, uint);
void WatchWriteAst (REQUEST_STRUCT*);

#endif /* WATCH_H_LOADED */

/*****************************************************************************/
