windows-server-2003/ds/netapi/svcimgs/ntrepl/inc/replutil.h

/*++

Copyright (c) 1997-1999 Microsoft Corporation

Module Name:

    replutil.h

Abstract:

    Header file for utility routines for the NT File Replication Service.

Author:

    David A. Orbits (davidor)  3-Mar-1997 Created

Environment:

    User Mode Service

Revision History:

--*/
#ifndef _REPLUTIL_INCLUDED_
#define _REPLUTIL_INCLUDED_
#endif

#ifdef __cplusplus
extern "C" {
#endif



#include <frserror.h>

#include <config.h>


#define BACKSLASH_CHAR  TEXT('\\')
#define COLON_CHAR      TEXT(':')
#define DOT_CHAR        TEXT('.')

#define UNICODE_STAR    (L'*')
#define UNICODE_QMARK   (L'?')
#define UNICODE_SPACE   0x0020
#define UNICODE_TAB     0x0009


#define TIME_STRING_LENGTH 32
//
// The maximum length of a volume label.  This is defined in ntos\inc\io.h
// but since this is the only def needed from io.h it is copied here.  sigh!
//
#define MAXIMUM_VOLUME_LABEL_LENGTH  (32 * sizeof(WCHAR)) // 32 characters

#define GUID_CHAR_LEN 40

#define OBJECT_ID_LENGTH  sizeof(GUID)
#define FILE_ID_LENGTH    sizeof(ULONGLONG)

//#define GUIDS_EQUAL(_a_, _b_) (memcmp((_a_), (_b_), sizeof(GUID)) == 0)

__inline
int
GuidsEqual( GUID UNALIGNED * a, GUID UNALIGNED * b){
            return (memcmp( a, b, sizeof(GUID)) == 0);
}

#define GUIDS_EQUAL(_a_, _b_) GuidsEqual((GUID UNALIGNED *)(_a_), (GUID UNALIGNED *)(_b_))

//#define COPY_GUID(_a_, _b_)    CopyMemory((_a_), (_b_), sizeof(GUID))

__inline
VOID
CopyGuid( GUID UNALIGNED * a, GUID UNALIGNED * b){
            CopyMemory( a, b, sizeof(GUID));
}

#define COPY_GUID(_a_, _b_)    CopyGuid((GUID UNALIGNED *)(_a_), (GUID UNALIGNED *)(_b_))

#define IS_GUID_ZERO(_g_) ((*((PULONG)(_g_)+0) |                     \
                            *((PULONG)(_g_)+1) |                     \
                            *((PULONG)(_g_)+2) |                     \
                            *((PULONG)(_g_)+3) ) == 0)


//#define COPY_TIME(_a_, _b_)   CopyMemory((_a_), (_b_), sizeof(FILETIME))

__inline
VOID
CopyTime( FILETIME UNALIGNED * a, FILETIME UNALIGNED * b){
            CopyMemory( a, b, sizeof(FILETIME));
}

#define COPY_TIME(_a_, _b_)   CopyTime((FILETIME UNALIGNED *)(_a_), (FILETIME UNALIGNED *)(_b_))

#define IS_TIME_ZERO(_g_) ((*((PULONG)(&(_g_))+0) | *((PULONG)(&(_g_))+1) ) == 0)

//
// A few macros for working with MD5 checksums.
//
#define IS_MD5_CHKSUM_ZERO(_x_)                                              \
    (((*(((PULONG) (_x_))+0)) | (*(((PULONG) (_x_))+1)) |                    \
      (*(((PULONG) (_x_))+2)) | (*(((PULONG) (_x_))+3)) ) == (ULONG) 0)

#define MD5_EQUAL(_a_, _b_) (memcmp((_a_), (_b_), MD5DIGESTLEN) == 0)



//
// Is a handle valid?
//      Some functions set the handle to NULL and some to
//      INVALID_HANDLE_VALUE (-1). This define handles both
//      cases.
//
#define HANDLE_IS_VALID(_Handle)  ((_Handle) && ((_Handle) != INVALID_HANDLE_VALUE))

//
// Only close valid handles and then set the handle invalid.
//   FRS_CLOSE(handle);
//
#define FRS_CLOSE(_Handle)                                                   \
    if (HANDLE_IS_VALID(_Handle)) {                                          \
        CloseHandle(_Handle);                                                \
        (_Handle) = INVALID_HANDLE_VALUE;                                    \
    }

//
// Only close valid registry key handles and then set the handle invalid.
//   FRS_REG_CLOSE(handle);
//
#define FRS_REG_CLOSE(_Handle)                                                   \
    if (HANDLE_IS_VALID(_Handle)) {                                          \
        RegCloseKey(_Handle);                                                \
        (_Handle) = INVALID_HANDLE_VALUE;                                    \
    }

#define FRS_FIND_CLOSE(_Handle)                                                   \
    if (HANDLE_IS_VALID(_Handle)) {                                          \
        FindClose(_Handle);                                                \
        (_Handle) = INVALID_HANDLE_VALUE;                                    \
    }


DWORD
FrsResetAttributesForReplication(
    PWCHAR  Name,
    HANDLE  Handle
    );

LONG
FrsIsParent(
    IN PWCHAR   Directory,
    IN PWCHAR   Path
    );

LPTSTR
FrsSupInitPath(
    OUT LPTSTR OutPath,
    IN  LPTSTR InPath,
    IN  ULONG  MaxOutPath
    );

ULONG
FrsForceDeleteFile(
    PTCHAR DestName
    );

VOID
FrsForceDeleteFileByWildCard(
    PWCHAR      DirPath,
    PWCHAR      WildCard
    );

HANDLE
FrsCreateEvent(
    IN  BOOL    ManualReset,
    IN  BOOL    InitialState
    );

HANDLE
FrsCreateWaitableTimer(
    IN  BOOL    ManualReset
    );

ULONG
FrsUuidCreate(
    OUT GUID *Guid
    );

VOID
FrsNowAsFileTime(
    IN  PLONGLONG   Now
    );

VOID
FileTimeToString(
    IN FILETIME *FileTime,
    OUT PCHAR    Buffer         // buffer must be at least 32 bytes long.
    );


VOID
FileTimeToStringClockTime(
    IN FILETIME *FileTime,
    OUT PCHAR     Buffer        // buffer must be at least 9 bytes long.
    );


DWORD
GeneralizedTimeToSystemTime(
    IN PWCHAR          szTime,
    OUT PSYSTEMTIME    psysTime
    );

VOID
FormatGeneralizedTime(
    IN PWCHAR  GTimeStr,
    IN ULONG   Length,
    OUT PCHAR  Buffer
    );

VOID
GuidToStr(
    IN GUID  *pGuid,
    OUT PCHAR  s
    );

VOID
GuidToStrW(
    IN GUID  *pGuid,
    OUT PWCHAR  ws
    );

BOOL
StrWToGuid(
    IN  PWCHAR  ws,
    OUT GUID  *pGuid
    );

VOID
StrToGuid(
    IN PCHAR  s,
    OUT GUID  *pGuid
    );

