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

Copyright (c) 2000 - 2000 Microsoft Corporation

Module Name :

    qmgrlib.h

Abstract :

    External header for library functions.

Author :

Revision History :

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

#pragma once

#include<nt.h>
#include<ntrtl.h>
#include<nturtl.h>
#include <windows.h>
#include <sddl.h>
#include <unknwn.h>
#include <memory>
#include <tchar.h>
#include <strsafe.h>
#include "bitsverp.h"

// strsafe.h deprecates the shlwapi string functions
//
#define NO_SHLWAPI_STRFCNS

//
// Version Control
//

enum PLATFORM_PRODUCT_VERSION
{
   WIN95_PLATFORM,
   WIN98_PLATFORM,
#if defined( BITS_V12_ON_NT4 )
   NT4_PLATFORM,
#endif
   WINDOWS2000_PLATFORM,
   WINDOWSXP_PLATFORM
};

extern PLATFORM_PRODUCT_VERSION g_PlatformVersion;
extern bool bIsWin9x;

BOOL DetectProductVersion();


//
// Limits
//

const size_t INT_DIGITS = 10;
const size_t INT64_DIGITS = 20;

const SIZE_T MAX_DISPLAYNAME        = 255;
const SIZE_T MAX_DESCRIPTION        = 1023;
const SIZE_T MAX_NOTIFY_CMD_LINE    = 4000;
const SIZE_T MAX_PROXYLIST          = 32767;
const SIZE_T MAX_PROXYBYPASSLIST    = 32767;

//
// Metadata overhead
//

const SIZE_T METADATA_PADDING                  = 4096;  // Padding on metadata for small changes such as timers
const SIZE_T METADATA_PREALLOC_SIZE          = 262144;  // Size to prealloc before a change
const SIZE_T METADATA_FOR_FILE                 = 4096;  // Initial file size.

const UINT MAX_GUID_CHARS=40;
typedef WCHAR GUIDSTR[MAX_GUID_CHARS];

template <class T>
inline void SafeRelease( T * & p ) { if (NULL != (p)) { p->Release(); p = NULL; } }

using namespace std;

template<HANDLE InvalidValue=NULL>
class auto_HANDLE
    {
public:
    auto_HANDLE(HANDLE Handle = InvalidValue)
    : m_Handle(Handle) {}
    auto_HANDLE(auto_HANDLE<InvalidValue>& Other)
    : m_Handle(Other.release()) {}
    auto_HANDLE<InvalidValue>& operator=( HANDLE Handle )
    {
        if (InvalidValue != m_Handle)
            {
            CloseHandle(m_Handle);
            }
        m_Handle = Handle;
        return *this;
    }
    auto_HANDLE<InvalidValue>& operator=(auto_HANDLE<InvalidValue>& Other)
    {
        if (this != &Other)
            {
            m_Handle = Other.release();
            }
        return *this;
    }
    ~auto_HANDLE()
    {
        if (InvalidValue != m_Handle)
            CloseHandle(m_Handle);
    }
    HANDLE get() const
    {
        return m_Handle;
    }

    HANDLE * GetWritePointer()
    {
        return &m_Handle;
    }

    HANDLE release()
    {
        HANDLE Handle = m_Handle;
        m_Handle = InvalidValue;
        return Handle;
    }
private:
    HANDLE m_Handle;
    };
typedef auto_HANDLE<INVALID_HANDLE_VALUE> auto_FILE_HANDLE;

class SidHandle
{
    PSID    m_pValue;
    long *  m_pRefs;

public:

    PSID operator->()  { ASSERT( *m_pRefs > 0); return m_pValue; }

    SidHandle( PSID value=NULL ) : m_pValue( value ), m_pRefs( new long(1) )
    {
    }

    SidHandle( const SidHandle & r ) : m_pValue( r.m_pValue ), m_pRefs( r.m_pRefs )
    {
        InterlockedIncrement( m_pRefs );
    }

    ~SidHandle()
    {
        if ( InterlockedDecrement( m_pRefs ) == 0 )
            {
            delete m_pRefs;
            delete m_pValue;
            m_pRefs = NULL;
            m_pValue = NULL;
            }
    }

