//#pragma hdrstop
/*++
	Kernel mode definitions and function prototypes for wdm model
--*/
#ifndef WDM_INCD
#define WDM_INCD

#pragma PAGEDCODE
#ifdef __cplusplus
extern "C"{
#endif

#include <wdm.h>
#include <stdio.h>
#include <stdarg.h>

#ifndef IRP_MN_QUERY_LEGACY_BUS_INFORMATION
#define IRP_MN_QUERY_LEGACY_BUS_INFORMATION 0x18
#endif

#if DBG && defined(_X86_)
#undef ASSERT
#define ASSERT(e) if(!(e)){DbgPrint("Assertion failure in"\
__FILE__", line %d: " #e "\n", __LINE__);\
_asm int 3\
}
#endif


#define BOOL BOOLEAN
#define FALSE 0
typedef UCHAR* PBYTE;


#define MSEC	*(-(LONGLONG)10000); //milliseconds 

///////////////////////////////////////////////////////////////////////////////
/************************* LISTS MANIPULATION MACROS **************************/
//  Doubly-linked list manipulation routines.  Implemented as macros
//  but logically these are procedures.

	/*
typedef struct _LIST_ENTRY {
   struct _LIST_ENTRY * volatile Flink;
   struct _LIST_ENTRY * volatile Blink;
} LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;

  */
#ifndef LIST_ENTRY_DEF
#define LIST_ENTRY_DEF

//  VOID
//  InitializeListHead(
//      PLIST_ENTRY ListHead
//      );
#define InitializeListHead(ListHead) (\
    (ListHead)->Flink = (ListHead)->Blink = (ListHead))

//  BOOLEAN
//  IsListEmpty(
//      PLIST_ENTRY ListHead
//      );
#define IsListEmpty(ListHead) \
    ((ListHead)->Flink == (ListHead))

//  PLIST_ENTRY
//  RemoveHeadList(
//      PLIST_ENTRY ListHead
//      );
#define RemoveHeadList(ListHead) \
    (ListHead)->Flink;\
    {RemoveEntryList((ListHead)->Flink)}

//  PLIST_ENTRY
//  RemoveTailList(
//      PLIST_ENTRY ListHead
//      );
#define RemoveTailList(ListHead) \
    (ListHead)->Blink;\
    {RemoveEntryList((ListHead)->Blink)}

//  VOID
//  RemoveEntryList(
//      PLIST_ENTRY Entry
//      );
#define RemoveEntryList(Entry) {\
    PLIST_ENTRY _EX_Blink;\
    PLIST_ENTRY _EX_Flink;\
    _EX_Flink = (Entry)->Flink;\
    _EX_Blink = (Entry)->Blink;\
    _EX_Blink->Flink = _EX_Flink;\
    _EX_Flink->Blink = _EX_Blink;\
    }

//  VOID
//  InsertTailList(
//      PLIST_ENTRY ListHead,
//      PLIST_ENTRY Entry
//      );
#define InsertTailList(ListHead,Entry) {\
    PLIST_ENTRY _EX_Blink;\
    PLIST_ENTRY _EX_ListHead;\
    _EX_ListHead = (ListHead);\
    _EX_Blink = _EX_ListHead->Blink;\
    (Entry)->Flink = _EX_ListHead;\
    (Entry)->Blink = _EX_Blink;\
    _EX_Blink->Flink = (Entry);\
    _EX_ListHead->Blink = (Entry);\
    }

//  VOID
//  InsertHeadList(
//      PLIST_ENTRY ListHead,
//      PLIST_ENTRY Entry
//      );
#define InsertHeadList(ListHead,Entry) {\
    PLIST_ENTRY _EX_Flink;\
    PLIST_ENTRY _EX_ListHead;\
    _EX_ListHead = (ListHead);\
    _EX_Flink = _EX_ListHead->Flink;\
    (Entry)->Flink = _EX_Flink;\
    (Entry)->Blink = _EX_ListHead;\
    _EX_Flink->Blink = (Entry);\
    _EX_ListHead->Flink = (Entry);\
    }

//  PSINGLE_LIST_ENTRY
//  PopEntryList(
//      PSINGLE_LIST_ENTRY ListHead
//      );
#define PopEntryList(ListHead) \
    (ListHead)->Next;\
    {\
        PSINGLE_LIST_ENTRY FirstEntry;\
        FirstEntry = (ListHead)->Next;\
        if (FirstEntry != NULL) {     \
            (ListHead)->Next = FirstEntry->Next;\
        }                             \
    }