NTSTATUS
SetupOnePrivilege (
    ULONG Privilege,
    PUCHAR PrivilegeName
    );

PWCHAR
FrsGetResourceStr(
    LONG  Id
);


//
// Convenient DesiredAccess
//
#define READ_ATTRIB_ACCESS  (FILE_READ_ATTRIBUTES | SYNCHRONIZE)

#define WRITE_ATTRIB_ACCESS  (FILE_WRITE_ATTRIBUTES | SYNCHRONIZE)

#define READ_ACCESS         (GENERIC_READ | GENERIC_EXECUTE | SYNCHRONIZE)

#define ATTR_ACCESS         (READ_ACCESS  | FILE_WRITE_ATTRIBUTES)

#define WRITE_ACCESS        (GENERIC_WRITE | GENERIC_EXECUTE | SYNCHRONIZE)

#define RESTORE_ACCESS      (READ_ACCESS        | \
                             WRITE_ACCESS       | \
                             WRITE_DAC          | \
                             WRITE_OWNER)

#define OPLOCK_ACCESS       (FILE_READ_ATTRIBUTES)

//
// Convenient CreateOptions
//
#define OPEN_OPTIONS        (FILE_OPEN_FOR_BACKUP_INTENT     | \
                             FILE_SEQUENTIAL_ONLY            | \
                             FILE_OPEN_NO_RECALL             | \
                             FILE_OPEN_REPARSE_POINT         | \
                             FILE_SYNCHRONOUS_IO_NONALERT)
#define ID_OPTIONS          (OPEN_OPTIONS | FILE_OPEN_BY_FILE_ID)

#define OPEN_OPLOCK_OPTIONS (FILE_RESERVE_OPFILTER | FILE_OPEN_REPARSE_POINT)
#define ID_OPLOCK_OPTIONS   (FILE_OPEN_FOR_BACKUP_INTENT | \
                             FILE_RESERVE_OPFILTER       | \
                             FILE_OPEN_REPARSE_POINT     | \
                             FILE_OPEN_BY_FILE_ID)

//
// convenient ShareMode
//
#define SHARE_ALL   (FILE_SHARE_READ |  \
                     FILE_SHARE_WRITE | \
                     FILE_SHARE_DELETE)
#define SHARE_NONE  (0)

//
// File attributes that prevent installation and prevent
// hammering the object id.
//
#define NOREPL_ATTRIBUTES   (FILE_ATTRIBUTE_READONLY | \
                             FILE_ATTRIBUTE_SYSTEM   | \
                             FILE_ATTRIBUTE_HIDDEN)

DWORD
FrsOpenSourceFileW(
    OUT PHANDLE     Handle,
    IN  LPCWSTR     lpFileName,
    IN  ACCESS_MASK DesiredAccess,
    IN  ULONG       CreateOptions
    );

DWORD
FrsOpenSourceFile2W(
    OUT PHANDLE     Handle,
    IN  LPCWSTR     lpFileName,
    IN  ACCESS_MASK DesiredAccess,
    IN  ULONG       CreateOptions,
    IN  ULONG       ShareMode
    );

DWORD
FrsCheckReparse(
    IN     PWCHAR Name,
    IN     PVOID  Id,
    IN     DWORD  IdLen,
    IN     HANDLE VolumeHandle
    );

DWORD
FrsDeleteReparsePoint(
    IN  HANDLE  Handle
    );

DWORD
FrsChaseSymbolicLink(
    IN  PWCHAR  SymLink,
    OUT PWCHAR  *OutPrintName,
    OUT PWCHAR  *OutSubstituteName
    );

DWORD
FrsTraverseReparsePoints(
    IN  PWCHAR  SuppliedPath,
    OUT PWCHAR  *RealPath
    );

DWORD
FrsOpenSourceFileById(
    OUT PHANDLE     Handle,
    OUT PFILE_NETWORK_OPEN_INFORMATION  FileOpenInfo,
    OUT OVERLAPPED  *OverLap,
    IN  HANDLE      VolumeHandle,
    IN  PVOID       ObjectId,
    IN  ULONG       Length,
    IN  ACCESS_MASK DesiredAccess,
    IN  ULONG       CreateOptions,
    IN  ULONG       ShareMode,
    IN  ULONG       CreateDispostion
    );

PWCHAR
FrsGetFullPathByHandle(
    IN PWCHAR   Name,
    IN HANDLE   Handle
    );

PWCHAR
FrsGetRelativePathByHandle(
    IN PWCHAR   Name,
    IN HANDLE   Handle
    );

DWORD
FrsCreateFileRelativeById(
    OUT PHANDLE Handle,
    IN  HANDLE  VolumeHandle,
    IN  PVOID   ParentObjectId,
    IN  ULONG   OidLength,
    IN  ULONG   FileCreateAttributes,
    IN  PWCHAR  BaseFileName,
    IN  USHORT  FileNameLength,
    IN  PLARGE_INTEGER  AllocationSize,
    IN  ULONG           CreateDisposition,
    IN  ACCESS_MASK     DesiredAccess
    );

DWORD
FrsCreateFileRelativeById2(
    OUT PHANDLE Handle,
    IN  HANDLE  VolumeHandle,
    IN  PVOID   ParentObjectId,
    IN  ULONG   OidLength,
    IN  ULONG   FileCreateAttributes,
    IN  PWCHAR  BaseFileName,
    IN  USHORT  FileNameLength,
    IN  PLARGE_INTEGER  AllocationSize,
    IN  ULONG           CreateDisposition,
    IN  ACCESS_MASK     DesiredAccess,
    IN  ULONG           ShareMode
    );

DWORD
FrsOpenFileRelativeByName(
    IN  HANDLE     VolumeHandle,
    IN  PULONGLONG FileReferenceNumber,
    IN  PWCHAR     FileName,
    IN  GUID       *ParentGuid,
    IN  GUID       *FileGuid,
    OUT HANDLE     *Handle
    );

typedef struct _QHASH_TABLE_ QHASH_TABLE, *PQHASH_TABLE;
DWORD
FrsDeleteFileRelativeByName(
    IN  HANDLE       VolumeHandle,
    IN  GUID         *ParentGuid,
    IN  PWCHAR       FileName,
    IN  PQHASH_TABLE FrsWriteFilter
    );

DWORD
FrsDeleteFileObjectId(
    IN  HANDLE Handle,
    IN  LPCWSTR FileName
    );

DWORD
FrsGetOrSetFileObjectId(
    IN  HANDLE Handle,
    IN  LPCWSTR FileName,
    IN  BOOL CallerSupplied,
    OUT PFILE_OBJECTID_BUFFER ObjectIdBuffer
    );

DWORD
FrsReadFileUsnData(
    IN  HANDLE Handle,
    OUT USN *UsnBuffer
    );

DWORD
FrsMarkHandle(
    IN HANDLE   VolumeHandle,
    IN HANDLE   Handle
    );

DWORD
FrsReadFileParentFid(
    IN  HANDLE     Handle,
    OUT ULONGLONG *ParentFid
    );