    SidHandle & operator=( const SidHandle & r );

    bool operator==( const SidHandle & r ) const
    {
        // this odd construction converts BOOL to bool.
        //
        return !!EqualSid( get(), r.get());
    }

    bool operator!=( const SidHandle & r ) const
    {
        return !((*this) == r);
    }

    PSID get() const  { ASSERT( *m_pRefs > 0); return m_pValue; }

};

template<class T>
class GenericStringHandle
{

    struct StringData
    {
        SIZE_T        m_Count;
        long          m_Refs;
        T             m_Data[1];
    };

    static StringData s_EmptyString;

    StringData *m_Value;

    void NewString( const T *String )
    {
       if ( !String )
           {
           m_Value = Alloc( 0 );
           return;
           }

       size_t Length = wcslen( String );
       m_Value = Alloc( Length );

       THROW_HRESULT( StringCchCopy( m_Value->m_Data, Length+1, String ));
    }

    static StringData * Alloc( SIZE_T max )
    {
        if (max == 0)
            {
            InterlockedIncrement( &s_EmptyString.m_Refs );
            return &s_EmptyString;
            }

        StringData * Value;

        Value = (StringData*) new char[sizeof(StringData)+(max*sizeof(T))];
        Value->m_Count = max;
        Value->m_Refs  = 1;

        Value->m_Data[0] = L'\0';

        return Value;
    }

    StringData * RefIt() const
    {
        InterlockedIncrement( &m_Value->m_Refs );
        return m_Value;
    }

    void FreeIt()
    {
        if ( InterlockedDecrement( &m_Value->m_Refs ) == 0 )
            delete m_Value;
    }

public:

    GenericStringHandle( const T *String = NULL )
    {
        NewString( String );
    }

    GenericStringHandle( const GenericStringHandle & Other ) :
        m_Value( Other.RefIt() )
    {
    }

    ~GenericStringHandle()
    {
        FreeIt();
    }

    GenericStringHandle & operator=( const GenericStringHandle & r )
    {
        FreeIt();
        m_Value = r.RefIt();
        return *this;
    }

    void operator=( const T * r )
    {
        FreeIt();
        NewString( r );
    }

    SIZE_T Size() const
    {
        return m_Value->m_Count;
    }

    operator const T *() const
    {
        return m_Value->m_Data;
    }

    //
    // Force a new copy of the data to be made.
    //
    GenericStringHandle Copy()
    {
        GenericStringHandle temp = m_Value->m_Data;
        return temp;
    }

    bool operator <( const GenericStringHandle & r ) const
    {
        if ( m_Value == r.m_Value)
            return false;
        return (wcscmp( this->m_Value->m_Data, r.m_Value->m_Data ) < 0);
    }

    T & operator[] ( const SIZE_T offset )
    {
        if (offset > Size())
            {
            THROW_HRESULT( E_INVALIDARG );
            }

        return m_Value->m_Data[ offset ];
    }

    void Truncate( SIZE_T max )
    {
        if (Size() <= max)
            {
            return;
            }

        //
        // Create the new value string.
        //
        StringData * NewValue = Alloc( max );

        StringCchCopy( NewValue->m_Data, max+1, m_Value->m_Data );

        //
        // Replace the current value with the new value.
        //
        FreeIt();
        m_Value = NewValue;
    }

    T * GetToken( T * CursorIn, const T Separators[], T ** CursorOut );
};

typedef GenericStringHandle<TCHAR> StringHandleT;
typedef GenericStringHandle<CHAR> StringHandleA;
typedef GenericStringHandle<WCHAR> StringHandle;

inline WCHAR *
GenericStringHandle<WCHAR>::GetToken( WCHAR * Cursor, const WCHAR Separators[], WCHAR **pCursor )
{
    if (Cursor == NULL)
        {
        Cursor = m_Value->m_Data;
        }

    WCHAR * Token = NULL;

    if (Cursor < m_Value->m_Data + m_Value->m_Count)
        {
        Token = wcstok( Cursor, Separators );
        }

    if (Token)
        {
        *pCursor = Token + wcslen(Token) + 1;
        }
    else
        {
        *pCursor = m_Value->m_Data + m_Value->m_Count;
        }

    return Token;
}

