/*****************************************************************************/
/*
                                 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

/* 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   0x08000000

/* bit set in the item number indicates WATCHing the HTTP/2 connection */
#define WATCH_ITEM_ONE_SHOT_FLAG   0x10000000

/* mask off the item number from the flag bits */
#define WATCH_ITEM_NUMBER_MASK 0x00fffffff

#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_CACHE         0x01000000
#define WATCH_SCRIPT              0x02000000
#define WATCH_HTTP2               0x04000000
#define WATCH_WEBDAV              0x08000000
#define WATCH_MATCH               0x10000000
#define WATCH_reserved1           0x20000000
#define WATCH_reserved2           0x40000000
#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)

/* reserve -1 as an easy way to use /WATCH= */
#define WATCH_ONE_SHOT_CAT        (-1)
#define WATCH_ONE_SHOT_MOD        (-1 & ~WATCH_MOD_FAO)

#define WATCH_CATEGORY_LIST_SIZE 1024
#define WATCH_FILTER_SIZE 128

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

typedef struct WatchEnableStruct WATCH_STRUCT;

struct WatchEnableStruct
{
   BOOL  CliEnabled,
         CliNoStartup,
         Disabled,
         DoPeek,
         DoWatch,
         EndWatch,
         FilterSet,
         FilterOutClient,
         FilterOutHttp,
         FilterOutRealm,
         FilterOutRequest,
         FilterOutService,
         FilterOutURI,
         FilterOutUser,
         HttpFilter09,
         HttpFilter10,
         HttpFilter11,
         HttpFilter2,
         StdoutOnly,
         StdoutToo;

   int  Category,
        Category2,
        ConnectNumber,
        DurationSeconds,
        ItemCount,
        ItemDigits,
        ItemPower2,
        ItemWidth,
        Module,
        Module2,
        StatusFilter;

   char  ClientFilter [WATCH_FILTER_SIZE],
         PathFilter [WATCH_FILTER_SIZE],
         RealmFilter [WATCH_FILTER_SIZE],
         RequestFilter [WATCH_FILTER_SIZE],
         ServiceFilter [WATCH_FILTER_SIZE],
         UserFilter [WATCH_FILTER_SIZE];

   STR_DSC  BufferDsc;

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

   REQUEST_STRUCT  *RequestPtr;
};

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

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 WatchDataFormatted (char*, ...);
void WatchEnd ();
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*, BOOL);
void WatchItemSize (REQUEST_STRUCT*);
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*);
BOOL WatchRabbitHole (WATCH_STRUCT*, REQUEST_STRUCT*);
void WatchReport (REQUEST_STRUCT*);
void WatchReportStruct (REQUEST_STRUCT*);
void WatchReset ();
#ifndef __VAX
unsigned __int64 WatchRPCC (NETIO_STRUCT*, int, char*, int);
#else
unsigned long WatchRPCC (NETIO_STRUCT*, int, char*, int);
#endif
char* WatchServerQuotas ();
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, int, char*, ...);
int WatchVmWrite (struct dsc$descriptor*, REQUEST_STRUCT*);
void WatchVmZone (REQUEST_STRUCT*, ulong);
char* WatchWhatCategory (uint);
char* WatchWhatModule (uint);
void WatchWrite (void*, uint);
void WatchWriteAst (REQUEST_STRUCT*);

#endif /* WATCH_H_LOADED */

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