DWORD
FrsDeletePath(
    IN  PWCHAR  Path,
    IN DWORD    DirectoryFlags
    );

DWORD
FrsRestrictAccessToFileOrDirectory(
    PWCHAR  Name,
    HANDLE  Handle,
    BOOL    InheritFromParent,
    BOOL    PushToChildren
    );


VOID
FrsAddToMultiString(
    IN     PWCHAR   AddStr,
    IN OUT DWORD    *IOSize,
    IN OUT DWORD    *IOIdx,
    IN OUT PWCHAR   *IOStr
    );

VOID
FrsCatToMultiString(
    IN     PWCHAR   CatStr,
    IN OUT DWORD    *IOSize,
    IN OUT DWORD    *IOIdx,
    IN OUT PWCHAR   *IOStr
    );

BOOL
FrsSearchArgv(
    IN LONG     ArgC,
    IN PWCHAR  *ArgV,
    IN PWCHAR   ArgKey,
    OUT PWCHAR *ArgValue
    );

BOOL
FrsSearchArgvDWord(
    IN LONG     ArgC,
    IN PWCHAR  *ArgV,
    IN PWCHAR   ArgKey,
    OUT PDWORD  ArgValue
    );

BOOL
FrsDissectCommaList (
    IN UNICODE_STRING RawArg,
    OUT PUNICODE_STRING FirstArg,
    OUT PUNICODE_STRING RemainingArg
    );

BOOL
FrsCheckNameFilter(
    IN  PUNICODE_STRING Name,
    IN  PLIST_ENTRY FilterListHead
    );

VOID
FrsEmptyNameFilter(
    IN PLIST_ENTRY FilterListHead
);

VOID
FrsLoadNameFilter(
    IN PUNICODE_STRING FilterString,
    IN PLIST_ENTRY FilterListHead
);

ULONG
FrsParseIntegerCommaList(
    IN PWCHAR ArgString,
    IN ULONG MaxResults,
    OUT PLONG Results,
    OUT PULONG NumberResults,
    OUT PULONG Offset
);

//
//  Unicode Name support routines, implemented in Name.c
//
//  The routines here are used to manipulate unicode names
//  The code is copied here from FsRtl because it calls the pool allocator.
//

//
//  The following macro is used to determine if a character is wild.
//
#define FrsIsUnicodeCharacterWild(C) (                               \
    (((C) == UNICODE_STAR) || ((C) == UNICODE_QMARK))                \
)

VOID
FrsDissectName (
    IN UNICODE_STRING Path,
    OUT PUNICODE_STRING FirstName,
    OUT PUNICODE_STRING RemainingName
    );

BOOLEAN
FrsDoesNameContainWildCards (
    IN PUNICODE_STRING Name
    );

BOOLEAN
FrsAreNamesEqual (
    IN PUNICODE_STRING ConstantNameA,
    IN PUNICODE_STRING ConstantNameB,
    IN BOOLEAN IgnoreCase,
    IN PCWCH UpcaseTable OPTIONAL
    );

BOOLEAN
FrsIsNameInExpression (
    IN PUNICODE_STRING Expression,
    IN PUNICODE_STRING Name,
    IN BOOLEAN IgnoreCase,
    IN PWCH UpcaseTable OPTIONAL
    );


//
// The following is taken from clusrtl.h
//
//
//  Routine Description:
//
//      Initializes the FRS run time library.
//
//  Arguments:
//
//      RunningAsService  - TRUE if the process is running as an NT service.
//                          FALSE if running as a console app.
//
//  Return Value:
//
//      ERROR_SUCCESS if the function succeeds.
//      A Win32 error code otherwise.
//
DWORD
FrsRtlInitialize(
    IN  BOOL    RunningAsService
    );


//
//  Routine Description:
//
//      Cleans up the FRS run time library.
//
//  Arguments:
//
//      RunningAsService  - TRUE if the process is running as an NT service.
//                          FALSE if running as a console app.
//
//  Return Value:
//
//      None.
//
VOID
FrsRtlCleanup(
    VOID
    );


//
//  PLIST_ENTRY
//  GetListHead(
//      PLIST_ENTRY ListHead
//      );
//
#define GetListHead(ListHead) ((ListHead)->Flink)

//
//  PLIST_ENTRY
//  GetListTail(
//      PLIST_ENTRY ListHead
//      );
//
#define GetListTail(ListHead) ((ListHead)->Blink)
//
//  PLIST_ENTRY
//  GetListNext(
//      PLIST_ENTRY Entry
//      );
//
#define GetListNext(Entry) ((Entry)->Flink)

//
//  VOID
//  FrsRemoveEntryList(
//      PLIST_ENTRY Entry
//      );
//
// *NOTE*  The Flink/Blink of the removed entry are set to NULL to cause an
// Access violation if a thread is following a list and an element is removed.
// UNFORTUNATELY there is still code that depends on this, perhaps through
// remove head/tail.  Sigh.  For now leave as is.
//
#define FrsRemoveEntryList(Entry) {\
    PLIST_ENTRY _EX_Blink;\
    PLIST_ENTRY _EX_Flink;\
    PLIST_ENTRY _EX_Entry;\
    _EX_Entry = (Entry);\
    _EX_Flink = _EX_Entry->Flink;\
    _EX_Blink = _EX_Entry->Blink;\
    _EX_Blink->Flink = _EX_Flink;\
    _EX_Flink->Blink = _EX_Blink;\
    _EX_Entry->Flink = _EX_Entry->Blink = _EX_Entry;\
    }


//
//  VOID
//  RemoveEntryListB(
//      PLIST_ENTRY Entry
//      );
//
// The BillyF version of remove entry list.  The Flink/Blink of the removed
// entry are set to the entry address.
//
#define RemoveEntryListB(Entry) {\
    PLIST_ENTRY _EX_Blink;\
    PLIST_ENTRY _EX_Flink;\
    PLIST_ENTRY _EX_Entry;\
    _EX_Entry = (Entry);\
    _EX_Flink = _EX_Entry->Flink;\
    _EX_Blink = _EX_Entry->Blink;\
    _EX_Blink->Flink = _EX_Flink;\
    _EX_Flink->Blink = _EX_Blink;\
    _EX_Entry->Flink = _EX_Entry->Blink = _EX_Entry;\
    }


//
// Traverse a singlely linked NULL terminated list.
// Pass in the address of the list head, the type of the containing record,
// the offset to the link entry in the conatining record, and code for
// the loop body.  pE is the iterator and is of type specified.
// Within the loop body the macros InsertSingleListEntry() and
// RemoveSingleListEntry() can be used to do the obvious things.
//