typedef auto_ptr<WCHAR> CAutoStringW;
typedef auto_ptr<TCHAR> CAutoStringT;
typedef auto_ptr<char> CAutoStringA;
typedef  CAutoStringW CAutoString;

//
// PSID does not have an obvious ordering of the type required by the MAP classes.
// So we define one here.
//
class CSidSorter
{
public:

    bool operator()( const SidHandle & psid1, const SidHandle & psid2 ) const;
};

PSID DuplicateSid( PSID _Sid );

//---------------------------------------------

enum FILE_DOWNLOAD_RESULT
{
    QM_IN_PROGRESS,
    QM_FILE_ABORTED,
    QM_FILE_DONE,
    QM_FILE_TRANSIENT_ERROR,
    QM_FILE_FATAL_ERROR,
    QM_SERVER_FILE_CHANGED
};
/*
 The source field is divided into regions, like NTSTATUS and HRESULT codes.
 The lowest-order bit is bit 0; the highest is bit 31.

  bit 31:     reserved, MBZ

  bits 30-29: component

                00 = unknown
                01 = queue manager
                10 = transport
                11 =

  bits 28-16: sub-component

                for queue manager:  0 = unknown
                                    1 = local file handling
                                    2 = queue management
                                    3 = notification

                for transport:      0 = unknown
                                    1 = HTTP
                                    2 = HTTPS
                                    3 = FTP
                                    4 = SMB
                                    5 = DAV

  bits 15-0:  defined by sub-component

                for HTTP:           0 = unknown
                                    1 = client connection
                                    2 = server connection
                                    3 = server file handling

*/

#define COMPONENT_MASK  (0x3    << 30)
#define SUBCOMP_MASK    (0x3fff << 16)
#define FINAL_MASK      (0xffff << 0 )

#define COMPONENT_QMGR  (0x1 << 30)
#define COMPONENT_TRANS (0x2 << 30)

#define SUBCOMP_QMGR_FILE       (0x1 << 16)
#define SUBCOMP_QMGR_QUEUE      (0x2 << 16)
#define SUBCOMP_QMGR_NOTIFY     (0x3 << 16)
#define SUBCOMP_QMGR_CACHE      (0x4 << 16)

#define SUBCOMP_TRANS_HTTP      (COMPONENT_TRANS | (0x1 << 16))
#define SUBCOMP_TRANS_HTTPS     (COMPONENT_TRANS | (0x2 << 16))
#define SUBCOMP_TRANS_FTP       (COMPONENT_TRANS | (0x3 << 16))

enum ERROR_SOURCE
{
    SOURCE_NONE             = 0,
    SOURCE_QMGR_FILE        = (COMPONENT_QMGR | SUBCOMP_QMGR_FILE   | 0x0),
    SOURCE_QMGR_QUEUE       = (COMPONENT_QMGR | SUBCOMP_QMGR_QUEUE  | 0x0),
    SOURCE_QMGR_NOTIFY      = (COMPONENT_QMGR | SUBCOMP_QMGR_NOTIFY | 0x0),

    SOURCE_HTTP_UNKNOWN     = (COMPONENT_TRANS | SUBCOMP_TRANS_HTTP | 0x0),
    SOURCE_HTTP_CLIENT_CONN = (COMPONENT_TRANS | SUBCOMP_TRANS_HTTP | 0x1),
    SOURCE_HTTP_SERVER      = (COMPONENT_TRANS | SUBCOMP_TRANS_HTTP | 0x2),
    SOURCE_HTTP_SERVER_FILE = (COMPONENT_TRANS | SUBCOMP_TRANS_HTTP | 0x3),
    SOURCE_HTTP_SERVER_APP  = (COMPONENT_TRANS | SUBCOMP_TRANS_HTTP | 0x4)
};

enum ERROR_STYLE
{
    ERROR_STYLE_NONE        = 0,
    ERROR_STYLE_HRESULT     = 1,
    ERROR_STYLE_WIN32       = 2,
    ERROR_STYLE_HTTP        = 3
};