//  VOID
//  PushEntryList(
//      PSINGLE_LIST_ENTRY ListHead,
//      PSINGLE_LIST_ENTRY Entry
//      );
#define PushEntryList(ListHead,Entry) \
    (Entry)->Next = (ListHead)->Next; \
    (ListHead)->Next = (Entry)

#endif //LIST_ENTRY

#ifndef CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field) ((type *)( \
                                                  (PCHAR)(address) - \
                                                  (ULONG_PTR)(&((type *)0)->field)))
#endif

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

#ifndef FIELDOFFSET
	#define FIELDOFFSET(type, field) ((DWORD)(&((type *)0)->field))
#endif


#ifndef CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field) ((type *)( \
                                                  (PCHAR)(address) - \
                                                  (ULONG_PTR)(&((type *)0)->field)))
#endif

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


#ifdef __cplusplus
}
#endif

// Macros to verify allocated objects
#define ALLOCATED_OK(obj) \
	((obj!=(VOID *)0) && NT_SUCCESS((obj)->m_Status))

#define DISPOSE_OBJECT(obj) \
		{if((obj!=(VOID *)0))	obj->dispose(); obj = NULL;}

#define RETURN_VERIFIED_OBJECT(obj) \
if(ALLOCATED_OK(obj)) return obj;	\
else								\
{									\
	DISPOSE_OBJECT(obj);			\
	return NULL;					\
}

// derived class Unicode string
#define TYPE_SYSTEM_ALLOCATED 0
#define TYPE_DRIVER_ALLOCATED 1

extern ULONG ObjectCounter;
//::DBG_PRINT("=== Deleting Object %8.8lX",ptr);\
// Overrides for library new and delete operators.

/*
inline VOID* __cdecl operator new(ULONG size, POOL_TYPE iType)\
{PVOID	pMem; if(pMem = ::ExAllocatePoolWithTag(iType,size,'_GRU'))\
{ ObjectCounter++; ::RtlZeroMemory(pMem,size); DBG_PRINT("\n=== New Object %8.8lX, %d\n",pMem,ObjectCounter);\
	return pMem; \
} else return NULL; };

inline VOID __cdecl operator delete(VOID* ptr)\
{ if(ptr){ObjectCounter--; DBG_PRINT("\n=== Deleting Object %8.8lX, %d\n",ptr,ObjectCounter); ::ExFreePool((PVOID)ptr);}\
};
*/


#pragma LOCKEDCODE
inline VOID* __cdecl operator new(size_t size, POOL_TYPE iType)\
{PVOID	pMem; if(pMem = ::ExAllocatePoolWithTag(iType,size,'URG_'))\
{ ObjectCounter++; ::RtlZeroMemory(pMem,size);\
	return pMem; \
} else return NULL; };

inline VOID __cdecl operator delete(VOID* ptr)\
{ if(ptr){ObjectCounter--; ::ExFreePool((PVOID)ptr);}\
};


#include "generic.h"

#pragma PAGEDCODE
template <class T>
class CLinkedList
{
public:
	NTSTATUS m_Status;
	VOID self_delete(VOID){delete this;};
	virtual VOID dispose(VOID){self_delete();};
protected:
    LIST_ENTRY head;
    KSPIN_LOCK splock;

public:
    CLinkedList()
    {
        InitializeListHead(&head);
        KeInitializeSpinLock(&splock);
    };
    
    BOOLEAN IsEmpty(VOID) { return IsListEmpty(&head); };
    ~CLinkedList()
    {    // if list is still not empty, free all items
		T *p;
        while (p=(T *) ExInterlockedRemoveHeadList(&head,&splock))
        {
			CONTAINING_RECORD(p,T,entry)->dispose();
        }
    };

    VOID New(T *p)
    {
        ExInterlockedInsertTailList(&head,&(p->entry),&splock);
    };

    VOID insertHead(T *p)
    {
        ExInterlockedInsertHeadList(&head,&(p->entry),&splock);
    };

    T*  removeHead(VOID)
    {
        T *p=(T *) ExInterlockedRemoveHeadList(&head,&splock);
        if (p) p=CONTAINING_RECORD(p,T,entry);
        return p;
    };
    VOID remove(T *p)
    {
        RemoveEntryList(&(p->entry));
    };
    
	T*  getNext(T* p)
    {        
		if (p)
		{
		PLIST_ENTRY	Next;
			Next = p->entry.Flink;
			if (Next && (Next!= &head))
			{
				T* pp=CONTAINING_RECORD(Next,T,entry);
				return pp;
			}
			else	return NULL;
		}
		return NULL;	
    };
	