#define ForEachSingleListEntry( _HEAD_, _TYPE_, _OFFSET_, _STMT_ ) \
{                                                             \
    PSINGLE_LIST_ENTRY __Entry, __NextEntry, __PrevEntry;     \
    _TYPE_ *pE;                                               \
                                                              \
    __Entry = (_HEAD_);                                       \
    __NextEntry = (_HEAD_)->Next;                             \
                                                              \
    while (__PrevEntry = __Entry, __Entry = __NextEntry, __Entry != NULL) { \
                                                              \
        __NextEntry = __Entry->Next;                          \
        pE = CONTAINING_RECORD(__Entry, _TYPE_, _OFFSET_);    \
                                                              \
        { _STMT_ }                                            \
                                                              \
    }                                                         \
                                                              \
}
//
// The following three macros are only valid within the loop body above.
// Insert an entry before the current entry with pointer pE.
//
#define InsertSingleListEntry( _Item_, _xOFFSET_ ) \
    (_Item_)->_xOFFSET_.Next = __Entry;            \
    __PrevEntry->Next = (PSINGLE_LIST_ENTRY) &((_Item_)->_xOFFSET_);

//
// Note that after you remove an entry the value for __Entry is set back to
// the __PrevEntry so when the loop continues __PrevEntry doesn't change
// since current entry had been removed.
//
#define RemoveSingleListEntry( _UNUSED_ )  \
    __PrevEntry->Next = __NextEntry;       \
    __Entry->Next = NULL;                  \
    __Entry = __PrevEntry;

//
// Return ptr to the previous node.  Only valid inside above FOR loop.
// Useful when deleting the current entry.
//
#define PreviousSingleListEntry( _TYPE_, _OFFSET_)  \
    CONTAINING_RECORD(__PrevEntry, _TYPE_, _OFFSET_)


//
// General-purpose queue package.  Taken from cluster\clusrtl.c
// *** WARNING ***  To make the macros work properly for both lists and queues
// the first five items in FRS_LIST and FRS_QUEUE MUST match.
//
typedef struct _FRS_QUEUE FRS_QUEUE, *PFRS_QUEUE;
struct _FRS_QUEUE {
    LIST_ENTRY          ListHead;
    CRITICAL_SECTION    Lock;
    DWORD               Count;
    PFRS_QUEUE          Control;
    DWORD               ControlCount;

    HANDLE              Event;
    HANDLE              RunDown;
    ULONG               InitTime;
    LIST_ENTRY          Full;
    LIST_ENTRY          Empty;
    LIST_ENTRY          Idled;
    BOOL                IsRunDown;
    BOOL                IsIdled;
};

VOID
FrsInitializeQueue(
    IN PFRS_QUEUE Queue,
    IN PFRS_QUEUE Control
    );

VOID
FrsRtlDeleteQueue(
    IN PFRS_QUEUE Queue
    );

PLIST_ENTRY
FrsRtlRemoveHeadQueue(
    IN PFRS_QUEUE Queue
    );

VOID
FrsRtlUnIdledQueue(
    IN PFRS_QUEUE   IdledQueue
    );

VOID
FrsRtlUnIdledQueueLock(
    IN PFRS_QUEUE   IdledQueue
    );

VOID
FrsRtlIdleQueue(
    IN PFRS_QUEUE   Queue
    );

VOID
FrsRtlIdleQueueLock(
    IN PFRS_QUEUE Queue
    );

PLIST_ENTRY
FrsRtlRemoveHeadQueueTimeoutIdled(
    IN PFRS_QUEUE   Queue,
    IN DWORD        dwMilliseconds,
    OUT PFRS_QUEUE  *IdledQueue
    );

PLIST_ENTRY
FrsRtlRemoveHeadQueueTimeout(
    IN PFRS_QUEUE Queue,
    IN DWORD dwMilliseconds
    );

VOID
FrsRtlRemoveEntryQueue(
    IN PFRS_QUEUE Queue,
    IN PLIST_ENTRY Entry
    );

DWORD
FrsRtlWaitForQueueFull(
    IN PFRS_QUEUE Queue,
    IN DWORD dwMilliseconds
    );

DWORD
FrsRtlInsertTailQueue(
    IN PFRS_QUEUE Queue,
    IN PLIST_ENTRY Item
    );

DWORD
FrsRtlInsertHeadQueue(
    IN PFRS_QUEUE Queue,
    IN PLIST_ENTRY Item
    );

VOID
FrsRtlRunDownQueue(
    IN PFRS_QUEUE Queue,
    OUT PLIST_ENTRY ListHead
    );

#define FrsRtlAcquireQueueLock(_pQueue_) \
            EnterCriticalSection(&(((_pQueue_)->Control)->Lock))

#define FrsRtlReleaseQueueLock(_pQueue_) \
            LeaveCriticalSection(&(((_pQueue_)->Control)->Lock))

#define FrsRtlCountQueue(_pQueue_) \
            (((_pQueue_)->Control)->ControlCount)

#define FrsRtlCountSubQueue(_pQueue_) \
            ((_pQueue_)->Count)

#define FrsRtlNoIdledQueues(_pQueue_) \
            (IsListEmpty(&(((_pQueue_)->Control)->Idled)))


//
// The Lock suffix on the routines below means the user already has the
// queue lock.
//
VOID
FrsRtlRemoveEntryQueueLock(
    IN PFRS_QUEUE Queue,
    IN PLIST_ENTRY Entry
    );

DWORD
FrsRtlInsertTailQueueLock(
    IN PFRS_QUEUE Queue,
    IN PLIST_ENTRY Item
    );

DWORD
FrsRtlInsertHeadQueueLock(
    IN PFRS_QUEUE Queue,
    IN PLIST_ENTRY Item
    );

//
// COMMAND SERVER
// A command server is a dynamic pool of threads and a controlled queue
//      The default queue is set up as a controlled queue. Other
//      controlled queues can be added in a server specific manner.
// A command server exports an initialize, abort, and none or more
// submit routines. The parameters and names of these functions is
// server specific. The consumers of a server's interface are intimate
// with the server.
//
typedef struct _COMMAND_SERVER  COMMAND_SERVER, *PCOMMAND_SERVER;
struct _COMMAND_SERVER {
    DWORD           MaxThreads;     // Max # of threads
    DWORD           FrsThreads;     // current # of frs threads
    DWORD           Waiters;        // current # of frs threads waiting
    PWCHAR          Name;           // Thread's name
    HANDLE          Idle;           // No active threads; no queue entries
    DWORD           (*Main)(PVOID); // Thread's entry point
    FRS_QUEUE       Control;        // controlling queue
    FRS_QUEUE       Queue;          // queue
};

//
// Interlocked list.
// *** WARNING ***  To make the macros work properly for both lists and queues
// the first five items in FRS_LIST and FRS_QUEUE MUST match.
//
typedef struct _FRS_LIST FRS_LIST, *PFRS_LIST;
struct _FRS_LIST {
    LIST_ENTRY ListHead;
    CRITICAL_SECTION Lock;
    DWORD Count;
    PFRS_LIST Control;
    DWORD ControlCount;
};


DWORD
FrsRtlInitializeList(
    PFRS_LIST List
    );

VOID
FrsRtlDeleteList(
    PFRS_LIST List
    );

PLIST_ENTRY
FrsRtlRemoveHeadList(
    IN PFRS_LIST List
    );

VOID
FrsRtlInsertHeadList(
    IN PFRS_LIST List,
    IN PLIST_ENTRY Entry
    );