struct QMErrInfo
{
    FILE_DOWNLOAD_RESULT result;

    UINT64          Code;
    ERROR_STYLE     Style;
    ERROR_SOURCE    Source;
    wchar_t *       Description;

    QMErrInfo()
    {
        result = QM_FILE_DONE;
        Clear();
    }

    QMErrInfo(
        ERROR_SOURCE  Source,
        ERROR_STYLE   Style,
        UINT64        Code,
        char *        comment = 0
        );

    void
    Set(
        ERROR_SOURCE  Source,
        ERROR_STYLE   Style,
        UINT64        Code,
        char *        comment = 0
        );

    void Clear()
    {
        Source   = SOURCE_NONE;
        Style    = ERROR_STYLE_NONE;
        Code     = 0;
        Description = NULL;
    }

    bool IsSet()
    {
        return (Style != ERROR_STYLE_NONE);
    }

    void Log();

    bool operator==( const QMErrInfo & err )
    {
        if (Source == err.Source &&
            Style  == err.Style  &&
            Code   == err.Code)
            {
            return true;
            }

        return false;
    }

    bool operator!=( const QMErrInfo & err )
    {
        if (*this == err)
            {
            return false;
            }

        return true;
    }
};

//---------------------------------------------

const UINT64 NanoSec100PerSec = 10000000;    //no of 100 nanosecs per sec

const TCHAR * const C_BITS_USER_AGENT = _T("Microsoft BITS/") VER_PRODUCTVERSION_WSTRING;

// Registry keys
const TCHAR * const  C_QMGR_REG_KEY = _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\BITS");

// Registry Value(REG_SZ).
// Point to where to load the upgraded DLL
const TCHAR * const  C_QMGR_SERVICEDLL = _T("ServiceDLL");

// Registry Values(REG_DWORD/seconds)
const TCHAR * const  C_QMGR_STATE_INDEX            = _T("StateIndex");
const TCHAR * const  C_QMGR_JOB_INACTIVITY_TIMEOUT = _T("JobInactivityTimeout");
const TCHAR * const  C_QMGR_TIME_QUANTA_LENGTH     = _T("TimeQuantaLength");
const TCHAR * const  C_QMGR_NO_PROGRESS_TIMEOUT    = _T("JobNoProgressTimeout");
const TCHAR * const  C_QMGR_MINIMUM_RETRY_DELAY    = _T("JobMinimumRetryDelay");

// Logging registry Values(REG_DWORD)
const TCHAR * const C_QMGR_LOGFILE_SIZE            = _T("LogFileSize"); // In MB
const TCHAR * const C_QMGR_LOGFILE_FLAGS           = _T("LogFileFlags");
const TCHAR * const C_QMGR_LOGFILE_MINMEMORY       = _T("LogFileMinMemory"); // In MB

// default values
const UINT32 C_QMGR_JOB_INACTIVITY_TIMEOUT_DEFAULT  = (60ui64 * 60ui64 * 24ui64 * 90ui64); // 90 days
const UINT32 C_QMGR_TIME_QUANTA_LENGTH_DEFAULT      = (5 * 60); // 5 minutes
const UINT32 C_QMGR_NO_PROGRESS_TIMEOUT_DEFAULT     = (14 * 24 * 60 * 60); //14 days
const UINT32 C_QMGR_MINIMUM_RETRY_DELAY_DEFAULT     = (10 * 60); // ten minutes

// Logging default values
const UINT32 C_QMGR_LOGFILE_SIZE_DEFAULT            = 1;

#if DBG
// Debug/Non-ship mode
// everything except 0x010 - Ref Counts and 0x020 - State File
//
const UINT32 C_QMGR_LOGFILE_FLAGS_DEFAULT           = 0xFFCF;
#else
const UINT32 C_QMGR_LOGFILE_FLAGS_DEFAULT           = 0;
#endif

const UINT32 C_QMGR_LOGFILE_MINMEMORY_DEFAULT       = 120;

// Policy keys
const TCHAR * const  C_QMGR_POLICY_REG_KEY = _T("Software\\Policies\\Microsoft\\Windows\\BITS");