	T*  getFirst()
    {   
		PLIST_ENTRY	Next = head.Flink;
		if (Next && Next!= &head)
		{
			T* p = CONTAINING_RECORD(Next,T,entry);
			return p;
		}
		return NULL;
    };
};

#pragma PAGEDCODE
class CUString 
{ 
public:
	NTSTATUS m_Status;
	VOID self_delete(VOID){delete this;};
	virtual VOID dispose(VOID){self_delete();};
private:
    UCHAR m_bType;
public:
    UNICODE_STRING m_String;
public:
	CUString(USHORT nSize)
	{
		m_Status = STATUS_INSUFFICIENT_RESOURCES;
		m_bType = TYPE_DRIVER_ALLOCATED;
		RtlInitUnicodeString(&m_String,NULL);
		m_String.MaximumLength = nSize;
		m_String.Buffer = (USHORT *)
			ExAllocatePool(PagedPool,nSize);
		if (!m_String.Buffer) return;  // leaving status the way it is
		RtlZeroMemory(m_String.Buffer,m_String.MaximumLength);
		m_Status = STATUS_SUCCESS;
	};
	
	CUString(PWCHAR uszString)
	{
		m_Status = STATUS_SUCCESS;
		m_bType = TYPE_SYSTEM_ALLOCATED;
		RtlInitUnicodeString(&m_String,uszString);
	};

	CUString(ANSI_STRING* pString)
	{
		m_Status = STATUS_SUCCESS;
		m_bType = TYPE_SYSTEM_ALLOCATED;
		RtlAnsiStringToUnicodeString(&m_String,pString,TRUE);
	};

	CUString(PCSTR pString)
	{
	ANSI_STRING AnsiString;
		m_Status = STATUS_SUCCESS;
		m_bType = TYPE_SYSTEM_ALLOCATED;
		RtlInitAnsiString(&AnsiString,pString);
		RtlAnsiStringToUnicodeString(&m_String,&AnsiString,TRUE);
	};



	CUString(PUNICODE_STRING uString)
	{
		m_Status = STATUS_INSUFFICIENT_RESOURCES;
		m_bType = TYPE_DRIVER_ALLOCATED;
		RtlInitUnicodeString(&m_String,NULL);
		m_String.MaximumLength = MAXIMUM_FILENAME_LENGTH;
		m_String.Buffer = (USHORT *)
			ExAllocatePool(PagedPool,MAXIMUM_FILENAME_LENGTH);
		if (!m_String.Buffer) return;  // leaving status the way it is
		RtlZeroMemory(m_String.Buffer,m_String.MaximumLength);

		RtlCopyUnicodeString(&m_String,uString);
		m_Status = STATUS_SUCCESS;
	};


	CUString(LONG iVal, LONG iBase)  
	{
		m_Status = STATUS_INSUFFICIENT_RESOURCES;
		m_bType = TYPE_DRIVER_ALLOCATED;
		RtlInitUnicodeString(&m_String,NULL);
		USHORT iSize=1;
		LONG iValCopy=(!iVal)?1:iVal;
		while (iValCopy>=1)
		{
			iValCopy/=iBase;
			iSize++;
		}    // now iSize carries the number of digits

		iSize*=sizeof(WCHAR);

		m_String.MaximumLength = iSize;
		m_String.Buffer = (USHORT *)
			ExAllocatePool(PagedPool,iSize);
		if (!m_String.Buffer) return;
		RtlZeroMemory(m_String.Buffer,m_String.MaximumLength);
		m_Status = RtlIntegerToUnicodeString(iVal, iBase, &m_String);
	};

	~CUString()
	{
		if ((m_bType == TYPE_DRIVER_ALLOCATED) && m_String.Buffer) 
			ExFreePool(m_String.Buffer);
	};

	VOID append(UNICODE_STRING *uszString)
	{
		m_Status = RtlAppendUnicodeStringToString(&m_String,uszString);
	};

	VOID copyTo(CUString *pTarget)
	{
		RtlCopyUnicodeString(&pTarget->m_String,&m_String);
	};

	BOOL operator==(CUString cuArg)
	{
		return (!RtlCompareUnicodeString(&m_String,
			&cuArg.m_String,FALSE));
	};

    LONG inline getLength() { return m_String.Length; };
    PWCHAR inline getString() { return m_String.Buffer; };
    VOID inline setLength(USHORT i) { m_String.Length = i; };
};


 // already included
#endif