PLIST_ENTRY
FrsRtlRemoveTailList(
    IN PFRS_LIST List
    );

VOID
FrsRtlInsertTailList(
    IN PFRS_LIST List,
    IN PLIST_ENTRY Entry
    );

VOID
FrsRtlRemoveEntryList(
    IN PFRS_LIST List,
    IN PLIST_ENTRY Entry
    );


#define FrsRtlAcquireListLock(_pList_) EnterCriticalSection(&(((_pList_)->Control)->Lock))

#define FrsRtlReleaseListLock(_pList_) LeaveCriticalSection(&(((_pList_)->Control)->Lock))

#define FrsRtlCountList(_pList_) (((_pList_)->Control)->ControlCount)


VOID
FrsRtlRemoveEntryListLock(
    IN PFRS_LIST List,
    IN PLIST_ENTRY Entry
    );

VOID
FrsRtlInsertTailListLock(
    IN PFRS_LIST List,
    IN PLIST_ENTRY Entry
    );

VOID
FrsRtlInsertHeadListLock(
    IN PFRS_LIST List,
    IN PLIST_ENTRY Entry
    );


//VOID
//FrsRtlInsertBeforeEntryListLock(
//    IN PFRS_LIST List,
//    IN PLIST_ENTRY BeforeEntry
//    IN PLIST_ENTRY NewEntry
//    )
//
//    Inserts newEntry before the BeforeEntry on the interlocked list (List).
//    This is used to keep the list elements in ascending order by KeyValue.
//
//    Assumes caller already has the list lock.
//

#define  FrsRtlInsertBeforeEntryListLock( _List, _BeforeEntry, _NewEntry ) \
    InsertTailList((_BeforeEntry), (_NewEntry)); \
    (_List)->Count += 1; \
    ((_List)->Control)->ControlCount += 1; \


//
// Walk thru an interlocked queue or list (_QUEUE_) with elements of type
// _TYPE_ and execute {_STMT_} for each one.  The list entry in _TYPE_ is
// at _OFFSET_.  Use pE in the statement body as a pointer to the entry.
// The entry may be removed from within the loop since we capture the
// link to the next entry before executing the loop body.  You may also use
// 'continue' within the loop body because the assignment of nextentry to entry
// is in a comma expression inside the while test.
//

#define ForEachListEntry( _QUEUE_, _TYPE_, _OFFSET_, _STMT_ ) \
{                                                             \
    PLIST_ENTRY __Entry, __NextEntry;                         \
    BOOL __Hold__=FALSE;                                      \
    _TYPE_ *pE;                                               \
                                                              \
    FrsRtlAcquireQueueLock(_QUEUE_);                          \
    __NextEntry = GetListHead(&((_QUEUE_)->ListHead));        \
                                                              \
    while (__Entry = __NextEntry, __Entry != &((_QUEUE_)->ListHead)) { \
                                                              \
        __NextEntry = GetListNext(__Entry);                   \
        pE = CONTAINING_RECORD(__Entry, _TYPE_, _OFFSET_);    \
                                                              \
        { _STMT_ }                                            \
                                                              \
    }                                                         \
                                                              \
    if (!__Hold__) FrsRtlReleaseQueueLock(_QUEUE_);           \
                                                              \
}

#define AquireListLock( _QUEUE_ )  FrsRtlAcquireListLock(_QUEUE_)
#define ReleaseListLock( _QUEUE_ ) FrsRtlReleaseListLock(_QUEUE_)

#define BreakAndHoldLock __Hold__ = TRUE; break


//
// Just like the above except the caller already has the list lock.
//

#define ForEachListEntryLock( _QUEUE_, _TYPE_, _OFFSET_, _STMT_ ) \
{                                                             \
    PLIST_ENTRY __Entry, __NextEntry;                         \
    _TYPE_ *pE;                                               \
                                                              \
    __NextEntry = GetListHead(&((_QUEUE_)->ListHead));        \
                                                              \
    while (__Entry = __NextEntry, __Entry != &((_QUEUE_)->ListHead)) {  \
                                                              \
        __NextEntry = GetListNext(__Entry);                   \
        pE = CONTAINING_RECORD(__Entry, _TYPE_, _OFFSET_);    \
                                                              \
        { _STMT_ }                                            \
                                                              \
    }                                                         \
                                                              \
}


//
// Just like the above except pass in the address of the list head
// instead of using QUEUE->ListHEad.
//

#define ForEachSimpleListEntry( _HEAD_, _TYPE_, _OFFSET_, _STMT_ ) \
{                                                             \
    PLIST_ENTRY __Entry, __NextEntry;                         \
    _TYPE_ *pE;                                               \
                                                              \
    __NextEntry = GetListHead(_HEAD_);                        \
                                                              \
    while (__Entry = __NextEntry, __Entry != (_HEAD_)) {      \
                                                              \
        __NextEntry = GetListNext(__Entry);                   \
        pE = CONTAINING_RECORD(__Entry, _TYPE_, _OFFSET_);    \
                                                              \
        { _STMT_ }                                            \
                                                              \
    }                                                         \
                                                              \
}


//VOID
//FrsRtlInsertQueueOrdered(
//    IN PFRS_QUEUE List,
//    IN PLIST_ENTRY NewEntry,
//    IN <Entry-Data-Type>,
//    IN <LIST_ENTRY-offset-name>,
//    IN <Orderkey-Offset-name>,
//    IN EventHandle or NULL
//    )
//
//    Inserts NewEntry on an ordered queue of <Entry-Data-Type> elements.
//    The offset to the LIST_ENTRY in each element is <LIST_ENTRY-offset-name>
//    The offset to the Ordering key (.eg. a ULONG) is <Orderkey-Offset-name>
//    It acquires the List Lock.
//    The list elements are kept in ascending order by KeyValue.
//    If a new element is placed at the head of the queue and the EventHandle
//    is non-NULL, the event is signalled.
//
//
#define FrsRtlInsertQueueOrdered(                                           \
    _QUEUE_, _NEWENTRY_, _TYPE_, _OFFSET_, _BY_, _EVENT_, _STATUS_)         \
{                                                                           \
    BOOL __InsertDone = FALSE;                                              \
    BOOL __FirstOnQueue = TRUE;                                             \
    _STATUS_ = ERROR_SUCCESS;                                               \
                                                                            \
    FrsRtlAcquireQueueLock(_QUEUE_);                                        \
                                                                            \
    ForEachListEntryLock(_QUEUE_, _TYPE_, _OFFSET_,                         \
                                                                            \
        /* pE is loop iterator of type _TYPE_                          */   \
                                                                            \
        if ((_NEWENTRY_)->_BY_ < pE->_BY_) {                                \
            FrsRtlInsertBeforeEntryListLock( _QUEUE_,                       \
                                             &pE->_OFFSET_,                 \
                                             &((_NEWENTRY_)->_OFFSET_));    \
            __InsertDone = TRUE;                                            \
            break;                                                          \
        }                                                                   \
                                                                            \
        __FirstOnQueue = FALSE;                                             \
    );                                                                      \
                                                                            \
    /* Handle new head or new tail case.  If the queue was previously  */   \
    /* the insert will set the event.                                  */   \
                                                                            \
    if (!__InsertDone) {                                                    \
        if (__FirstOnQueue) {                                               \
            _STATUS_ = FrsRtlInsertHeadQueueLock(_QUEUE_, &((_NEWENTRY_)->_OFFSET_));  \
        } else {                                                            \
            _STATUS_ = FrsRtlInsertTailQueueLock(_QUEUE_, &((_NEWENTRY_)->_OFFSET_));  \
        }                                                                   \
    }                                                                       \
                                                                            \
    /* If this command became the new first one on the queue and the   */   \
    /* queue wasn't previously empty we have to set the event here to  */   \
    /* get the thread to readjust its wait time.                       */   \
                                                                            \
    if (__FirstOnQueue &&                                                   \
        (FrsRtlCountQueue(_QUEUE_) != 1)) {                                 \
        if (HANDLE_IS_VALID(_EVENT_)) {                                     \
            SetEvent(_EVENT_);                                              \
        }                                                                   \
    }                                                                       \
                                                                            \
    FrsRtlReleaseQueueLock(_QUEUE_);                                        \
                                                                            \
}