// Policy values
const TCHAR * const  C_QMGR_POLICY_JOB_INACTIVITY_TIMEOUT = _T("JobInactivityTimeout");

// Special directories
const TCHAR * const  C_QMGR_DIRECTORY = _T("\\Microsoft\\Network\\Downloader\\");

const wchar_t NullString[] = L"(null)";



// cfreg.cpp - Functions to handle registry keys
HRESULT GetRegStringValue(LPCTSTR lpszValueName, LPTSTR lpszBuffer, int iBufferSize);
HRESULT SetRegStringValue(LPCTSTR lpszValueName, LPCTSTR lpszNewValue);
HRESULT DeleteRegStringValue(LPCTSTR lpszValueName);
HRESULT GetRegDWordValue(LPCTSTR lpszValueName, LPDWORD pdwValue);
HRESULT SetRegDWordValue(LPCTSTR lpszValueName, DWORD dwValue);

// service.cxx
HRESULT SetServiceStartup( bool bAutoStart );

// helpers.cpp
BOOL QMgrFileExists(LPCTSTR szFile);
FILETIME GetTimeAfterDelta( UINT64 uDelta );
BOOL IsConnected();

LPCWSTR TruncateString( LPCWSTR String, SIZE_T MaxLength, auto_ptr<WCHAR> & AutoPointer );

//
// The standard error class.  This is the only type of C++ exception that
// BITS functions should throw.
//
class ComError
{
    HRESULT m_error;

public:

    ComError(HRESULT NewErrorCode) : m_error ( NewErrorCode ) {}

    HRESULT Error() { return m_error; }

};

inline void THROW_HRESULT( HRESULT hr )
{
    if (FAILED(hr))
        {
        throw ComError( hr );
        }
}

inline void ThrowLastError()
{
    throw ComError( HRESULT_FROM_WIN32( GetLastError() ));
}

////////////////////////////////////////////////////////////////////////
//
//   Global info class
//
////////////////////////////////////////////////////////////////////////


class GlobalInfo
{
private:

    GlobalInfo( TCHAR *QmgrDirectory,
                LARGE_INTEGER PerfamceCounterFrequency,
                HKEY QmgrRegistryRoot,
                UINT64 JobInactivityTimeout,
                UINT64 TimeQuantaLength,
                UINT32 DefaultNoProgressTimeout,
                UINT32 DefaultMinimumRetryDelay,
                SECURITY_DESCRIPTOR *MetadataSecurityDescriptor,
                DWORD MetadataSecurityDescriptorLength,
                SidHandle AdministratorsSid,
                SidHandle LocalSystemSid,
                SidHandle NetworkUsersSid
                );

    ~GlobalInfo();

public:

    static DWORD RegGetDWORD( HKEY hKey, const TCHAR * pValue, DWORD dwDefault );

    const TCHAR * const m_QmgrDirectory;
    const LARGE_INTEGER m_PerformanceCounterFrequency;
    const HKEY m_QmgrRegistryRoot;
    const UINT64 m_JobInactivityTimeout;
    const UINT64 m_TimeQuantaLength;
    const UINT32 m_DefaultNoProgressTimeout;
    const UINT32 m_DefaultMinimumRetryDelay;
    const SECURITY_DESCRIPTOR * const m_MetadataSecurityDescriptor;
    const DWORD m_MetadataSecurityDescriptorLength;
    const SidHandle m_AdministratorsSid;
    const SidHandle m_LocalSystemSid;
    const SidHandle m_NetworkUsersSid;

    static HRESULT Init(void);
    static HRESULT Uninit(void);

};

extern class GlobalInfo *g_GlobalInfo;

//
// variables to keep track of service state
//
enum MANAGER_STATE
{
    MANAGER_INACTIVE,
    MANAGER_ACTIVE,
    MANAGER_TERMINATING
};

extern MANAGER_STATE g_ServiceState;
extern long          g_ServiceInstance;
extern DWORD         g_LastServiceControl;

//
// Jump to a label on failure.  Assumes an HRESULT "hr" and a label "Cleanup".
//
#define CLEANUP_ON_FAILURE( x ) \
                hr = x; \
                if (FAILED(hr)) \
                    { \
                    goto Cleanup; \
                    }