//VOID
//FrsRtlInsertListOrdered(
//    IN PFRS_LIST List,
//    IN PLIST_ENTRY NewEntry,
//    IN <Entry-Data-Type>,
//    IN <LIST_ENTRY-offset-name>,
//    IN <Orderkey-Offset-name>,
//    IN EventHandle or NULL
//    )
//
//    Inserts NewEntry on an ordered list of <Entry-Data-Type> elements.
//    The offset to the LIST_ENTRY in each element is <LIST_ENTRY-offset-name>
//    The offset to the Ordering key (.eg. a ULONG) is <Orderkey-Offset-name>
//    It acquires the List Lock.
//    The list elements are kept in ascending order by KeyValue.
//    If a new element is placed at the head of the queue and the EventHandle
//    is non-NULL, the event is signalled.
//
//
#define FrsRtlInsertListOrdered(                                            \
    _FRSLIST_, _NEWENTRY_, _TYPE_, _OFFSET_, _BY_, _EVENT_)                 \
{                                                                           \
    BOOL __InsertDone = FALSE;                                              \
    BOOL __FirstOnList = TRUE;                                              \
                                                                            \
    FrsRtlAcquireListLock(_FRSLIST_);                                       \
                                                                            \
    ForEachListEntryLock(_FRSLIST_, _TYPE_, _OFFSET_,                       \
                                                                            \
        /* pE is loop iterator of type _TYPE_                          */   \
                                                                            \
        if ((_NEWENTRY_)->_BY_ < pE->_BY_) {                                \
            FrsRtlInsertBeforeEntryListLock( _FRSLIST_,                     \
                                             &pE->_OFFSET_,                 \
                                             &((_NEWENTRY_)->_OFFSET_));    \
            __InsertDone = TRUE;                                            \
            break;                                                          \
        }                                                                   \
                                                                            \
        __FirstOnList = FALSE;                                              \
    );                                                                      \
                                                                            \
    /* Handle new head or new tail case. */                                 \
                                                                            \
    if (!__InsertDone) {                                                    \
        if (__FirstOnList) {                                                \
            FrsRtlInsertHeadListLock(_FRSLIST_, &((_NEWENTRY_)->_OFFSET_)); \
        } else {                                                            \
            FrsRtlInsertTailListLock(_FRSLIST_, &((_NEWENTRY_)->_OFFSET_)); \
        }                                                                   \
    }                                                                       \
                                                                            \
    /* If this command became the new first one on the list              */ \
    /* we set the event here to get the thread to readjust its wait time.*/ \
                                                                            \
    if (__FirstOnList) {                                                    \
        if (HANDLE_IS_VALID(_EVENT_)) {                                     \
            SetEvent(_EVENT_);                                              \
        }                                                                   \
    }                                                                       \
                                                                            \
    FrsRtlReleaseListLock(_FRSLIST_);                                       \
                                                                            \
}



//
// Request counts are used as a simple means for tracking the number of
// command requests that are pending so the requestor can wait until
// all the commands have been processed.
//
typedef struct _FRS_REQUEST_COUNT FRS_REQUEST_COUNT, *PFRS_REQUEST_COUNT;
struct _FRS_REQUEST_COUNT {
    CRITICAL_SECTION    Lock;
    LONG                Count;     // Number of requests active
    HANDLE              Event;     // Event set when count goes to zero.
    ULONG               Status;    // Optional status return
};


#define FrsIncrementRequestCount(_RC_)     \
    EnterCriticalSection(&(_RC_)->Lock);   \
    (_RC_)->Count += 1;                    \
    if ((_RC_)->Count == 1) {              \
        ResetEvent((_RC_)->Event);         \
    }                                      \
    LeaveCriticalSection(&(_RC_)->Lock);


#define FrsDecrementRequestCount(_RC_, _Status_)   \
    EnterCriticalSection(&(_RC_)->Lock);   \
    (_RC_)->Status |= _Status_;            \
    (_RC_)->Count -= 1;                    \
    FRS_ASSERT((_RC_)->Count >= 0);        \
    if ((_RC_)->Count == 0) {              \
        SetEvent((_RC_)->Event);           \
    }                                      \
    LeaveCriticalSection(&(_RC_)->Lock);


ULONG
FrsWaitOnRequestCount(
    IN PFRS_REQUEST_COUNT RequestCount,
    IN ULONG Timeout
    );


struct _COMMAND_PACKET;
VOID
FrsCompleteRequestCount(
    IN struct _COMMAND_PACKET *CmdPkt,
    IN PFRS_REQUEST_COUNT RequestCount
    );

VOID
FrsCompleteRequestCountKeepPkt(
    IN struct _COMMAND_PACKET *CmdPkt,
    IN PFRS_REQUEST_COUNT RequestCount
    );

VOID
FrsCompleteKeepPkt(
    IN struct _COMMAND_PACKET *CmdPkt,
    IN PVOID           CompletionArg
    );

VOID
FrsInitializeRequestCount(
    IN PFRS_REQUEST_COUNT RequestCount
    );

VOID
FrsDeleteRequestCount(
    IN PFRS_REQUEST_COUNT RequestCount
    );

VOID
FrsDeleteAllTempFiles(
    );


#define FrsInterlockedIncrement64(_Dest_, _Data_, _Lock_) \
    EnterCriticalSection(_Lock_);                         \
    _Data_ += (ULONGLONG) 1;                              \
    _Dest_ = (_Data_);                                    \
    LeaveCriticalSection(_Lock_);