#define RETURN_HRESULT( x ) \
            { \
            HRESULT _hr_ = (x); \
            if (FAILED(_hr_)) \
                { \
                return _hr_; \
                } \
            }

#define GFA_FAILED   DWORD(-1)

inline BOOL FileExists( LPWSTR szFile )
{
    DWORD dwAttr = GetFileAttributes( szFile );

    if( GFA_FAILED == dwAttr )
        return FALSE;

    return (BOOL)( !(dwAttr & FILE_ATTRIBUTE_DIRECTORY) );
}

inline UINT64 FILETIMEToUINT64( const FILETIME & FileTime )
{
    ULARGE_INTEGER LargeInteger;
    LargeInteger.HighPart = FileTime.dwHighDateTime;
    LargeInteger.LowPart = FileTime.dwLowDateTime;
    return LargeInteger.QuadPart;
}

inline FILETIME UINT64ToFILETIME( UINT64 Int64Value )
{
    ULARGE_INTEGER LargeInteger;
    LargeInteger.QuadPart = Int64Value;

    FILETIME FileTime;
    FileTime.dwHighDateTime = LargeInteger.HighPart;
    FileTime.dwLowDateTime = LargeInteger.LowPart;

    return FileTime;
}

//------------------------------------------------------------------------
//
// NT security
//
//------------------------------------------------------------------------

SidHandle GetThreadClientSid();

HRESULT
ImpersonateSid(
    PSID sid
    );

BOOL
SidToString(
    PSID sid,
    wchar_t buffer[],
    USHORT bytes
    );

HRESULT
IsRemoteUser();

HRESULT
IsAdministratorUser();

HRESULT
DenyRemoteAccess();

HRESULT
DenyNonAdminAccess();

PSID DuplicateSid( PSID _Sid );

//
// Copy of RtlSecureZeroMemory() from the .Net Server tree.
//
FORCEINLINE
PVOID
MySecureZeroMemory(
    IN PVOID ptr, 
    IN SIZE_T cnt
    ) 
{
    volatile char *vptr = (volatile char *)ptr;
    while (cnt) {
        *vptr = 0;
        vptr++;
        cnt--;
    }
    return ptr;
}


//
// allows CreateInstanceInSession to choose an arbitrary session.
//
#define ANY_SESSION  DWORD(-1)

HRESULT
CreateInstanceInSession(
    REFCLSID clsid,
    REFIID   iid,
    DWORD    session,
    void **  pif
    );

HRESULT
SetStaticCloaking(
    IUnknown *pUnk
    );

HRESULT
ApplyIdentityToInterface(
  IUnknown *pUnk,
  PSID sid
  );

struct IBackgroundCopyCallback;
struct IBackgroundCopyCallback1;

HRESULT
CreateUserCallback(
  CLSID clsid,
  PSID sid,
  IBackgroundCopyCallback **pICB
  );

HRESULT
CreateOldUserCallback(
  CLSID clsid,
  PSID sid,
  IBackgroundCopyCallback1 **pICB
  );

HRESULT
SessionLogonCallback(
    DWORD SessionId
    );

HRESULT
SessionLogoffCallback(
    DWORD SessionId
    );

DWORD
DeviceEventCallback(
    DWORD dwEventType,
    LPVOID lpEventData
    );


BOOL Log_Init();
void Log_StartLogger();
void Log_Close();

HRESULT GlobalInit();
HRESULT GlobalUninit();

HRESULT InitQmgr();
HRESULT UninitQmgr();


const GUID BITSCtrlGuid = {0x4a8aaa94,0xcfc4,0x46a7,{0x8e,0x4e,0x17,0xbc,0x45,0x60,0x8f,0x0a}};

#define WPP_CONTROL_GUIDS \
    WPP_DEFINE_CONTROL_GUID(CtlGuid,(4a8aaa94,cfc4,46a7,8e4e,17bc45608f0a),  \
        WPP_DEFINE_BIT(LogFlagInfo)                 \
        WPP_DEFINE_BIT(LogFlagWarning)              \
        WPP_DEFINE_BIT(LogFlagError)                \
        WPP_DEFINE_BIT(LogFlagFunction)             \
        WPP_DEFINE_BIT(LogFlagRefCount)             \
        WPP_DEFINE_BIT(LogFlagSerialize)            \
        WPP_DEFINE_BIT(LogFlagDownload)             \
        WPP_DEFINE_BIT(LogFlagTask)                 \
        WPP_DEFINE_BIT(LogFlagLock)                 \
        WPP_DEFINE_BIT(LogFlagService)              \
        )


#define LogLevelEnabled(flags) WPP_LEVEL_ENABLED(flags)                                                       \

LONG ExternalFuncExceptionFilter( struct _EXCEPTION_POINTERS *ExceptionInfo );

//
// We keep track of COM calls because we can't delete our objects at shutdown
// until all the active calls have stopped referring to them.
//
extern long g_cCalls;

inline void IncrementCallCount()
{
    InterlockedIncrement(&g_cCalls);
}

inline void DecrementCallCount()
{
    InterlockedDecrement(&g_cCalls);
}

inline long ActiveCallCount()
{
    return g_cCalls;
}

//
// A simple helper class to keep track of our call count.
//
class DispatchedCall
{
public:
    DispatchedCall()  { IncrementCallCount(); }
    ~DispatchedCall() { DecrementCallCount(); }
};

//
// Each member function of our public COM interfaces has an external
// and an internal version.  The external version is simply
//    {
//        EXTERNAL_FUNC_WRAP( internal-version );
//    }
// This captures any exceptions in a way that can be reported by the OfficeWatson
// error-reporting apparatus.
// It also checks for service shutdown.
//
HRESULT
CheckServerInstance(
    long ObjectServiceInstance
    );

#define EXTERNAL_FUNC_WRAP( call_parent )                       \
                                                                \
    __try                                                       \
        {                                                       \
        RETURN_HRESULT( CheckServerInstance( m_ServiceInstance )); \
                                                                \
        HRESULT hr = call_parent ;                              \
                                                                \
        DecrementCallCount();                                   \
        return hr;                                              \
        }                                                       \
    __except( ExternalFuncExceptionFilter( GetExceptionInformation() ) ) \
        {                                                       \
        DecrementCallCount();                                   \
        return RPC_E_SERVERFAULT;                               \
        }                                                       \

//
// IUnknown member functions use these alternate macros.
//
#define BEGIN_EXTERNAL_FUNC                                     \
    __try                                                       \
        {                                                       \

#define END_EXTERNAL_FUNC                                       \
        }                                                       \
    __except( ExternalFuncExceptionFilter( GetExceptionInformation() ) ) \
        {                                                       \
        return RPC_E_SERVERFAULT;                               \
        }                                                       \


StringHandle
BITSCrackFileName(
    const WCHAR * RawFileName,
    StringHandle & ReturnFileName
    );

StringHandle
BITSCreateTempFile(
    StringHandle Directory
    );

HRESULT
BITSCheckFileWritability(
    LPCWSTR name
    );

StringHandle
CombineUrl(
    LPCWSTR BaseUrl,
    LPCWSTR RelativeUrl,
    DWORD Flags
    );

LPWSTR MidlCopyString( LPCWSTR source, size_t Length  = -1);

inline LPWSTR MidlCopyString( StringHandle source )
{
    return MidlCopyString( source, source.Size()+1 );
}

LPWSTR CopyString( LPCWSTR source, size_t Length  = -1);

inline LPWSTR CopyString( StringHandle source )
{
    return CopyString( source, source.Size()+1 );
}

inline bool operator==( const FILETIME left, const FILETIME right )
{
    return ((left.dwLowDateTime  == right.dwLowDateTime) &&
            (left.dwHighDateTime == right.dwHighDateTime));
}

inline bool operator!=( const FILETIME left, const FILETIME right )
{
    return !(left == right);
}

bool IsServiceShuttingDown();

bool IsAnyDebuggerPresent();

bool InitCompilerLibrary();
bool UninitCompilerLibrary();

#if defined(BITS_V12_ON_NT4)