//
//  ADVANCE_VALUE_INTERLOCKED(
//      IN PULONG _dest,
//      IN ULONG  _newval
//  )
//  Advance the destination to the value given in newval atomically using
//  interlocked exchange.  _dest is never moved to a smaller value so this
//  is a no-op if _newval is < _dest.
//
//  *NOTE* Other operations on _dest MUST be done with interlocked ops like
//  InterlockedIncrement to ensure that an incremented value is not lost if
//  it occurs simultaneously on another processor.
//
#define ADVANCE_VALUE_INTERLOCKED(_dest, _newval)  {                           \
    ULONG CurVal, SaveCurVal, Result, *pDest = (_dest);                        \
    CurVal = SaveCurVal = *pDest;                                              \
    while ((_newval) > CurVal) {                                               \
        Result = (ULONG)InterlockedCompareExchange((PLONG)pDest, (_newval), CurVal); \
        if (Result == CurVal) {                                                \
            break;                                                             \
        }                                                                      \
        CurVal = Result;                                                       \
    }                                                                          \
    FRS_ASSERT(*pDest >= SaveCurVal);                                          \
}

//
//
// Avoiding a torn quadword result (without a crit sect) when 1 thread is
// writing a quadord and another is reading the quadword, or,
// 2 threads are writing the same quadword.
//
// To do this in alpha we need an assembler routine to use load_locked / store_cond.
// To do this in x86 (per DaveC):
#if 0
    if (USER_SHARED_DATA->ProcessorFeatures[PF_COMPARE_EXCHANGE_DOUBLE] == FALSE) {
        // code to use a crit section.
    } else {
        // code to use inline assembly with cmpxchg8b.
    }
#endif
// KUSER_SHARED_DATA is defined in sdk\inc\ntxapi.h
// USER_SHARED_DATA is an arch specific typecast pointer to KUSER_SHARED_DATA.
// User shared data has a processor feature list with a cell for
// PF_COMPARE_EXCHANGE_DOUBLE that tells if the processor supports
// the cmpxchg8b instruction for x86.  The 486 doesn't have it.
//
#define ReadQuadLock(_qw, _Lock)  \
    (EnterCriticalSection((_Lock)), *(_qw))

#define WriteQuadUnlock(_qw, _newval, _Lock)  \
    *(_qw) = (_newval);                       \
    LeaveCriticalSection((_Lock))

#define AcquireQuadLock(_Lock)  EnterCriticalSection((_Lock))
#define ReleaseQuadLock(_Lock)  LeaveCriticalSection((_Lock))



//
//  SET_FLAG_INTERLOCKED(
//      IN PULONG _dest,
//      IN ULONG  _flags
//  )
//
//  *NOTE* Other operations on _dest MUST be done with interlocked ops like
//  InterlockedIncrement to ensure that an incremented value is not lost if
//  it occurs simultaneously on another processor.
//
#define SET_FLAG_INTERLOCKED(_dest, _flags)  {                                 \
    ULONG CurVal, NewVal, Result, *pDest = (_dest);                            \
    CurVal = *pDest;                                                           \
    NewVal = (_flags) | CurVal;                                                \
    while ((NewVal) != CurVal) {                                               \
        Result = (ULONG)InterlockedCompareExchange((PLONG)pDest, NewVal, CurVal);    \
        if (Result == CurVal) {                                                \
            break;                                                             \
        }                                                                      \
        CurVal = Result;                                                       \
        NewVal = (_flags) | CurVal;                                            \
    }                                                                          \
}


//
//  CLEAR_FLAG_INTERLOCKED(
//      IN PULONG _dest,
//      IN ULONG  _flags
//  )
//
//  *NOTE* Other operations on _dest MUST be done with interlocked ops like
//  InterlockedIncrement to ensure that an incremented value is not lost if
//  it occurs simultaneously on another processor.
//
#define CLEAR_FLAG_INTERLOCKED(_dest, _flags)  {                               \
    ULONG CurVal, NewVal, Result, *pDest = (_dest);                            \
    CurVal = *pDest;                                                           \
    NewVal = CurVal & ~(_flags);                                               \
    while ((NewVal) != CurVal) {                                               \
        Result = (ULONG)InterlockedCompareExchange((PLONG)pDest, NewVal, CurVal);    \
        if (Result == CurVal) {                                                \
            break;                                                             \
        }                                                                      \
        CurVal = Result;                                                       \
        NewVal = CurVal & ~(_flags);                                           \
    }                                                                          \
}



#define FlagOn(Flags,SingleFlag)  ((Flags) & (SingleFlag))

#define BooleanFlagOn(Flags,SingleFlag) ((BOOLEAN)(((Flags) & (SingleFlag)) != 0))

#define SetFlag(_F,_SF) { \
    (_F) |= (_SF);        \
}

#define ClearFlag(_F,_SF) { \
    (_F) &= ~(_SF);         \
}

#define ValueIsMultOf2(_x_)  (((ULONG_PTR)(_x_) & 0x00000001) == 0)
#define ValueIsMultOf4(_x_)  (((ULONG_PTR)(_x_) & 0x00000003) == 0)
#define ValueIsMultOf8(_x_)  (((ULONG_PTR)(_x_) & 0x00000007) == 0)
#define ValueIsMultOf16(_x_) (((ULONG_PTR)(_x_) & 0x0000000F) == 0)


#define ARRAY_SZ(_ar)  (sizeof(_ar)/sizeof((_ar)[0]))
#define ARRAY_SZ2(_ar, _type)  (sizeof(_ar)/sizeof(_type))


//
// This macros below take a pointer (or ulong) and return the value rounded
// up to the next aligned boundary.
//
#define WordAlign(Ptr)     ((PVOID)((((ULONG_PTR)(Ptr)) + 1)  & ~1))
#define LongAlign(Ptr)     ((PVOID)((((ULONG_PTR)(Ptr)) + 3)  & ~3))
#define QuadAlign(Ptr)     ((PVOID)((((ULONG_PTR)(Ptr)) + 7)  & ~7))
#define DblQuadAlign(Ptr)  ((PVOID)((((ULONG_PTR)(Ptr)) + 15) & ~15))
#define QuadQuadAlign(Ptr) ((PVOID)((((ULONG_PTR)(Ptr)) + 31) & ~31))

#define QuadQuadAlignSize(Size) ((((ULONG)(Size)) + 31) & ~31)

//
// Check for a zero FILETIME.
//
#define FILETIME_IS_ZERO(_F_) \
    ((_F_.dwLowDateTime == 0) && (_F_.dwHighDateTime == 0))


//
// Convert a quad to two ULONGs for printing with format: %08x %08x
//
#define PRINTQUAD(__ARG__) (ULONG)((__ARG__)>>32) ,(ULONG)(__ARG__)

//
// Convert to printable cxtion path with format: %ws\%ws\%ws -> %ws\%ws
//
#define FORMAT_CXTION_PATH2  "%ws\\%ws\\%ws %ws %ws %ws"
#define FORMAT_CXTION_PATH2W  L"%ws\\%ws\\%ws %ws %ws %ws"
#define PRINT_CXTION_PATH2(_REPLICA, _CXTION)                       \
    (_REPLICA)->ReplicaName->Name,                                  \
    (_REPLICA)->MemberName->Name,                                   \
    (((_CXTION) != NULL) ? (_CXTION)->Name->Name : L"null"),        \
    (((_CXTION) != NULL) ? (((_CXTION)->Inbound) ? L"<-" : L"->") : \
                           L"?"),                                   \
    (((_CXTION) != NULL) ? (_CXTION)->PartSrvName : L"null"),       \
    (((_CXTION) != NULL) ? (((_CXTION)->JrnlCxtion) ? L"JrnlCxt" : L"RemoteCxt") : L"null")