extern ULONG BITSFlags;
void Log( const CHAR *Prefix, const CHAR *Format, va_list ArgList );

const DWORD LogFlagInfo         = 0;
const DWORD LogFlagWarning      = 1;
const DWORD LogFlagError        = 2;
const DWORD LogFlagFunction     = 4;
const DWORD LogFlagRefCount     = 8;
const DWORD LogFlagRef          = LogFlagRefCount;
const DWORD LogFlagSerialize    = 16;
const DWORD LogFlagSerial       = LogFlagSerialize;
const DWORD LogFlagDownload     = 32;
const DWORD LogFlagDl           = LogFlagDownload;
const DWORD LogFlagTask         = 64;
const DWORD LogFlagLock         = 128;
const DWORD LogFlagService      = 256;
const DWORD LogFlagPublicApiBegin = LogFlagFunction;
const DWORD LogFlagPublicApiEnd   = LogFlagFunction;

#define DEFINE_SIMPLE_LOG_FUNCT( flag, prefix )                    \
inline void Log##flag##( const char *format, ...)                  \
{                                                                  \
    if ( ! ( BITSFlags & ~LogFlag##flag ) )                        \
        return;                                                    \
    va_list marker;                                                \
    va_start( marker, format );                                    \
    Log( prefix, format, marker );                                 \
}                                                                  \

DEFINE_SIMPLE_LOG_FUNCT( Info,              " INFO        :" )
DEFINE_SIMPLE_LOG_FUNCT( Warning,           " WARNING     :" )
DEFINE_SIMPLE_LOG_FUNCT( Error,             " ERROR       :" )
DEFINE_SIMPLE_LOG_FUNCT( PublicApiBegin,    " FUNC_BEGIN  :" )
DEFINE_SIMPLE_LOG_FUNCT( PublicApiEnd,      " FUNC_END    :" )
DEFINE_SIMPLE_LOG_FUNCT( Ref,               " REF         :" )
DEFINE_SIMPLE_LOG_FUNCT( Lock,              " LOCK        :" )
DEFINE_SIMPLE_LOG_FUNCT( Task,              " TASK        :" )
DEFINE_SIMPLE_LOG_FUNCT( Service,           " SERVICE     :" )
DEFINE_SIMPLE_LOG_FUNCT( Dl,                " DOWNLOAD    :" )
DEFINE_SIMPLE_LOG_FUNCT( Serial,            " SERIALIZE   :" )

BOOL
BITSAltGetFileSizeEx(
   HANDLE hFile,              // handle to file
   PLARGE_INTEGER lpFileSize  // file size
   );

BOOL
BITSAltSetFilePointerEx(
    HANDLE hFile,                    // handle to file
    LARGE_INTEGER liDistanceToMove,  // bytes to move pointer
    PLARGE_INTEGER lpNewFilePointer, // new file pointer
    DWORD dwMoveMethod               // starting point
    );

BOOL
BITSAltConvertSidToStringSidW(
    IN  PSID     Sid,
    OUT LPWSTR  *StringSid
    );

BOOL
BITSAltConvertStringSidToSidW(
    IN LPCWSTR  StringSid,
    OUT PSID   *Sid
    );

BOOL
BITSAltCheckTokenMembership(
    IN HANDLE TokenHandle OPTIONAL,
    IN PSID SidToCheck,
    OUT PBOOL IsMember
    );

SERVICE_STATUS_HANDLE
BITSAltRegisterServiceCtrlHandlerExW(
  LPCTSTR lpServiceName,                // name of service
  LPHANDLER_FUNCTION_EX lpHandlerProc,  // handler function
  LPVOID lpContext                      // user data
);

#define GetFileSizeEx BITSAltGetFileSizeEx
#define SetFilePointerEx BITSAltSetFilePointerEx
#define ConvertSidToStringSidW BITSAltConvertSidToStringSidW
#define ConvertStringSidToSidW BITSAltConvertStringSidToSidW
#define CheckTokenMembership  BITSAltCheckTokenMembership
#define RegisterServiceCtrlHandlerExW BITSAltRegisterServiceCtrlHandlerExW

#endif