#define PRINT_CXTION_PATH(_REPLICA, _CXTION)                    \
    (_REPLICA)->ReplicaName->Name,                              \
    (_REPLICA)->MemberName->Name,                               \
    (((_CXTION) != NULL) ? (_CXTION)->Name->Name : L"null"),    \
    (((_CXTION) != NULL) ? (_CXTION)->Partner->Name : L"null"), \
    (((_CXTION) != NULL) ? (_CXTION)->PartSrvName : L"null")

//
// Lower case
//
#define FRS_WCSLWR(_s_) \
{ \
    if (_s_) { \
        _wcslwr(_s_); \
    } \
}

//
// Lock to protect the child lists in the Filter Table.  (must be pwr of 2)
// Instead of paying the overhead of having one per node we just use an array
// to help reduce contention.  We use the ReplicaNumber masked by the lock
// table size as the index.
//
// Acquire the lock on the ReplicaSet Filter table Child List before
// inserting or removing a child from the list.
//
#define NUMBER_FILTER_TABLE_CHILD_LOCKS 8
extern CRITICAL_SECTION JrnlFilterTableChildLock[NUMBER_FILTER_TABLE_CHILD_LOCKS];

#define FILTER_TABLE_CHILD_INDEX(_x_) \
((ULONG)((_x_)->ReplicaNumber) & (NUMBER_FILTER_TABLE_CHILD_LOCKS - 1))

#define JrnlAcquireChildLock(_replica_) EnterCriticalSection( \
    &JrnlFilterTableChildLock[FILTER_TABLE_CHILD_INDEX(_replica_)] )

#define JrnlReleaseChildLock(_replica_) LeaveCriticalSection( \
    &JrnlFilterTableChildLock[FILTER_TABLE_CHILD_INDEX(_replica_)] )

//
// Renaming a subtree from one replica set to another requires the child locks
// for both replica sets.  Always get them in the same order (low to high)
// to avoid deadlock.  Also check if the both use the same lock.
// Note: The caller must use JrnlReleaseChildLockPair() so the check for
// using the same lock can be repeated.  Release in reverse order to avoid
// an extra context switch if another thread was waiting behind the first lock.
//
#define JrnlAcquireChildLockPair(_replica1_, _replica2_)        \
{                                                               \
    ULONG Lx1, Lx2, Lxt;                                        \
    Lx1 = FILTER_TABLE_CHILD_INDEX(_replica1_);                 \
    Lx2 = FILTER_TABLE_CHILD_INDEX(_replica2_);                 \
    if (Lx1 > Lx2) {                                            \
        Lxt = Lx1; Lx1 = Lx2; Lx2 = Lxt;                        \
    }                                                           \
    EnterCriticalSection(&JrnlFilterTableChildLock[Lx1]);       \
    if (Lx1 != Lx2) {                                           \
        EnterCriticalSection(&JrnlFilterTableChildLock[Lx2]);   \
    }                                                           \
}


#define JrnlReleaseChildLockPair(_replica1_, _replica2_)        \
{                                                               \
    ULONG Lx1, Lx2, Lxt;                                        \
    Lx1 = FILTER_TABLE_CHILD_INDEX(_replica1_);                 \
    Lx2 = FILTER_TABLE_CHILD_INDEX(_replica2_);                 \
    if (Lx1 < Lx2) {                                            \
        Lxt = Lx1; Lx1 = Lx2; Lx2 = Lxt;                        \
    }                                                           \
    LeaveCriticalSection(&JrnlFilterTableChildLock[Lx1]);       \
    if (Lx1 != Lx2) {                                           \
        LeaveCriticalSection(&JrnlFilterTableChildLock[Lx2]);   \
    }                                                           \
}

#ifdef __cplusplus
  }
#endif



ULONG
FrsRunProcess(
    IN PWCHAR   AppPathAndName,
    IN PWCHAR   CommandLine,
    IN HANDLE   StandardIn,
    IN HANDLE   StandardOut,
    IN HANDLE   StandardError
    );


VOID
FrsFlagsToStr(
    IN DWORD            Flags,
    IN PFLAG_NAME_TABLE NameTable,
    IN ULONG            Length,
    OUT PSTR            Buffer
    );


//
//######################### COMPRESSION OF STAGING FILE STARTS ###############
//

//
//  The compressed chunk header is the structure that starts every
//  new chunk in the compressed data stream.  In our definition here
//  we union it with a ushort to make setting and retrieving the chunk
//  header easier.  The header stores the size of the compressed chunk,
//  its signature, and if the data stored in the chunk is compressed or
//  not.
//
//  Compressed Chunk Size:
//
//      The actual size of a compressed chunk ranges from 4 bytes (2 byte
//      header, 1 flag byte, and 1 literal byte) to 4098 bytes (2 byte
//      header, and 4096 bytes of uncompressed data).  The size is encoded
//      in a 12 bit field biased by 3.  A value of 1 corresponds to a chunk
//      size of 4, 2 => 5, ..., 4095 => 4098.  A value of zero is special
//      because it denotes the ending chunk header.
//
//  Chunk Signature:
//
//      The only valid signature value is 3.  This denotes a 4KB uncompressed
//      chunk using with the 4/12 to 12/4 sliding offset/length encoding.
//
//  Is Chunk Compressed:
//
//      If the data in the chunk is compressed this field is 1 otherwise
//      the data is uncompressed and this field is 0.
//
//  The ending chunk header in a compressed buffer contains the a value of
//  zero (space permitting).
//

typedef union _FRS_COMPRESSED_CHUNK_HEADER {

    struct {

        USHORT CompressedChunkSizeMinus3 : 12;
        USHORT ChunkSignature            :  3;
        USHORT IsChunkCompressed         :  1;

    } Chunk;

    USHORT Short;

} FRS_COMPRESSED_CHUNK_HEADER, *PFRS_COMPRESSED_CHUNK_HEADER;

typedef struct _FRS_DECOMPRESS_CONTEXT {
    DWORD   BytesProcessed;
} FRS_DECOMPRESS_CONTEXT, *PFRS_DECOMPRESS_CONTEXT;

#define FRS_MAX_CHUNKS_TO_DECOMPRESS 16
#define FRS_UNCOMPRESSED_CHUNK_SIZE  4096

//
//######################### COMPRESSION OF STAGING FILE ENDS ###############
//


//
// This context is used to send data to the callback functions for the RAW
// encrypt APIs.
//
typedef struct _FRS_ENCRYPT_DATA_CONTEXT {

    PWCHAR         StagePath;
    HANDLE         StageHandle;
    LARGE_INTEGER  RawEncryptedBytes;

} FRS_ENCRYPT_DATA_CONTEXT, *PFRS_ENCRYPT_DATA_CONTEXT;