windows-xp/Source/XPSP1/NT/net/qos/pclass/gpc/gpcmain.c

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

Copyright (c) 1996-1997  Microsoft Corporation

Module Name:

    gpcmain.c

Abstract:

    This file contains initialization stuff for the GPC
    and all the exposed APIs

Author:

    Ofer Bar - April 15, 1997

Environment:

    Kernel mode

Revision History:


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

#include "gpcpre.h"


/*
/////////////////////////////////////////////////////////////////
//
//   globals
//
/////////////////////////////////////////////////////////////////
*/

NDIS_STRING 	DriverName = NDIS_STRING_CONST( "\\Device\\Gpc" );
GLOBAL_BLOCK    glData;

GPC_STAT        glStat;
static          _init_driver = FALSE;
ULONG			GpcMinorVersion = 0;

#ifdef STANDALONE_DRIVER
GPC_EXPORTED_CALLS			glGpcExportedCalls;
#endif

#if DBG
CHAR VersionTimestamp[] = __DATE__ " " __TIME__;
#endif

// tags

ULONG					QueuedNotificationTag = 'nqpQ';
ULONG					PendingIrpTag = 'ippQ';
ULONG					CfInfoTag = 'icpQ';
ULONG					ClientTag = 'tcpQ';
ULONG					PatternTag = 'appQ';

ULONG					HandleFactoryTag = 'fhpQ';	// Gphf
ULONG					PathHashTag = 'hppQ';
ULONG					RhizomeTag = 'zrpQ';
ULONG					GenPatternDbTag = 'dppQ';
ULONG					FragmentDbTag = 'dfpQ';
ULONG					ClassificationFamilyTag = 'fcpQ';
ULONG					CfInfoDataTag = 'dcpQ';
ULONG					ClassificationBlockTag = 'bcpQ';
ULONG					ProtocolTag = 'tppQ';
ULONG					DebugTag = 'gdpQ';
ULONG                   RequestBlockTag = 'brpQ';

// Lookaside lists

NPAGED_LOOKASIDE_LIST	ClassificationFamilyLL;
NPAGED_LOOKASIDE_LIST	ClientLL;
NPAGED_LOOKASIDE_LIST	PatternLL;
NPAGED_LOOKASIDE_LIST	CfInfoLL;
NPAGED_LOOKASIDE_LIST	QueuedNotificationLL;
NPAGED_LOOKASIDE_LIST	PendingIrpLL;

ULONG 					ClassificationFamilyLLSize = sizeof( CF_BLOCK );
ULONG 					ClientLLSize = sizeof( CLIENT_BLOCK );
ULONG 					PatternLLSize = sizeof( PATTERN_BLOCK );
ULONG 					CfInfoLLSize = sizeof( BLOB_BLOCK );
ULONG 					QueuedNotificationLLSize = sizeof( QUEUED_NOTIFY );
ULONG 					PendingIrpLLSize = sizeof( PENDING_IRP );

/*
/////////////////////////////////////////////////////////////////
//
//   pragma
//
/////////////////////////////////////////////////////////////////
*/


//#pragma NDIS_INIT_FUNCTION(DriverEntry)

#if 0
#pragma NDIS_PAGEABLE_FUNCTION(DriverEntry)
#pragma NDIS_PAGEABLE_FUNCTION(GpcRegisterClient)
#pragma NDIS_PAGEABLE_FUNCTION(GpcDeregisterClient)
#pragma NDIS_PAGEABLE_FUNCTION(GpcAddCfInfo)
#pragma NDIS_PAGEABLE_FUNCTION(GpcAddPattern)
#pragma NDIS_PAGEABLE_FUNCTION(GpcAddCfInfoNotifyComplete)
#pragma NDIS_PAGEABLE_FUNCTION(GpcModifyCfInfo)
#pragma NDIS_PAGEABLE_FUNCTION(GpcModifyCfInfoNotifyComplete)
#pragma NDIS_PAGEABLE_FUNCTION(GpcRemoveCfInfo)
#pragma NDIS_PAGEABLE_FUNCTION(GpcRemoveCfInfoNotifyComplete)
#pragma NDIS_PAGEABLE_FUNCTION(GpcRemovePattern)
#endif

/*
/////////////////////////////////////////////////////////////////
//
//   prototypes
//
/////////////////////////////////////////////////////////////////
*/

#if DBG
NTSTATUS
InitializeLog();

VOID
FreeDebugLog(
    VOID);

#endif

VOID
GpcUnload (
    IN PDRIVER_OBJECT DriverObject
    );

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

InitGpc - 

The initialization routine. It is getting called during load time
and is responsible to call other initialization code.

Arguments
	none

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
InitGpc(void)
{
    GPC_STATUS	Status = STATUS_SUCCESS;
    ULONG		i, k;

	TRACE(INIT, 0, 0, "InitGpc");

    //
    // init the global data
    //

    RtlZeroMemory(&glData, sizeof(glData));

    InitializeListHead(&glData.CfList);
	NDIS_INIT_LOCK(&glData.Lock);
    
    //
    // Create a new Request list for blocked requests... [276945]
    //
    InitializeListHead(&glData.gRequestList);
    NDIS_INIT_LOCK(&glData.RequestListLock);

    k = sizeof(PROTOCOL_BLOCK) * GPC_PROTOCOL_TEMPLATE_MAX;

    GpcAllocMem(&glData.pProtocols, k, ProtocolTag);

    if (glData.pProtocols == NULL) {

        Status = GPC_STATUS_NO_MEMORY;

        TRACE(INIT, Status, 0, "InitGpc==>");

        return Status;
    }

    RtlZeroMemory(glData.pProtocols, k);
    RtlZeroMemory(&glStat, sizeof(glStat));

    for (i = 0; i < GPC_PROTOCOL_TEMPLATE_MAX; i++) {

        if ((Status = InitPatternTimer(i)) != STATUS_SUCCESS) {
            
            TRACE(INIT, Status, i, "InitGpc, timer==>");
            
            break;
        }

        //
        // init rest of strcture
        //
        
        glData.pProtocols[i].ProtocolTemplate = i;
        glData.pProtocols[i].SpecificPatternCount = 0;
        glData.pProtocols[i].AutoSpecificPatternCount = 0;
        glData.pProtocols[i].GenericPatternCount = 0;

        switch (i) {

        case GPC_PROTOCOL_TEMPLATE_IP:

            k = sizeof(GPC_IP_PATTERN);
            break;

        case GPC_PROTOCOL_TEMPLATE_IPX:

            k = sizeof(GPC_IPX_PATTERN);
            break;

        default:
            ASSERT(0);
        }

        glData.pProtocols[i].PatternSize = k;

        //
        // init specific pattern db
        //
        
        Status = InitSpecificPatternDb(&glData.pProtocols[i].SpecificDb, k);
        
        if (!NT_SUCCESS(Status)) {
            
            TRACE(INIT, Status, 0, "InitGpc==>");
            
            break;
        }

        //
        // init fragments db
        //
        
        Status = InitFragmentDb((PFRAGMENT_DB *)&glData.pProtocols[i].pProtocolDb);
        
        if (!NT_SUCCESS(Status)) {
            
            UninitSpecificPatternDb(&glData.pProtocols[i].SpecificDb);
            
            TRACE(INIT, Status, 0, "InitGpc==>");
            
            break;
        }
        
    } 	// for (i...)

    if (!NT_SUCCESS (Status)) {
        while (i-- != 0) {
            UninitSpecificPatternDb (&glData.pProtocols[i].SpecificDb);
            UninitFragmentDb((PFRAGMENT_DB)glData.pProtocols[i].pProtocolDb);
        }
        return Status;
    }
    //
    // init handle mapping table
    //

    Status = InitMapHandles();

    if (!NT_SUCCESS(Status)) {
	  
        TRACE(INIT, Status, 0, "InitGpc==>");

        for (i = 0; i < GPC_PROTOCOL_TEMPLATE_MAX; i++) {
            UninitSpecificPatternDb (&glData.pProtocols[i].SpecificDb);
            UninitFragmentDb((PFRAGMENT_DB)glData.pProtocols[i].pProtocolDb);
        }
        return Status;
    }

    //
    // init classification index table
    //

    Status = InitClassificationHandleTbl(&glData.pCHTable);

    if (!NT_SUCCESS(Status)) {
	  
        TRACE(INIT, Status, 0, "InitGpc==>");

        UninitMapHandles();
        for (i = 0; i < GPC_PROTOCOL_TEMPLATE_MAX; i++) {
            UninitSpecificPatternDb (&glData.pProtocols[i].SpecificDb);
            UninitFragmentDb((PFRAGMENT_DB)glData.pProtocols[i].pProtocolDb);
        }
        return Status;
    }


#ifdef STANDALONE_DRIVER

    //
    // initialize the exported calls table
    //

    glGpcExportedCalls.GpcVersion = GpcMajorVersion;
    glGpcExportedCalls.GpcGetCfInfoClientContextHandler = GpcGetCfInfoClientContext;
    glGpcExportedCalls.GpcGetCfInfoClientContextWithRefHandler = GpcGetCfInfoClientContextWithRef;
    glGpcExportedCalls.GpcGetUlongFromCfInfoHandler = GpcGetUlongFromCfInfo;
    glGpcExportedCalls.GpcRegisterClientHandler = GpcRegisterClient;
    glGpcExportedCalls.GpcDeregisterClientHandler = GpcDeregisterClient;
    glGpcExportedCalls.GpcAddCfInfoHandler = GpcAddCfInfo;
    glGpcExportedCalls.GpcAddPatternHandler = GpcAddPattern;
    glGpcExportedCalls.GpcAddCfInfoNotifyCompleteHandler = GpcAddCfInfoNotifyComplete;
    glGpcExportedCalls.GpcModifyCfInfoHandler = GpcModifyCfInfo;
    glGpcExportedCalls.GpcModifyCfInfoNotifyCompleteHandler = GpcModifyCfInfoNotifyComplete;
    glGpcExportedCalls.GpcRemoveCfInfoHandler = GpcRemoveCfInfo;
    glGpcExportedCalls.GpcRemoveCfInfoNotifyCompleteHandler = GpcRemoveCfInfoNotifyComplete;
    glGpcExportedCalls.GpcRemovePatternHandler = GpcRemovePattern;
    glGpcExportedCalls.GpcClassifyPatternHandler = GpcClassifyPattern;
    glGpcExportedCalls.GpcClassifyPacketHandler = GpcClassifyPacket;
    //glGpcExportedCalls.GpcEnumCfInfoHandler = GpcEnumCfInfo;

#endif

#if DBG

    //
    // for the debug version, add a ULONG_PTR for the GPC mark ULONG.
    // ULONG_PTR is used to ensure 8-byte alignment of the returned block on
    // 64-bit platforms.
    //

    ClassificationFamilyLLSize += sizeof( ULONG_PTR );
    ClientLLSize += sizeof( ULONG_PTR );
    PatternLLSize += sizeof( ULONG_PTR );
    CfInfoLLSize += sizeof( ULONG_PTR );
    QueuedNotificationLLSize += sizeof( ULONG_PTR );
    PendingIrpLLSize += sizeof( ULONG_PTR );
#endif

    NdisInitializeNPagedLookasideList(&ClassificationFamilyLL,
                                      NULL,
                                      NULL,
                                      0,
                                      ClassificationFamilyLLSize,
                                      ClassificationFamilyTag,
                                      (USHORT)0);

    NdisInitializeNPagedLookasideList(&ClientLL,
                                      NULL,
                                      NULL,
                                      0,
                                      ClientLLSize,
                                      ClientTag,
                                      (USHORT)0);

    NdisInitializeNPagedLookasideList(&PatternLL,
                                      NULL,
                                      NULL,
                                      0,
                                      PatternLLSize,
                                      PatternTag,
                                      (USHORT)0);

    NdisInitializeNPagedLookasideList(&CfInfoLL,
                                      NULL,
                                      NULL,
                                      0,
                                      CfInfoLLSize,
                                      CfInfoTag,
                                      (USHORT)0);

    NdisInitializeNPagedLookasideList(&QueuedNotificationLL,
                                      NULL,
                                      NULL,
                                      0,
                                      QueuedNotificationLLSize,
                                      QueuedNotificationTag,
                                      (USHORT)0);

    NdisInitializeNPagedLookasideList(&PendingIrpLL,
                                      NULL,
                                      NULL,
                                      0,
                                      PendingIrpLLSize,
                                      PendingIrpTag,
                                      (USHORT)0);

    TRACE(INIT, Status, 0, "InitGpc==>");


	return Status;
}





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

DriverEntry -

The driver's entry point.

Arguments
	DriverObject - Pointer to the driver object created by the system.
        RegistryPath - string path to the registry.

Returns
	NT_STATUS

************************************************************************
*/
NTSTATUS
DriverEntry(
	IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath
    )
{
    GPC_STATUS		Status;
    ULONG			dummy = 0;
    PWCHAR          EventLogString = DriverName.Buffer;

    _init_driver = TRUE;


#if DBG

    //
    // first thing, init the trace log
    //

    Status = InitializeLog();

    if (Status != STATUS_SUCCESS) {
     
        KdPrint(("!!! GPC Failed to initialize trace log !!!\n", Status));
    }
#endif

    DriverObject->DriverUnload = GpcUnload;
    //
    // Call the init routine
    //
    
    Status = InitGpc();
    
    if (NT_SUCCESS(Status)) {
        
        //
        // initialize the file system device
        //
        
        Status = (GPC_STATUS)IoctlInitialize(DriverObject, &dummy);
        
        if (!NT_SUCCESS(Status)) {
            
            NdisWriteEventLogEntry(DriverObject,
                                   EVENT_TRANSPORT_REGISTER_FAILED,
                                   GPC_ERROR_INIT_IOCTL,
                                   1,
                                   &EventLogString,
                                   0,
                                   NULL);
        }

    } else {

        NdisWriteEventLogEntry(DriverObject,
                               EVENT_TRANSPORT_REGISTER_FAILED,
                               GPC_ERROR_INIT_MAIN,
                               1,
                               &EventLogString,
                               0,
                               NULL);
#if DBG
        FreeDebugLog ();
#endif
    }

#if DBG
    if (!NT_SUCCESS(Status)) {
        KdPrint(("!!! GPC loading Failed (%08X) !!!\n", Status));        
    }
#endif

    return (NTSTATUS)Status;

} // end DriverEntry
VOID
GpcUnload(
    IN PDRIVER_OBJECT DriverObject
    )
{
    ULONG i;

    NdisDeleteNPagedLookasideList(&ClassificationFamilyLL);
    NdisDeleteNPagedLookasideList(&ClientLL);
    NdisDeleteNPagedLookasideList(&PatternLL);
    NdisDeleteNPagedLookasideList(&CfInfoLL);
    NdisDeleteNPagedLookasideList(&QueuedNotificationLL);
    NdisDeleteNPagedLookasideList(&PendingIrpLL);

    UninitClassificationHandleTbl(glData.pCHTable);
    UninitMapHandles();

    for (i = 0; i < GPC_PROTOCOL_TEMPLATE_MAX; i++) {
        UninitSpecificPatternDb (&glData.pProtocols[i].SpecificDb);
        UninitFragmentDb((PFRAGMENT_DB)glData.pProtocols[i].pProtocolDb);
    }
    GpcFreeMem(glData.pProtocols, ProtocolTag);
#if DBG
    FreeDebugLog ();
#endif

}




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

GpcGetCfInfoClientContext -

Returns the client context for blob

Arguments
    ClientHandle - the calling client's handle
	ClassificationHandle - needless to say

Returns
	A CfInfo client context or NULL if the classification 
	handle is invalid

************************************************************************
*/
GPC_STATUS
GpcGetCfInfoClientContext(
	IN	GPC_HANDLE				ClientHandle,
    IN	CLASSIFICATION_HANDLE	ClassificationHandle,
    OUT PGPC_CLIENT_HANDLE      pClientCfInfoContext
    )
{
    PBLOB_BLOCK				pBlob;
    GPC_CLIENT_HANDLE		h;
    KIRQL					CHirql;
    NTSTATUS                Status;
    PCLASSIFICATION_BLOCK   pCB;

	TRACE(CLASSIFY, ClientHandle, ClassificationHandle, "GpcGetCfInfoClientContext");

    pCB = NULL;

	if (ClientHandle == NULL) {
        
        *pClientCfInfoContext = NULL;
	    return GPC_STATUS_INVALID_PARAMETER;

    }

    READ_LOCK(&glData.ChLock, &CHirql);

	pBlob = (PBLOB_BLOCK)dereference_HF_handle_with_cb(
							glData.pCHTable,
                            ClassificationHandle,
                            GetCFIndexFromClient(ClientHandle));

	if (pBlob == NULL) {
    
        pCB = dereference_HF_handle(
                                    glData.pCHTable,
                                    ClassificationHandle);

        READ_UNLOCK(&glData.ChLock, CHirql);

        if (!pCB) {

            Status = GPC_STATUS_INVALID_HANDLE;

        } else {
        
            Status = GPC_STATUS_NOT_FOUND;

        }

        *pClientCfInfoContext = 0;

        return Status;
    }

#if DBG
    {
        //
        // Get the client index to reference into the ClientCtx table
        //
        
        ULONG t = GetClientIndexFromClient(ClientHandle);

        ASSERT(t < MAX_CLIENTS_CTX_PER_BLOB);
        
        TRACE(CLASSIFY, ClassificationHandle, pBlob->arClientCtx[t],
              "GpcGetCfInfoClientContext (ctx)");
    }
#endif

    h = pBlob->arClientCtx[GetClientIndexFromClient(ClientHandle)];

    READ_UNLOCK(&glData.ChLock, CHirql);

	TRACE(CLASSIFY, pBlob, h, "GpcGetCfInfoClientContext==>");
    
    *pClientCfInfoContext = h;

    return GPC_STATUS_SUCCESS;
}


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

GpcGetCfInfoClientContextWithRef -

Returns the client context for blob and increments a Dword provided by
the client. This function can be used by clients to synchronize access
to their structures on the remove and send path.

Arguments
    ClientHandle - the calling client's handle
	ClassificationHandle - needless to say
    Offset - Offset to location that needs to be incremented.

Returns
	A CfInfo client context or NULL if the classification 
	handle is invalid

************************************************************************
*/
GPC_CLIENT_HANDLE
GpcGetCfInfoClientContextWithRef(
	IN	GPC_HANDLE				ClientHandle,
    IN	CLASSIFICATION_HANDLE	ClassificationHandle,
    IN  ULONG                   Offset
    )
{
    PBLOB_BLOCK				pBlob;
    GPC_CLIENT_HANDLE		h;
    KIRQL					CHirql;
    PULONG                  RefPtr = NULL;

	TRACE(CLASSIFY, ClientHandle, ClassificationHandle, "GpcGetCfInfoClientContextWithRef");

	if (ClientHandle == NULL)
	  return NULL;

    READ_LOCK(&glData.ChLock, &CHirql);

	pBlob = (PBLOB_BLOCK)dereference_HF_handle_with_cb(
							glData.pCHTable,
                            ClassificationHandle,
                            GetCFIndexFromClient(ClientHandle));

    
	if (pBlob == NULL) {

        READ_UNLOCK(&glData.ChLock, CHirql);

        return NULL;

    } 
    
#if DBG
    {
        //
        // Get the client index to reference into the ClientCtx table
        //
        
        ULONG t = GetClientIndexFromClient(ClientHandle);

        ASSERT(t < MAX_CLIENTS_CTX_PER_BLOB);
        
        TRACE(CLASSIFY, ClassificationHandle, pBlob->arClientCtx[t],
              "GpcGetCfInfoClientContextWithRef (ctx)");
    }
#endif

    h = pBlob->arClientCtx[GetClientIndexFromClient(ClientHandle)];

    //
    // As part of 390882, it has been noted that sometimes the handle can
    // NULL, this could be either due to an Auto pattern or a generic 
    // pattern.
    //
    if (!h) {
        
        READ_UNLOCK(&glData.ChLock, CHirql);
        TRACE(CLASSIFY, pBlob, h, "GpcGetCfInfoClientContextWithRef==>");
        return NULL;

    }

    // The GPC Clients wants GPC to increment the memory at this offset.
    ASSERT(h);
    RefPtr = (PULONG) (((PUCHAR)h) + Offset);
    InterlockedIncrement(RefPtr);

    //(*((PUCHAR)h + Offset))++;

    READ_UNLOCK(&glData.ChLock, CHirql);

	TRACE(CLASSIFY, pBlob, h, "GpcGetCfInfoClientContextWithRef==>");

    return h;
}




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

GpcGetUlongFromCfInfo -

Returns a ulong in the blob data pointer from the classification handle for
the particular client.

Arguments
    ClientHandle    - the client handle
    ClassificationHandle - the classification handle
    Offset          - oofset in bytes into the CfInfo structure
    pValue          - store for the returned value

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
GpcGetUlongFromCfInfo(
	IN	GPC_HANDLE				ClientHandle,
    IN	CLASSIFICATION_HANDLE	ClassificationHandle,
    IN	ULONG					Offset,
    IN	PULONG					pValue
    )
{
    KIRQL					irql;
    PCLASSIFICATION_BLOCK	pCB;
    PBLOB_BLOCK				pBlob;

    ASSERT( pValue );

	TRACE(CLASSIFY, ClientHandle, ClassificationHandle, "GpcGetUlongFromCfInfo");

	if (ClientHandle == NULL)
	  return GPC_STATUS_INVALID_PARAMETER;

    READ_LOCK(&glData.ChLock, &irql);

	pCB = (PCLASSIFICATION_BLOCK)dereference_HF_handle(
							glData.pCHTable,
                            ClassificationHandle);

	if (pCB == NULL) {

        READ_UNLOCK(&glData.ChLock, irql);
    
        return GPC_STATUS_INVALID_HANDLE;
    }

    pBlob = pCB->arpBlobBlock[GetCFIndexFromClient(ClientHandle)];

    if (pBlob == NULL) {

        TRACE(CLASSIFY, pBlob, 0, "GpcGetUlongFromCfInfo-->");

        READ_UNLOCK(&glData.ChLock, irql);
    
        return GPC_STATUS_NOT_FOUND;
    }

	TRACE(CLASSIFY, ClassificationHandle, pBlob->pClientData, "GpcGetUlongFromCfInfo (2)");

    ASSERT( Offset+sizeof(ULONG) <= pBlob->ClientDataSize );
    ASSERT( pBlob->pClientData );

    if (pBlob->pClientData == NULL) {
        READ_UNLOCK(&glData.ChLock, irql);
        return (GPC_STATUS_FAILURE);
    }

    *pValue = *(PULONG)((PUCHAR)pBlob->pClientData + Offset);

    READ_UNLOCK(&glData.ChLock, irql);

	TRACE(CLASSIFY, pBlob, *pValue, "GpcGetUlongFromCfInfo==>");

    return GPC_STATUS_SUCCESS;
}




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

GetClientCtxAndUlongFromCfInfo -

Returns a ulong in the blob data pointer AND the client context
from the classification handle for the particular client.

Arguments
    ClientHandle    - the client handle
    ClassificationHandle - the classification handle
    Offset          - oofset in bytes into the CfInfo structure
    pValue          - store for the returned value

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
GetClientCtxAndUlongFromCfInfo(
	IN	GPC_HANDLE				ClientHandle,
    IN	OUT PCLASSIFICATION_HANDLE	pClassificationHandle,
    OUT PGPC_CLIENT_HANDLE		pClientCfInfoContext,
    IN	ULONG					Offset,
    IN	PULONG					pValue
    )
{
    PCLASSIFICATION_BLOCK	pCB;
    KIRQL					irql;
    PBLOB_BLOCK				pBlob;

    ASSERT( ClientHandle );
    ASSERT( pClientCfInfoContext || pValue );

	TRACE(CLASSIFY, ClientHandle, pClassificationHandle, "GetClientCtxAndUlongFromCfInfo");

    READ_LOCK(&glData.ChLock, &irql);

	pCB = (PCLASSIFICATION_BLOCK)dereference_HF_handle(
							glData.pCHTable,
                            *pClassificationHandle
                            );

	TRACE(CLASSIFY, pCB, GetCFIndexFromClient(ClientHandle), "GetClientCtxAndUlongFromCfInfo (2)");

	if (pCB == NULL) {

        //
        // didn't find the reference, which means the CH is probably invalid
        // reset it to 0 to indicate the caller that it should add a new one
        //

        *pClassificationHandle = 0;
        READ_UNLOCK(&glData.ChLock, irql);

        return GPC_STATUS_NOT_FOUND;
    }

    ASSERT(GetClientIndexFromClient(ClientHandle) < MAX_CLIENTS_CTX_PER_BLOB);

    pBlob = pCB->arpBlobBlock[GetCFIndexFromClient(ClientHandle)];

    if (pBlob == NULL) {

        TRACE(CLASSIFY, pBlob, 0, "GetClientCtxAndUlongFromCfInfo-->");

        READ_UNLOCK(&glData.ChLock, irql);

        return GPC_STATUS_NOT_FOUND;
    
    } 
    
    TRACE(CLASSIFY, *pClassificationHandle, pBlob->pClientData, "GetClientCtxAndUlongFromCfInfo (3)");

    ASSERT( Offset+sizeof(ULONG) <= pBlob->ClientDataSize );
    ASSERT( pBlob->pClientData );
    
    if (pClientCfInfoContext) {
        *pClientCfInfoContext = pBlob->arClientCtx[GetClientIndexFromClient(ClientHandle)];

        TRACE(CLASSIFY, pBlob, *pClientCfInfoContext, "GetClientCtxAndUlongFromCfInfo==>");

    }

    if (pValue) {
        *pValue = *(PULONG)((PUCHAR)pBlob->pClientData + Offset);

        TRACE(CLASSIFY, pBlob, *pValue, "GetClientCtxAndUlongFromCfInfo==>");

    }

    READ_UNLOCK(&glData.ChLock, irql);

    return GPC_STATUS_SUCCESS;
}



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

GpcRegisterClient -

	This will register the client in the GPC and return a client handle.
    If another client already registered for the same CF, we link this one
    on a list for the CF. The first client for the CF will cause a CF block
    to be created. CFs are identified by CfName. The other parameters will also
    be set in the client's block.

Arguments
	CfId 				- Id of the classification family
    Flags				- operation modes for the client:
							CF_FRAGMENT
    MaxPriorities		- max number of priorities the client will ever use
    pClientFuncList		- list of callback functions
    ClientContext		- client context, GPC will use it in callbacks
    pClientHandle		- OUT, the returned client handle
    
Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
GpcRegisterClient(
	IN	ULONG					CfId,
    IN	ULONG					Flags,
    IN  ULONG					MaxPriorities,
    IN	PGPC_CLIENT_FUNC_LIST	pClientFuncList,
    IN	GPC_CLIENT_HANDLE		ClientContext,
    OUT	PGPC_HANDLE				pClientHandle
    )
{
    GPC_STATUS		Status = GPC_STATUS_SUCCESS;
    PCF_BLOCK		pCf;
    PCLIENT_BLOCK	pClient= NULL;
    ULONG			i;
    PLIST_ENTRY		pHead, pEntry;
    KIRQL			irql;

	TRACE(REGISTER, CfId, ClientContext, "GpcRegisterClient");

    *pClientHandle = NULL;

    if (!_init_driver) {

        return GPC_STATUS_NOTREADY;
    }

    //
    // verify the CF Id
    //

    if (CfId >= GPC_CF_MAX) {
        
        TRACE(REGISTER, GPC_STATUS_INVALID_PARAMETER, CfId, "GpcRegisterClient-->");
        StatInc(RejectedCf);

        return GPC_STATUS_INVALID_PARAMETER;
    }

    //
    // verify the maximum number of priorities
    //

    if (MaxPriorities > GPC_PRIORITY_MAX) {
        
        TRACE(REGISTER, GPC_STATUS_INVALID_PARAMETER, MaxPriorities, "GpcRegisterClient~~>");
        StatInc(RejectedCf);

        return GPC_STATUS_INVALID_PARAMETER;
    }

    if (MaxPriorities == 0) {
        MaxPriorities = 1;
    }

    //
    // find the CF or create a new one
    //

    NDIS_LOCK(&glData.Lock);

    pHead = &glData.CfList;
    pEntry = pHead->Flink;
    pCf = NULL;

    while (pCf == NULL && pEntry != pHead) {

        pCf = CONTAINING_RECORD(pEntry, CF_BLOCK, Linkage);

        if (pCf->AssignedIndex != CfId) {

            pCf = NULL;
        }

        pEntry = pEntry->Flink;
    }

    if (pCf == NULL) {

        //
        // create a new CF
        //

        pCf = CreateNewCfBlock(CfId, MaxPriorities);

        if (pCf == NULL) {

            NDIS_UNLOCK(&glData.Lock);

            return GPC_STATUS_NO_MEMORY;
        }
     
        //
        // add the new CF to the list
        //

        GpcInsertTailList(&glData.CfList, &pCf->Linkage);
    }

    //
    // grab the CF lock before releasing the global lock
    //

    NDIS_UNLOCK(&glData.Lock);

    RSC_WRITE_LOCK(&pCf->ClientSync, &irql);

    NDIS_LOCK(&pCf->Lock);
    
    //
    // create a new client block and chain it on the CF block
    //

    pClient = CreateNewClientBlock();

    if (pClient == NULL) {

        //
        // oops
        //

        NDIS_UNLOCK(&pCf->Lock);

        RSC_WRITE_UNLOCK(&pCf->ClientSync, irql);

        TRACE(REGISTER, GPC_STATUS_RESOURCES, 0, "GpcRegisterClient==>");

        StatInc(RejectedCf);

        return GPC_STATUS_NO_MEMORY;
    }

    //
    // assign a new index to the client. This will also mark the index
    // as busy for this CF.
    //

    pClient->AssignedIndex = AssignNewClientIndex(pCf);

    if (pClient->AssignedIndex == (-1)) {

        //
        // too many clients
        //

        StatInc(RejectedCf);

        NDIS_UNLOCK(&pCf->Lock);

        RSC_WRITE_UNLOCK(&pCf->ClientSync, irql);

        ReleaseClientBlock(pClient);

        TRACE(REGISTER, GPC_STATUS_TOO_MANY_HANDLES, 0, "GpcRegisterClient==>");
        return GPC_STATUS_TOO_MANY_HANDLES;
    }

    //
    // init the client block
    //

    pClient->pCfBlock = pCf;
    pClient->ClientCtx = ClientContext;
    pClient->Flags = Flags;
    pClient->State = GPC_STATE_READY;

    if (pClientFuncList) {

        RtlMoveMemory(&pClient->FuncList, 
                      pClientFuncList, 
                      sizeof(GPC_CLIENT_FUNC_LIST));
    }

    //
    // add the client block to the CF and update CF
    //

    GpcInsertTailList(&pCf->ClientList, &pClient->ClientLinkage);

    pCf->NumberOfClients++;

    //
    // fill the output client handle
    //

    *pClientHandle = (GPC_CLIENT_HANDLE)pClient;

    //
    // release the lock
    //

    NDIS_UNLOCK(&pCf->Lock);

    RSC_WRITE_UNLOCK(&pCf->ClientSync, irql);

#if 0
    //
    // if this is not the first client for the CF, start a working
    // thread to notify the client about each installed blob for the CF.
    // In the call include:
    //

    if (!IsListEmpty(&pCf->BlobList)) {

        //
        // this is not the first client, start a notification thread
        //

    }
#endif

    TRACE(REGISTER, pClient, Status, "GpcRegisterClient==>");

    if (NT_SUCCESS(Status)) {

        StatInc(CreatedCf);
        StatInc(CurrentCf);

    } else {

        StatInc(RejectedCf);

    }

    return Status;
}




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

GpcDeregisterClient -

Deregisters the client and remove associated data from the GPC.

Arguments
	ClientHandle - client handle

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
GpcDeregisterClient(
	IN	GPC_HANDLE		ClientHandle
    )
{
    GPC_STATUS	    Status = STATUS_SUCCESS;
    PCLIENT_BLOCK   pClient;
    PCF_BLOCK       pCf;

	TRACE(REGISTER, ClientHandle, 0, "GpcDeregisterClient");

    pClient = (PCLIENT_BLOCK)ClientHandle;

    NDIS_LOCK(&pClient->Lock);

    pCf = pClient->pCfBlock;
    
    if (!IsListEmpty(&pClient->BlobList)) {

        Status = GPC_STATUS_NOT_EMPTY;

        NDIS_UNLOCK(&pClient->Lock);

        return Status;
    }

    if (pClient->State != GPC_STATE_READY) {

        //
        // HUH?!?
        // Client called to remove twice! probably caller bug
        // but we need to protect our selves.
        //

        NDIS_UNLOCK(&pClient->Lock);

        TRACE(REGISTER, GPC_STATUS_NOTREADY, 0, "GpcDeregisterClient==>");

        return GPC_STATUS_NOTREADY;
    }

    //
    // remove the client from the Cf's client list
    //
    
    pClient->State = GPC_STATE_REMOVE;
    pClient->ObjectType = GPC_ENUM_INVALID;

    //
    // release the client's mapping handle
    //
    
    FreeHandle(pClient->ClHandle);    

    //
    // remove the client from the CF list and return the index back
    //

#if 0
    NDIS_DPR_LOCK(&pCf->Lock);

    GpcRemoveEntryList(&pClient->ClientLinkage);
    ReleaseClientIndex(pCf->ClientIndexes, pClient->AssignedIndex);
#endif

    //
    // decrease number of clients
    //
        
    if (NdisInterlockedDecrement(&pCf->NumberOfClients) == 0) {
        
        TRACE(CLIENT, pClient, pCf->NumberOfClients, "NumberOfClients");
        
        //
        // last client on the CF, we may release all db
        //
        
        //UninitializeGenericDb(&pCf->pGenericDb, pCf->MaxPriorities);
    }    
        
    StatInc(DeletedCf);
    StatDec(CurrentCf);

#if 0
    NDIS_DPR_UNLOCK(&pCf->Lock);
#endif

    NDIS_UNLOCK(&pClient->Lock);

    //
    // release the client block
    //

    REFDEL(&pClient->RefCount, 'CLNT');
    
    TRACE(REGISTER, Status, 0, "GpcDeregisterClient==>");

    return Status;
}

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

GpcAddCfInfo -

Add A new blob. The blob is copied into the GPC and the GPC notifies
other client for the same CF about the installation.

Arguments
	ClientHandle		- client handle
    CfInfoSize			- size of the blob
    pClientCfInfoPtr	- pointer to the blob
    ClientCfInfoContext	- client's context to associate with the blob
    pGpcCfInfoHandle	- OUT, returned blob handle

Returns
	GPC_STATUS: SUCCESS, PENDING or FAILURE

************************************************************************
*/
GPC_STATUS
GpcAddCfInfo(
	IN	GPC_HANDLE				ClientHandle,
    IN	ULONG					CfInfoSize,
    IN	PVOID					pClientCfInfoPtr,
    IN	GPC_CLIENT_HANDLE		ClientCfInfoContext,
    OUT PGPC_HANDLE	    		pGpcCfInfoHandle
    )
{
    GPC_STATUS			Status = GPC_STATUS_SUCCESS;
    GPC_STATUS          Status1;
    PCLIENT_BLOCK		pClient;
    PCLIENT_BLOCK		pNotifyClient;
    PCLIENT_BLOCK		pNotifyClient2;
    PBLOB_BLOCK			pBlob;
    PCF_BLOCK			pCf;
    PLIST_ENTRY			pEntry, pHead;
    int                 i;
    GPC_CLIENT_HANDLE	ReturnedCtx;
    KIRQL				irql;

	TRACE(BLOB, ClientHandle, ClientCfInfoContext, "GpcAddCfInfo");

    VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);

    *pGpcCfInfoHandle = NULL;

    //
    // cast the client handle to the block
    //

    pClient = (PCLIENT_BLOCK)ClientHandle;
    
    ASSERT(pClient);

    pCf = pClient->pCfBlock;

    ASSERT(pCf);

    //
    // create a new blob block and copy the user data into
    //

    pBlob = CreateNewBlobBlock(CfInfoSize, pClientCfInfoPtr);

    if (pBlob) {

#if NO_USER_PENDING

        //
        // this will be only required until we implement the user level
        // pending report
        //

        CTEInitBlockStruc(&pBlob->WaitBlock);

#endif

        //
        // Add one reference count to the blob since if during
        // completion, it might be deleted (if the client fails)
        //

        REFADD(&pBlob->RefCount, 'ADCF');

        //
        // set the calling client context inside the blob
        //
        
        pBlob->arClientCtx[pClient->AssignedIndex] = ClientCfInfoContext;

        //
        // set the owner client's context
        //

        pBlob->OwnerClientCtx = ClientCfInfoContext;

        //
        // set pointer to installer and the state
        //

        pBlob->pOwnerClient = pClient;
        pBlob->State = GPC_STATE_ADD;

        //
        // init the client status array to keep track
        // of how many client have succeeded so far
        //
        
        RtlZeroMemory(pBlob->arpClientStatus, sizeof(pBlob->arpClientStatus));
        pBlob->ClientStatusCountDown = 0;

        //
        // notify each client
        //

        //NDIS_LOCK(&pCf->Lock);

        RSC_READ_LOCK(&pCf->ClientSync, &irql);

        pHead = &pCf->ClientList;
        pEntry = pHead->Flink;

        while (pEntry != pHead && (Status == GPC_STATUS_SUCCESS || 
                                   Status == GPC_STATUS_PENDING)) {

            //
            // get the notified client block
            //

            pNotifyClient = CONTAINING_RECORD(pEntry, 
                                              CLIENT_BLOCK, 
                                              ClientLinkage);

            if (pNotifyClient != pClient 
                && 
                !IS_USERMODE_CLIENT(pNotifyClient) ) {

                //
                // don't notify the caller
                //

                REFADD(&pNotifyClient->RefCount, 'ADCF');

                //
                // okay, we have bumped the ref count for this
                // client. No need to keep the lock 
                //

                RSC_READ_UNLOCK(&pCf->ClientSync, irql);
                //NDIS_UNLOCK(&pCf->Lock);
        
                //
                // increase number of count down clients,
                // so we keep track how many clients are still
                // pending. We do it *before* the call, since
                // the completion might be called before the notification
                // returns.
                //
                
                Status1 = ClientAddCfInfo
                    (pNotifyClient,
                     pBlob,
                     &ReturnedCtx
                     );

                if (Status1 == GPC_STATUS_PENDING) {
                    
                    pBlob->arClientCtx[pNotifyClient->AssignedIndex] = 
                        ReturnedCtx;
                    Status = GPC_STATUS_PENDING;
                    
                    if (pBlob->pNotifiedClient == NULL &&
                        pNotifyClient->FuncList.ClGetCfInfoName) {

                        TRACE(BLOB, pBlob, ReturnedCtx, "GpcAddCfInfo: (client)");

                        //ASSERT(ReturnedCtx);

                        //
                        // assume that is the client returned PENDING
                        // it has some interest in the blob...
                        //
                        
                        pBlob->pNotifiedClient = pNotifyClient;
                        pBlob->NotifiedClientCtx = ReturnedCtx;
                    }

                } else if (!NT_SUCCESS(Status1)) {
                    
                    //
                    // some failure, notify each client that reported
                    // success on the add blob, to remove it
                    //

                    //
                    // change the state to 'remove'
                    //
                    
                    pBlob->State = GPC_STATE_REMOVE;

                    //
                    // set the last status to the failure status
                    //

                    pBlob->LastStatus = Status = Status1;

                    REFDEL(&pNotifyClient->RefCount, 'ADCF');

                    for (i = 0; i < MAX_CLIENTS_CTX_PER_BLOB; i++) {

                        //
                        // only clients with none zero entries
                        // have succefully installed the blob
                        //

                        if (pNotifyClient = pBlob->arpClientStatus[i]) {
                            
                            //
                            // notify each client to remove the blob
                            //
                            
                            Status1 = ClientRemoveCfInfo
                                (
                                 pNotifyClient,
                                 pBlob,
                                 pBlob->arClientCtx[pNotifyClient->AssignedIndex]
                                 );
                            
                            if (Status1 != GPC_STATUS_PENDING) {
                                
                                //
                                // error or success
                                //

                                pBlob->arpClientStatus[i] = NULL;

                                //DereferenceClient(pNotifyClient);
                            }
                            
                        }

                    } // for

                    //
                    // don't notify other clients
                    //

                    //NDIS_LOCK(&pCf->Lock);
                    RSC_READ_LOCK(&pCf->ClientSync, &irql);
                    
                    break;

                } else {

                    //
                    // status success or ignored reported
                    //

                    if (Status1 == GPC_STATUS_SUCCESS) {
                        
                        pBlob->arClientCtx[pNotifyClient->AssignedIndex] = 
                            ReturnedCtx;
                        pBlob->arpClientStatus[pNotifyClient->AssignedIndex] = 
                            pNotifyClient;

                        if (pBlob->pNotifiedClient == NULL &&
                            pNotifyClient->FuncList.ClGetCfInfoName) {

                            TRACE(BLOB, pBlob, ReturnedCtx, "GpcAddCfInfo: (client 2)");
                            
                            //ASSERT(ReturnedCtx);

                            //
                            // update the notified client
                            //
                            
                            pBlob->pNotifiedClient = pNotifyClient;
                            pBlob->NotifiedClientCtx = ReturnedCtx;
                        }

                    }

                }

                //
                // This is a tricky part,
                // we need to let go of the ref count of the current client object
                // but get the next one...
                //
                
                //NDIS_LOCK(&pCf->Lock);
                RSC_READ_LOCK(&pCf->ClientSync, &irql);

                pEntry = pEntry->Flink;

                if (pEntry != pHead) {
                    
                    pNotifyClient2 = CONTAINING_RECORD(pEntry, 
                                                       CLIENT_BLOCK, 
                                                       ClientLinkage);

                    REFADD(&pNotifyClient2->RefCount, 'ADCF');

                }

                //
                // release the list lock since the next call will try to get it
                //

                RSC_READ_UNLOCK(&pCf->ClientSync, irql);
                 
                REFDEL(&pNotifyClient->RefCount, 'ADCF');

                RSC_READ_LOCK(&pCf->ClientSync, &irql);

                if (pEntry != pHead) {
                    
                    //
                    // safe to do since the list is locked
                    //

                    REFDEL(&pNotifyClient2->RefCount, 'ADCF');
                }

            } else {   // if (pNotifyClient != pClient)

                //
                // advance to the next client block
                //
                
                pEntry = pEntry->Flink;
            }
                
        } // while


        //
        // release the CF lock still got
        //

        //NDIS_UNLOCK(&pCf->Lock);

        RSC_READ_UNLOCK(&pCf->ClientSync, irql);

    } else { // if (pBlob)...
        
        //
        // error - no more memory?!?
        //

        Status = GPC_STATUS_RESOURCES;
    }

    if (NT_SUCCESS(Status)) {
        
        ASSERT(pBlob);

        *pGpcCfInfoHandle = (GPC_CLIENT_HANDLE)pBlob;

        if (Status == GPC_STATUS_SUCCESS) {

            //
            // add the blob to the CF and client lists
            //
            
            GpcInterlockedInsertTailList(&pClient->BlobList, 
                                         &pBlob->ClientLinkage,
                                         &pClient->Lock
                                         );
            GpcInterlockedInsertTailList(&pCf->BlobList, 
                                         &pBlob->CfLinkage,
                                         &pCf->Lock
                                         );
            
            pBlob->State = GPC_STATE_READY;
        }

    } else {
        
        //
        // failed - remove the blob
        //

        if (pBlob)
            REFDEL(&pBlob->RefCount, 'BLOB');
    }

    if (pBlob) {

        //
        // release the first refcount we got up there...
        //
        REFDEL(&pBlob->RefCount, 'ADCF');

    }

	TRACE(BLOB, pBlob, Status, "GpcAddCfInfo==>");

    if (Status == GPC_STATUS_SUCCESS) {

        CfStatInc(pCf->AssignedIndex,CreatedBlobs);
        CfStatInc(pCf->AssignedIndex,CurrentBlobs);

    } else if (Status != GPC_STATUS_PENDING) {

        CfStatInc(pCf->AssignedIndex,RejectedBlobs);
        
    }

    return Status;
}




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

GpcAddPattern -

This will install a pattern into the GPC database. The pattern is hooked
to a blob. The pattern can be specific or general.
Adding a specific pattern:
It goes into the specific hash table (per protocol block)
....
return a classification handle

Adding general pattern:
It goes into a separate Rhizome per CF and into its priority slot.
....

Arguments
	ClientHandle			- client handle
    ProtocolTemplate		- the protocol template ID to use
    Pattern					- pattern
    Mask					- patern mask
    Priority				- pattern priority in case of conflict
    GpcCfInfoHandle			- associated blob handle
    pGpcPatternHandle		- OUT, returned pattern handle
    pClassificationHandle	- OUT, for specific pattern only

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
GpcAddPattern(
	IN	GPC_HANDLE				ClientHandle,
    IN	ULONG					ProtocolTemplate,
    IN	PVOID					Pattern,
    IN	PVOID					Mask,
    IN	ULONG					Priority,
    IN	GPC_HANDLE				GpcCfInfoHandle,
    OUT	PGPC_HANDLE				pGpcPatternHandle,
    OUT	PCLASSIFICATION_HANDLE  pClassificationHandle
    )
{
    GPC_STATUS				Status;
    PCLIENT_BLOCK			pClient;
    PBLOB_BLOCK				pBlob;
    PPATTERN_BLOCK			pPattern, pCreatedPattern;
    PGENERIC_PATTERN_DB		pGenericDb;
    PCLASSIFICATION_BLOCK	pCB;
    ULONG					i;
    PUCHAR					p;
    ULONG					Flags;
    PPROTOCOL_BLOCK			pProtocolBlock;
    ULONG					CfIndex;
    PGPC_IP_PATTERN			pIpPattern;
    REQUEST_BLOCK           Request, *pRequest;
    PLIST_ENTRY             pLinkage;

	TRACE(PATTERN, ClientHandle, Pattern, "GpcAddPattern");

    VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);
    //VERIFY_OBJECT(GpcCfInfoHandle, GPC_ENUM_CFINFO_TYPE);

    ASSERT(pGpcPatternHandle);
    ASSERT(pClassificationHandle);

    *pGpcPatternHandle = NULL;
    *pClassificationHandle = (CLASSIFICATION_HANDLE)0;

    //
    // NdisInitializeEvent must run at PASSIVE (isnt that sad)
    //
    RtlZeroMemory(&Request, sizeof(REQUEST_BLOCK));
    NdisInitializeEvent(
                        &Request.RequestEvent
                        );
    
    //
    // cast the client handle to the block
    // and the CfInfo handle to a blob block
    //

    pClient = (PCLIENT_BLOCK)ClientHandle;
    pBlob = (PBLOB_BLOCK)GpcCfInfoHandle;

    ASSERT(pClient);

    CfIndex = pClient->pCfBlock->AssignedIndex;

    if (Priority >= pClient->pCfBlock->MaxPriorities ||
        ProtocolTemplate >= GPC_PROTOCOL_TEMPLATE_MAX ) {

        return GPC_STATUS_INVALID_PARAMETER;
    }

    if (pBlob != NULL) {
        NDIS_LOCK(&pBlob->Lock);

        if (pBlob->ObjectType != GPC_ENUM_CFINFO_TYPE) {

            NDIS_UNLOCK(&pBlob->Lock);
            return GPC_STATUS_INVALID_PARAMETER;
        }

    }

    NDIS_LOCK(&glData.RequestListLock);

    if (pBlob != NULL && pBlob->State != GPC_STATE_READY) {
     
        //
        // Block until it is safe to restart the work.
        //
        InsertTailList(&glData.gRequestList, &Request.Linkage);
            
        NDIS_UNLOCK(&glData.RequestListLock);
        
        //
        // doing something else
        //
        NDIS_UNLOCK(&pBlob->Lock);

        if (TRUE == NdisWaitEvent(
                                  &Request.RequestEvent,
                                  0
                                  )) {
            
            //
            // The wait was successful, continue with regularly scheduled programming.
            // This lock needs to be taken when we get out.
            NDIS_LOCK(&pBlob->Lock);
            
        } else {

            //
            // How could this happen? I dont know. 
            // Definitely need to investigate.
            //

            TRACE(PATTERN, GPC_STATUS_FAILURE, 0, "GpcAddPattern: The conflict <-> wait <-> resume plan has FAILED!\n");
            ASSERT(FALSE);
            return GPC_STATUS_NOTREADY;
        }

    } else {

        NDIS_UNLOCK(&glData.RequestListLock);

    }

    //
    // determine if the pattern is specific or generic
    //

    pProtocolBlock = &glData.pProtocols[ProtocolTemplate];

    if (ProtocolTemplate == GPC_PROTOCOL_TEMPLATE_IP) {

        //
        // 
        //

        pIpPattern = (PGPC_IP_PATTERN)Pattern;
        pIpPattern->Reserved[0] = pIpPattern->Reserved[1] = pIpPattern->Reserved[2] = 0;

        pIpPattern = (PGPC_IP_PATTERN)Mask;
        pIpPattern->Reserved[0] = pIpPattern->Reserved[1] = pIpPattern->Reserved[2] = 0xff;
    }

    for (i = 0, p=(PUCHAR)Mask; i < pProtocolBlock->PatternSize; i++, p++) {
        
        if (*p != 0xff)
            break;
        
    }

    //
    // set the Flags
    //

    Flags = (i < pProtocolBlock->PatternSize) ? 0 : PATTERN_SPECIFIC;

    if (pBlob != NULL) {

        //
        // change the blob state to ADD, so no one can delete it
        // while the pattern is being added to its list
        //
        
        pBlob->State = GPC_STATE_ADD;
        
        NDIS_UNLOCK(&pBlob->Lock);
    }

    //
    // increment ref counting
    //

    //NdisInterlockedIncrement(&pClient->RefCount);

    //
    // cerate a new pattern block
    //

    pPattern = CreateNewPatternBlock(Flags);

    pCreatedPattern = pPattern;

#if DBG

    {
        PGPC_IP_PATTERN	pIp = (PGPC_IP_PATTERN)Pattern;
        PGPC_IP_PATTERN	pMask = (PGPC_IP_PATTERN)Mask;

        DBGPRINT(PATTERN, ("GpcAddPattern: Client=%X %s - ", 
                           pClient,
                           TEST_BIT_ON(Flags, PATTERN_SPECIFIC)?"Specific":"Generic"));
        DBGPRINT(PATTERN, ("IP: ifc={%d,%d} src=%08X:%04x, dst=%08X:%04x, prot=%d rsv=%x,%x,%x\n", 
                           pIp->InterfaceId.InterfaceId,
                           pIp->InterfaceId.LinkId,
                           pIp->SrcAddr,
                           pIp->gpcSrcPort,
                           pIp->DstAddr,
                           pIp->gpcDstPort,
                           pIp->ProtocolId,
                           pIp->Reserved[0],
                           pIp->Reserved[1],
                           pIp->Reserved[2]
                           ));
        DBGPRINT(PATTERN, ("Mask: ifc={%x,%x} src=%08X:%04x, dst=%08X:%04x, prot=%x rsv=%x,%x,%x\n", 
                           pMask->InterfaceId.InterfaceId,
                           pMask->InterfaceId.LinkId,
                           pMask->SrcAddr,
                           pMask->gpcSrcPort,
                           pMask->DstAddr,
                           pMask->gpcDstPort,
                           pMask->ProtocolId,
                           pMask->Reserved[0],
                           pMask->Reserved[1],
                           pMask->Reserved[2]
                           ));
    }
#endif

    if (pPattern) {
        
        //
        // add one reference count to the pattern, so when we add it
        // to the db, we're sure it stays there
        //
        
        //pPattern->RefCount++;
        pPattern->Priority = Priority;
        pPattern->ProtocolTemplate = ProtocolTemplate;

        if (TEST_BIT_ON(Flags, PATTERN_SPECIFIC)) {

            //
            // add a specific pattern
            //
            
            Status = AddSpecificPattern(
                                        pClient,
                                        Pattern,
                                        Mask,
                                        pBlob,
                                        pProtocolBlock,
                                        &pPattern,  // output pattern pointer
                                        pClassificationHandle
                                        );

        } else {
            
            //
            // add a generic pattern
            //
            
            Status = AddGenericPattern(
                                       pClient,
                                       Pattern,
                                       Mask,
                                       Priority,
                                       pBlob,
                                       pProtocolBlock,
                                       &pPattern   // output pattern pointer
                                       );
            
        }

        // [OferBar]
        // release the extra ref count that was added
        // in the case of a specific pattern, this might be a totally different
        // one, but it should still have the extra ref-count
        // if there was an error, this will release the pattern
        // REFDEL(&pPattern->RefCount, 'FILT');


        // [ShreeM]
        // A reference FILT is added to a filter on creation. This will be substituted by 'ADSP' or
        // 'ADGP' whether it was a Generic Pattern or a Specific Pattern. However, it is likely that
        // in the AddSpecificPattern function, the pPattern got changed to something else because a
        // filter already existed. We want to ensure that the tag subsitution happens only in the 
        // case where pPattern was not replaced with the existing pattern in AddSpecificPattern.
        // 
        REFDEL(&pCreatedPattern->RefCount, 'FILT');

        //
        // check if failure, and if so - release the pattern block
        //
        
        if (NT_SUCCESS(Status)) {

            //
            // fill the output handle
            //
            
            *pGpcPatternHandle = (GPC_HANDLE)pPattern;
        }

    } else {

        Status = GPC_STATUS_RESOURCES;
    }

    if (pBlob != NULL) {

        //
        // change the state back to ready, so others can work on this blob
        //

        pBlob->State = GPC_STATE_READY;
    }

    //
    // release the extra ref count
    //

    //NdisInterlockedDecrement(&pClient->RefCount);

    TRACE(PATTERN, pPattern, Status, "GpcAddPattern==>");
        
    if (NT_SUCCESS(Status)) {

        if (TEST_BIT_ON(Flags, PATTERN_SPECIFIC)) {

            ProtocolStatInc(ProtocolTemplate,
                            CreatedSp);
            ProtocolStatInc(ProtocolTemplate,
                            CurrentSp);

            NdisInterlockedIncrement(&pProtocolBlock->SpecificPatternCount);            
            
            ASSERT(pProtocolBlock->SpecificPatternCount > 0);

        } else {

            ProtocolStatInc(ProtocolTemplate,
                            CreatedGp);
            ProtocolStatInc(ProtocolTemplate,
                            CurrentGp);

            NdisInterlockedIncrement(&pProtocolBlock->GenericPatternCount);            
            
            ASSERT(pProtocolBlock->GenericPatternCount > 0);

        }

    } else {

        if (TEST_BIT_ON(Flags, PATTERN_SPECIFIC)) {
            
            ProtocolStatInc(ProtocolTemplate,
                            RejectedSp);

        } else {

            ProtocolStatInc(ProtocolTemplate,
                            RejectedGp);
        }        
    }

    //
    // Check if some requests got queued while we were in there.
    //
    
    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);

    NDIS_LOCK(&glData.RequestListLock);
    
    if (!IsListEmpty(&glData.gRequestList)) {

        pLinkage = RemoveHeadList(&glData.gRequestList);

        NDIS_UNLOCK(&glData.RequestListLock);

        pRequest = CONTAINING_RECORD(pLinkage, REQUEST_BLOCK, Linkage);
        
        NdisSetEvent(&pRequest->RequestEvent);
        
    } else {

        NDIS_UNLOCK(&glData.RequestListLock);

    }

    return Status;
}



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

GpcAddCfInfoNotifyComplete -

A completion routine that the client will call after the GPC called into
the client's ClAddCfInfoNotify handler, but returned PENDING.
After all the clients have completed, a callback to the calling client's
ClAddCfInfoComplete is done to complete the GpcAddCfInfo call.

Arguments
	ClientHandle	- client handle
    GpcCfInfoHandle	- the blob handle
    Status			- completion status

Returns
	void

************************************************************************
*/
VOID
GpcAddCfInfoNotifyComplete(
	IN	GPC_HANDLE			ClientHandle,
    IN	GPC_HANDLE			GpcCfInfoHandle,
    IN	GPC_STATUS			Status,
	IN	GPC_CLIENT_HANDLE	ClientCfInfoContext
    )
{
    PCLIENT_BLOCK		pClient, pNotifyClient, pFirstClient;
    PBLOB_BLOCK			pBlob;
    //GPC_CLIENT_HANDLE	ClientCtx;
    //ULONG				cd;
    int                 i;
    GPC_STATUS          LastStatus, Status1;

	TRACE(BLOB, GpcCfInfoHandle, Status, "GpcAddCfInfoNotifyComplete");

    //VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);
    //VERIFY_OBJECT(GpcCfInfoHandle, GPC_ENUM_CFINFO_TYPE);

    pClient = (PCLIENT_BLOCK)ClientHandle;
    pBlob = (PBLOB_BLOCK)GpcCfInfoHandle;

    ASSERT(pBlob);
    ASSERT(pClient);
    ASSERT(Status != GPC_STATUS_PENDING);
    ASSERT(pBlob->ClientStatusCountDown > 0);

    if (NT_SUCCESS(Status)) {

        //
        // success reported, save the reporting client handle
        // so we can notify him to remove the blob in case of an error
        // down the road by another client for the same blob
        //

        ASSERT(pBlob->arpClientStatus[pClient->AssignedIndex] == NULL);

        pBlob->arpClientStatus[pClient->AssignedIndex] = pClient;

    } else {

        //
        // error reported, update the last status code.
        //

        pBlob->LastStatus = Status;

    }

    if (NdisInterlockedDecrement(&pBlob->ClientStatusCountDown) == 0) {
        
        //
        // all clients have reported
        //
        
        //
        // save the client's blob data, cuz it might get deleted
        // 

        //ClientCtx = pBlob->arClientCtx[pClient->AssignedIndex];
        LastStatus = pBlob->LastStatus;
        pFirstClient = pBlob->pOwnerClient;

        if (NT_ERROR(LastStatus)) {

            //
            // error has been previously reported by a client
            // tell each client that reported success to remove
            // the blob (sorry...)
            //

#if 0
            NDIS_LOCK(&pBlob->pOwnerClient->pCfBlock->Lock);
            
            GpcRemoveEntryList(&pBlob->CfLinkage);
            
            NDIS_DPR_LOCK(&pBlob->pOwnerClient->Lock);    
            GpcRemoveEntryList(&pBlob->ClientLinkage);
            NDIS_DPR_UNLOCK(&pBlob->pOwnerClient->Lock);

            NDIS_UNLOCK(&pBlob->pOwnerClient->pCfBlock->Lock);
#endif

            CTEInitBlockStruc(&pBlob->WaitBlockAddFailed);

            Status1 = GPC_STATUS_SUCCESS;

            for (i = 0; i < MAX_CLIENTS_CTX_PER_BLOB; i++) {
                
                //
                // only clients with none zero entries
                // have succefully installed the blob
                //
                
                if (pNotifyClient = pBlob->arpClientStatus[i]) {
                    
                    //
                    // notify each client to remove the blob
                    //
                    
                    if (ClientRemoveCfInfo
                        (
                         pNotifyClient,
                         pBlob,
                         pBlob->arClientCtx[pNotifyClient->AssignedIndex]
                         ) == GPC_STATUS_PENDING)

                        {
                            Status1 = GPC_STATUS_PENDING;

                        } else {

                            //DereferenceClient(pNotifyClient);
                        }
                }
                
            } // for
            
            if (Status1 == GPC_STATUS_PENDING) {

                //
                // Block on completion of all removals...
                //
                
                Status1 = CTEBlock(&pBlob->WaitBlockAddFailed);
                
            }

        } else {	// if (NT_ERROR(LastStats))...

            //
            // store the returned client context, since the call can be completed
            // before the notification handler returns.
            //

            pBlob->arClientCtx[pClient->AssignedIndex] = ClientCfInfoContext;

            //
            // add the blob to the CF and client lists
            //
            
            GpcInterlockedInsertTailList(&pBlob->pOwnerClient->BlobList, 
                                         &pBlob->ClientLinkage,
                                         &pBlob->pOwnerClient->Lock
                                         );
            GpcInterlockedInsertTailList(&pBlob->pOwnerClient->pCfBlock->BlobList, 
                                         &pBlob->CfLinkage,
                                         &pBlob->pOwnerClient->pCfBlock->Lock
                                         );
            
        }

        //
        // complete the request to the client
        //

        ClientAddCfInfoComplete(
                                pFirstClient, // first guy who made the call
                                pBlob,        // completing blob
                                LastStatus    // status
                                );
        
    }

    //
    // this will be done after the last client completes
    //

    //DereferenceClient(pClient);
}



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

GpcModifyCfInfo -

The client calls this to modify a blob. Each other client on the CF will
get notified. This routine returns PENDING and starts a working thread
to do the main job.

Arguments
	ClientHandle	- client handle
    GpcCfInfoHandle	- the handle of the blob to modify
    CfInfoSize		- new blob size
    pClientCfInfo	- new blob data pointer

Returns
	GPC_STATUS, PENDING is valid

************************************************************************
*/
GPC_STATUS
GpcModifyCfInfo(
	IN	GPC_HANDLE				ClientHandle,
    IN	GPC_HANDLE	    		GpcCfInfoHandle,
    IN	ULONG					CfInfoSize,
    IN  PVOID	    			pClientCfInfoPtr
    )
{
    GPC_STATUS			Status = GPC_STATUS_SUCCESS;
    GPC_STATUS          Status1;
    PCLIENT_BLOCK		pClient;
    PCLIENT_BLOCK		pNotifyClient;
    PCLIENT_BLOCK		pNotifyClient2;
    PBLOB_BLOCK			pBlob;
    PCF_BLOCK			pCf;
    PLIST_ENTRY			pEntry, pHead;
    int                 i;
    KIRQL				irql;

	TRACE(BLOB, ClientHandle, GpcCfInfoHandle, "GpcModifyCfInfo");

    VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);
    //VERIFY_OBJECT(GpcCfInfoHandle, GPC_ENUM_CFINFO_TYPE);

    ASSERT(pClientCfInfoPtr);

    //
    // cast the client handle to the block
    //

    pClient = (PCLIENT_BLOCK)ClientHandle;
    pBlob = (PBLOB_BLOCK)GpcCfInfoHandle;
    pCf = pClient->pCfBlock;

    ASSERT(pClient);
    ASSERT(pBlob);

    NDIS_LOCK(&pBlob->Lock);

    if (pBlob->ObjectType != GPC_ENUM_CFINFO_TYPE) {

        NDIS_UNLOCK(&pBlob->Lock);
        return GPC_STATUS_INVALID_PARAMETER;
    }

    //
    // check the blob is in READY state and change it to MODIFY state
    //

    if (pBlob->State != GPC_STATE_READY) {

        NDIS_UNLOCK(&pBlob->Lock);
        return GPC_STATUS_NOTREADY;
    }

    //
    // allocate private memory in the GPC to copy the client's data
    // into
    //

    GpcAllocMem(&pBlob->pNewClientData, CfInfoSize, CfInfoDataTag);

    if (pBlob->pNewClientData == NULL) {

        NDIS_UNLOCK(&pBlob->Lock);
        return GPC_STATUS_RESOURCES;
    }

    pBlob->NewClientDataSize = CfInfoSize;
    pBlob->State = GPC_STATE_MODIFY;

    //
    // we set the calling client here so we can notify it when the 
    // the modification is completed
    //

    pBlob->pCallingClient = pClient;

    NDIS_UNLOCK(&pBlob->Lock);

#if NO_USER_PENDING

    //
    // this will be only required until we implement the user level
    // pending report
    //
    
    CTEInitBlockStruc(&pBlob->WaitBlock);
    
#endif

    //
    // copy the memory
    //
    
    RtlMoveMemory(pBlob->pNewClientData, pClientCfInfoPtr, CfInfoSize);

    //
    // init the client status array to keep track
    // of how many client have succeeded so far
    //
    
    //RtlZeroMemory(pBlob->arpClientStatus, sizeof(pBlob->arpClientStatus));
    pBlob->ClientStatusCountDown = 0;
    pBlob->LastStatus = GPC_STATUS_SUCCESS;

    //
    // notify each client
    //
    
    //NDIS_LOCK(&pCf->Lock);

    RSC_READ_LOCK(&pCf->ClientSync, &irql);
    
    pHead = &pCf->ClientList;
    pEntry = pHead->Flink;
    
    while (pEntry != pHead && (Status == GPC_STATUS_SUCCESS || 
                               Status == GPC_STATUS_PENDING)) {

        //
        // get the notified client block
        //
        
        pNotifyClient = CONTAINING_RECORD(pEntry, CLIENT_BLOCK, ClientLinkage);
        
        if (pNotifyClient != pClient 
            &&
            pBlob->arpClientStatus[pNotifyClient->AssignedIndex]
            && 
            !IS_USERMODE_CLIENT(pNotifyClient) ) {

            //
            // don't notify the caller
            //

            REFADD(&pNotifyClient->RefCount, 'CFMF');
       
            //
            // okay, we have bumped the ref count for this
            // client. No need to keep the lock 
            //

            //NDIS_UNLOCK(&pCf->Lock);
            RSC_READ_UNLOCK(&pCf->ClientSync, irql);
            
            //
            // increase number of count down clients,
            // so we keep track how many clients are still
            // pending. We do it *before* the call, since
            // the completion might be called before the notification
            // returns.
            //
                
            Status1 = ClientModifyCfInfo
                (pNotifyClient,
                 pBlob,
                 CfInfoSize,
                 pBlob->pNewClientData
                 );

            TRACE(BLOB, pBlob, Status1, "GpcModifyCfInfo: (client)");

            //
            // grab the lock again since we're walking the list
            //
            
            //NDIS_LOCK(&pCf->Lock);
                
            //
            // now we check the Status1 code
            // the rules are:
            //  we stop on failure
            //  ignore GPC_STATUS_IGNORE
            //  and save PENDING status
            // 

            if (Status1 == GPC_STATUS_PENDING
                       && 
                       !NT_SUCCESS(pBlob->LastStatus)) {

                //
                // we've got back pending, but the client
                // actually completed the request
                // behind our back
                //

                Status = GPC_STATUS_PENDING;

                REFDEL(&pNotifyClient->RefCount, 'CFMF');

                RSC_READ_LOCK(&pCf->ClientSync, &irql);

                break;
                
            } else if (!NT_SUCCESS(Status1)) {
                    
                //
                // don't notify other clients
                //

                pBlob->LastStatus = Status = Status1;

                REFDEL(&pNotifyClient->RefCount, 'CFMF');

                RSC_READ_LOCK(&pCf->ClientSync, &irql);
                
                break;
                
            } else if (Status1 == GPC_STATUS_SUCCESS
                       ||
                       Status1 == GPC_STATUS_PENDING) {

                pBlob->arpClientStatus[pNotifyClient->AssignedIndex] = 
                    pNotifyClient;

                if (Status1 == GPC_STATUS_PENDING) {
                    Status = GPC_STATUS_PENDING;
                }

            }

            RSC_READ_LOCK(&pCf->ClientSync, &irql);

            pEntry = pEntry->Flink;

            if (pEntry != pHead) {
                
                pNotifyClient2 = CONTAINING_RECORD(pEntry, 
                                                   CLIENT_BLOCK, 
                                                   ClientLinkage);
                
                REFADD(&pNotifyClient2->RefCount, 'CFMF');

            }

            //
            // release the list lock since the next call will try to get it
            //
            
            RSC_READ_UNLOCK(&pCf->ClientSync, irql);
            
            REFDEL(&pNotifyClient->RefCount, 'CFMF');

            RSC_READ_LOCK(&pCf->ClientSync, &irql);
            
            if (pEntry != pHead) {
                
                //
                // safe to do since the list is locked
                //
                REFDEL(&pNotifyClient2->RefCount, 'CFMF');
                
            }
            
        } else {   // if (pNotifyClient != pClient)
        
            //
            // grab the next client block, 
            //
            
            pEntry = pEntry->Flink;

        }

    } // while
    
    
    //
    // release the CF lock still got
    //

    //NDIS_UNLOCK(&pCf->Lock);
    RSC_READ_UNLOCK(&pCf->ClientSync, irql);

    //
    // Status code should be either:
    //
    // GPC_STATUS_SUCCESS - all clients have been notified and returned SUCCESS
    // GPC_STATUS_PENDING - all clients have been notified, at least one
    //						return PENDING
    // Error code - at least one client failed
    //

    if (Status != GPC_STATUS_PENDING) {

        //
        // Note: the status here can be either FAILED or SUCCESS
        //
        // no client has been pending, so we complete the modification
        // back to the clients (except the caling client)
        //

        ModifyCompleteClients(pClient, pBlob);

        //
        // restore READY state
        //

        pBlob->State = GPC_STATE_READY;

    }

	TRACE(BLOB, pBlob, Status, "GpcModifyCfInfo==>");

    if (NT_SUCCESS(Status)) {

        CfStatInc(pCf->AssignedIndex,ModifiedBlobs);
        
    }

    return Status;
}





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

GpcModifyCfInfoNotifyComplete -

Called by clients to complete a previous call to ClModifyCfInfoNotify
made by the GPC.


Arguments
	ClientHandle	- client handle
    GpcCfInfoHandle	- the blob handle
    Status			- completion status

Returns
	GPC_STATUS

************************************************************************
*/
VOID
GpcModifyCfInfoNotifyComplete(
	IN	GPC_HANDLE		ClientHandle,
    IN	GPC_HANDLE		GpcCfInfoHandle,
    IN	GPC_STATUS		Status
    )
{
    PCLIENT_BLOCK		pClient, pNotifyClient;
    PBLOB_BLOCK			pBlob;

	TRACE(BLOB, GpcCfInfoHandle, Status, "GpcModifyCfInfoNotifyComplete");

    //VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);
    //VERIFY_OBJECT(GpcCfInfoHandle, GPC_ENUM_CFINFO_TYPE);

    pClient = (PCLIENT_BLOCK)ClientHandle;
    pBlob = (PBLOB_BLOCK)GpcCfInfoHandle;

    ASSERT(pBlob);
    ASSERT(pClient);
    ASSERT(Status != GPC_STATUS_PENDING);
    ASSERT(pBlob->ClientStatusCountDown > 0);

    if (NT_SUCCESS(Status)) {

        //
        // success reported, save the reporting client handle
        // so we can notify him to remove the blob in case of an error
        // down the road by another client for the same blob
        //

        ASSERT(pBlob->arpClientStatus[pClient->AssignedIndex] == pClient);

        //pBlob->arpClientStatus[pClient->AssignedIndex] = pClient;
        
    } else {

        //
        // error reported, update the last status code.
        //

        pBlob->LastStatus = Status;

    }

    if (NdisInterlockedDecrement(&pBlob->ClientStatusCountDown) == 0) {
        
        //
        // all clients have reported
        //
        
        ModifyCompleteClients(pClient, pBlob);

#if NO_USER_PENDING

        //
        // the user is blocking on this call
        //

        CTESignal(&pBlob->WaitBlock, Status);

#else
            
        //
        // now, complete the call back to the calling client
        //

        ClientModifyCfInfoComplete(
                                   pBlob->pCallingClient,
                                   pBlob,
                                   pBlob->LastStatus
                                   );

        pBlob->State = GPC_STATE_READY;

#endif
        
    }

	TRACE(BLOB, pClient, Status, "GpcModifyCfInfoNotifyComplete==>");
}




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

privateGpcRemoveCfInfo - 

Remove a blob from GPC. 


Arguments
	ClientHandle	- client handle
    GpcCfInfoHandle	- blob handle

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
privateGpcRemoveCfInfo(
	IN	GPC_HANDLE		ClientHandle,
    IN	GPC_HANDLE		GpcCfInfoHandle,
    IN   ULONG			Flags
    )
{
    GPC_STATUS	    Status = GPC_STATUS_SUCCESS;
    GPC_STATUS      Status1;
    PCLIENT_BLOCK   pClient;
    PCLIENT_BLOCK   pNotifyClient;
    PCLIENT_BLOCK   pNotifyClient2;
    PBLOB_BLOCK     pBlob;
    PCF_BLOCK       pCf;
    PPATTERN_BLOCK	pPattern;
    PLIST_ENTRY     pHead, pEntry;
    KIRQL			irql;
    PPROTOCOL_BLOCK pProtocol;
    ULONG           cClientRef;

	TRACE(BLOB, ClientHandle, GpcCfInfoHandle, "privateGpcRemoveCfInfo");

    VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);
    
    pClient = (PCLIENT_BLOCK)ClientHandle;
    pBlob   = (PBLOB_BLOCK)GpcCfInfoHandle;
    pCf     = pClient->pCfBlock;

    NDIS_LOCK(&pBlob->Lock);

    if (pBlob->ObjectType != GPC_ENUM_CFINFO_TYPE) {

        NDIS_UNLOCK(&pBlob->Lock);
        return GPC_STATUS_INVALID_PARAMETER;
    }


    if (pBlob->State != GPC_STATE_READY) {

        if (pBlob->pCallingClient2) {

            //
            // Can't handle more than 2 removals for the 
            // same flow.
            // another client has already requested the removal of 
            // this flow, we should fail here
            //

            NDIS_UNLOCK(&pBlob->Lock);

            TRACE(BLOB, GPC_STATUS_NOTREADY, 0, "privateGpcRemoveCfInfo==>");
            
            return GPC_STATUS_NOTREADY;

        }
         
        //
        // the flow is being removed when another client
        // requested its removal. we save this client handle
        // and we'll coplete it later
        //
        
        pBlob->pCallingClient2 = pClient;
    
        NDIS_UNLOCK(&pBlob->Lock);
        
        TRACE(BLOB, GPC_STATUS_PENDING, 0, "privateGpcRemoveCfInfo==>");
        
        return GPC_STATUS_PENDING;
    }
    
    //
    // remove the supported patterns on the cfinfo
    // there are two cases:
    //
    // 1. from a user - traffic.dll requires that ALL the filters
    //	  would have been deleted, therefore this case is a nop.
    //
    // 2. from a kernel client - in this case we MUST remove the 
    //    patterns before proceesing to delete the cfinfo,
    //    since we can't rely on traffic.dll to do it
    //

    //
    // grab a refcount on this blob so it doesn't go away due
    // to some funky client that decides to complete before
    // it return any status code (and most of them do!)
    // this should be released before we exit the routine,
    // so that the blob may actually go away on the last deref
    //

    REFADD(&pBlob->RefCount, 'RMCF');

    //
    // set the removing client
    //
    
    pBlob->pCallingClient = pClient;
    

    //
    // don't allow the user mode owner client to remove this flow
        // if there are any patterns on it....
    // ...unless the REMOVE_CB_BLOB bit ahs been set,
    // for example: when the calling process dies
    //

    if (!IsListEmpty(&pBlob->PatternList) &&
        TEST_BIT_ON(pClient->Flags, GPC_FLAGS_USERMODE_CLIENT) &&
        (pClient == pBlob->pOwnerClient) &&
         TEST_BIT_OFF(pBlob->Flags, PATTERN_REMOVE_CB_BLOB)
       )
    {

        NDIS_UNLOCK(&pBlob->Lock);

        return GPC_STATUS_NOT_EMPTY;
    
    } else {

        //
        // Since we have decided to remove the patterns, we should
        // mark this as invalid
        //

        pBlob->ObjectType = GPC_ENUM_INVALID;
    }

    while (!IsListEmpty(&pBlob->PatternList)) {

        pPattern = CONTAINING_RECORD(pBlob->PatternList.Flink,
                                     PATTERN_BLOCK,
                                     BlobLinkage[pCf->AssignedIndex]);

        NDIS_DPR_LOCK(&pPattern->Lock);

        REFADD(&pPattern->RefCount, 'RMCF');

        pPattern->State = GPC_STATE_FORCE_REMOVE;
        
        //
        // If it is an AUTO PATTERN, remove it from the list and 
        // unset the flag.
        //
        if (TEST_BIT_ON( pPattern->Flags, PATTERN_AUTO)) {
    
            pProtocol = &glData.pProtocols[pPattern->ProtocolTemplate];
            
            pPattern->Flags |= ~PATTERN_AUTO;

            NDIS_DPR_LOCK(&pProtocol->PatternTimerLock[pPattern->WheelIndex]);
    
            GpcRemoveEntryList(&pPattern->TimerLinkage);
    
            NDIS_DPR_UNLOCK(&pProtocol->PatternTimerLock[pPattern->WheelIndex]);
                
            InitializeListHead(&pPattern->TimerLinkage);
            
            NDIS_DPR_UNLOCK(&pPattern->Lock);

            NDIS_UNLOCK(&pBlob->Lock);

            privateGpcRemovePattern(ClientHandle, (GPC_HANDLE)pPattern, TRUE);        

            InterlockedDecrement(&pProtocol->AutoSpecificPatternCount);

        } else {

            NDIS_DPR_UNLOCK(&pPattern->Lock);
            NDIS_UNLOCK(&pBlob->Lock);

        }
        
        privateGpcRemovePattern(ClientHandle, (GPC_HANDLE)pPattern, TRUE);        
        
        REFDEL(&pPattern->RefCount, 'RMCF');

        NDIS_LOCK(&pBlob->Lock);
    }


    //
    // set the state
    //
    
    pBlob->State = GPC_STATE_REMOVE;

    NDIS_UNLOCK(&pBlob->Lock);

#if NO_USER_PENDING

    //
    // this will be only required until we implement the user level
    // pending report
    //
    
    CTEInitBlockStruc(&pBlob->WaitBlock);
    
#endif


    SuspendHandle(pBlob->ClHandle);

    //
    // init the client status array to keep track
    // of how many client have succeeded so far
    //
        
    //RtlZeroMemory(pBlob->arpClientStatus, sizeof(pBlob->arpClientStatus));
    pBlob->ClientStatusCountDown = 0;
    pBlob->LastStatus = GPC_STATUS_SUCCESS;

    //
    // notify each client
    //

    NDIS_LOCK(&pCf->Lock);
    GpcRemoveEntryList(&pBlob->CfLinkage);
    NDIS_UNLOCK(&pCf->Lock);

    //NDIS_LOCK(&pClient->Lock);    

    RSC_READ_LOCK(&pCf->ClientSync, &irql);
    
    NDIS_LOCK(&pClient->Lock);
    GpcRemoveEntryList(&pBlob->ClientLinkage);
    NDIS_UNLOCK(&pClient->Lock);

    //NDIS_UNLOCK(&pClient->Lock);

    //
    // the blob is not on the CF or on the client list
    // okay to change the object type so further handle lookup will fail
    //

    pHead = &pCf->ClientList;
    pEntry = pHead->Flink;
    
    while (pEntry != pHead && (Status == GPC_STATUS_SUCCESS || 
                               Status == GPC_STATUS_PENDING)) {

        //
        // get the notified client block
        //
        
        pNotifyClient = CONTAINING_RECORD(pEntry, CLIENT_BLOCK, ClientLinkage);
        
        if (pNotifyClient != pClient
            &&
            pBlob->arpClientStatus[pNotifyClient->AssignedIndex] ) {

            //
            // don't notify the caller
            //
            
            REFADD(&pNotifyClient->RefCount, 'PRCF');

            //NDIS_UNLOCK(&pCf->Lock);
            RSC_READ_UNLOCK(&pCf->ClientSync, &irql);

            Status1 = ClientRemoveCfInfo
                (pNotifyClient,
                 pBlob,
                 pBlob->arClientCtx[pNotifyClient->AssignedIndex]
                 );
            
            TRACE(BLOB, pBlob, Status, "privateGpcRemoveCfInfo: (client)");

            RSC_READ_LOCK(&pCf->ClientSync, &irql);

            if (Status1 == GPC_STATUS_PENDING) {
                                
                Status = GPC_STATUS_PENDING;
              
            } else {

                if (NT_ERROR(Status1)) {
                
                    Status = pBlob->LastStatus = Status1;
                
                } else {
                    
                    //
                    // status success
                    //
                
                    pBlob->arpClientStatus[pNotifyClient->AssignedIndex] = 
                        pNotifyClient;

                    NDIS_DPR_LOCK(&pBlob->Lock);

                    if (pNotifyClient == pBlob->pNotifiedClient) {

                        pBlob->pNotifiedClient = NULL;
                        pBlob->NotifiedClientCtx = NULL;
                    }

                    NDIS_DPR_UNLOCK(&pBlob->Lock);

                }
                
                //
                // not pending - no need to hold the ref count to this client
                //

                //DereferenceClient(pNotifyClient);
            }
            
            //
            // advance to the next client block, and release the ref count
            // for this client
            //
            
            //NDIS_LOCK(&pCf->Lock);

            pEntry = pEntry->Flink;

            if (pEntry != pHead) {
                
                pNotifyClient2 = CONTAINING_RECORD(pEntry, 
                                                   CLIENT_BLOCK, 
                                                   ClientLinkage);
                
                REFADD(&pNotifyClient2->RefCount, 'PRCF');

            }

            //
            // release the list lock since the next call will try to get it
            //
            
            RSC_READ_UNLOCK(&pCf->ClientSync, irql);
            
            REFDEL(&pNotifyClient->RefCount, 'PRCF');

            RSC_READ_LOCK(&pCf->ClientSync, &irql);

            if (pEntry != pHead) {
                
                //
                // safe to do since the list is locked
                //
                
                REFDEL(&pNotifyClient2->RefCount, 'PRCF');
            }

        } else {      // if (pNotifyClient != pClient)
            
            pEntry = pEntry->Flink;
        }
        
    } // while
        
    //NDIS_UNLOCK(&pCf->Lock);

    RSC_READ_UNLOCK(&pCf->ClientSync, irql);

    if (Status != GPC_STATUS_PENDING) {

        NDIS_LOCK(&pBlob->Lock);

        //
        // notify any pending client about the status
        //
        
        if (pClient = pBlob->pCallingClient2) {

            pClient = pBlob->pCallingClient2;
            pBlob->pCallingClient2 = NULL;

            NDIS_UNLOCK(&pBlob->Lock);

            //
            // complete the request to this client
            //
            
            ClientRemoveCfInfoComplete
                (
                 pClient,  			// the guy who made the call
                 pBlob,             // completing blob
                 Status        		// status
                 );
            
            //pBlob->pCallingClient2 = NULL;

        } else {

            NDIS_UNLOCK(&pBlob->Lock);
        }

        if (Status != GPC_STATUS_SUCCESS) {

            //
            // failed to remove the blob
            //

            pBlob->State = GPC_STATE_READY;
            pBlob->ObjectType = GPC_ENUM_CFINFO_TYPE;

            //
            // resume the suspended handle
            //

            ResumeHandle(pBlob->ClHandle);
        }
    }

    if (Status == GPC_STATUS_SUCCESS) {
        
        //
        // release the mapping handle 
        //
        
        FreeHandle(pBlob->ClHandle);
        
        //
        // all done, we can remove the blob from memory
        //
        
        REFDEL(&pBlob->RefCount, 'BLOB');
        
        CfStatInc(pCf->AssignedIndex,DeletedBlobs);
        CfStatDec(pCf->AssignedIndex,CurrentBlobs);
    }           

    //
    // release the extra refcount we got in the begining
    // this is to avoid the problem of the blob going away,
    // since some clients may complete the remove before we get
    // here, and this will cause the blob structure to be released
    // it's not a pretty sight....
    //

    REFDEL(&pBlob->RefCount, 'RMCF');
    
    TRACE(BLOB, Status, 0, "privateGpcRemoveCfInfo==>");

    return Status;
}




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

GpcRemoveCfInfo - 

	This must have been called from kernel. We simply pass the call
    to the private routine with Flags=0.


Arguments
	ClientHandle	- client handle
    GpcCfInfoHandle	- blob handle

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
GpcRemoveCfInfo(
	IN	GPC_HANDLE		ClientHandle,
    IN	GPC_HANDLE		GpcCfInfoHandle
    )
{

    return privateGpcRemoveCfInfo(
                                  ClientHandle,
                                  GpcCfInfoHandle,
                                  0
                                  );
}




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

GpcRemoveCfInfoNotifyComplete -

Called by clients who are completing a ClRemoveCfInfoNotify that was PENDING.
This may have been called for two reasons:
1. A client issued a GpcRemoveCfInfo request.
2. A client issued a GpcAddCfInfo request, but one of the other clients
   failed, so we are removing the successfully installed blobs.

Arguments
	ClientHandle	- client handle
    GpcCfInfoHandle	- the blob handle
    Status			- completion status

Returns
	void

************************************************************************
*/
VOID
GpcRemoveCfInfoNotifyComplete(
	IN	GPC_HANDLE		ClientHandle,
    IN	GPC_HANDLE		GpcCfInfoHandle,
    IN	GPC_STATUS		Status
    )
{
    PCLIENT_BLOCK		pClient;
    PBLOB_BLOCK			pBlob;
    PCLIENT_BLOCK		pClient2;

	TRACE(BLOB, GpcCfInfoHandle, Status, "GpcRemoveCfInfoNotifyComplete");

    //VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);
    //VERIFY_OBJECT(GpcCfInfoHandle, GPC_ENUM_CFINFO_TYPE);

    pClient = (PCLIENT_BLOCK)ClientHandle;
    pBlob = (PBLOB_BLOCK)GpcCfInfoHandle;

    ASSERT(pBlob);
    ASSERT(pClient);
    ASSERT(Status != GPC_STATUS_PENDING);
    ASSERT(pBlob->ClientStatusCountDown > 0);

    if (!NT_ERROR(pBlob->LastStatus) || NT_ERROR(Status)) {

        //
        // save the last error code
        //

        pBlob->LastStatus = Status;
    }

    NDIS_LOCK(&pBlob->Lock);
    
    if (Status == GPC_STATUS_SUCCESS && pClient == pBlob->pNotifiedClient) {
        
        pBlob->pNotifiedClient = NULL;
        pBlob->NotifiedClientCtx = NULL;
    }
    
    NDIS_UNLOCK(&pBlob->Lock);

    if (NdisInterlockedDecrement(&pBlob->ClientStatusCountDown) == 0) {

        if (pBlob->State == GPC_STATE_REMOVE) {
            
            if (pBlob->pCallingClient->State == GPC_STATE_READY) {

                //
                // complete the request to the client
                //
                
                ClientRemoveCfInfoComplete
                    (
                     pBlob->pCallingClient,   // first guy who made the call
                     pBlob,                   // completing blob
                     pBlob->LastStatus        // status
                     );

                NDIS_LOCK(&pBlob->Lock);

                //
                // notify any pending client about the status
                //
                
                if (pClient2 = pBlob->pCallingClient2) {

                    pBlob->pCallingClient2 = NULL;

                    NDIS_UNLOCK(&pBlob->Lock);

                    //
                    // complete the request to this client
                    //
                    
                    ClientRemoveCfInfoComplete
                        (
                         pClient2,  			// the guy who made the call
                         pBlob,                 // completing blob
                         pBlob->LastStatus		// status
                         );
                } else {

                    NDIS_UNLOCK(&pBlob->Lock);
                }
                
                //pBlob->State = GPC_STATE_READY;

                if (pBlob->LastStatus == GPC_STATUS_SUCCESS) {

                    //
                    // release the mapping handle 
                    //
                    
                    FreeHandle(pBlob->ClHandle);
                    
                    //
                    // all clients have reported
                    // remove the blob
                    //
                
                    REFDEL(&pBlob->RefCount, 'BLOB');
                    //DereferenceBlob(&pBlob);

                } else {

                    //
                    // blob not removed - restore the object type
                    //

                    pBlob->ObjectType = GPC_ENUM_CFINFO_TYPE;

                    //
                    // resume the mapping handle
                    //
                    
                    ResumeHandle(pBlob->ClHandle);
                }
            }

        } else { // if (pBlob->State....)

            //
            // we are removing the blob since we failed to add it
            // to ALL clients.
            //

            ASSERT(pBlob->State == GPC_STATE_ADD);

            //
            // Release the AddFailed block so that the AddComplete
            // will resume
            //

            CTESignal(&pBlob->WaitBlockAddFailed, pBlob->LastStatus);
            
        }
    }

    //
    // release the one we got earlier
    //

    //DereferenceClient(pClient);

	TRACE(BLOB, 0, 0, "GpcRemoveCfInfoNotifyComplete==>");
}




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

GpcRemovePattern -

Called by the client to remove a pattern from the database.

Arguments
	ClientHandle		- client handle
    GpcPatternHandle	- pattern handle

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
GpcRemovePattern(
	IN	GPC_HANDLE		ClientHandle,
    IN	GPC_HANDLE		GpcPatternHandle
    )
{

    return(privateGpcRemovePattern(
                            ClientHandle,
                            GpcPatternHandle,
                            FALSE
                            ));

}


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

privateGpcRemovePattern -

Internal call in the GPC to indicate whether this is forceful removal.

Arguments
	ClientHandle		- client handle
    GpcPatternHandle	- pattern handle

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
privateGpcRemovePattern(
	IN	GPC_HANDLE		ClientHandle,
    IN	GPC_HANDLE		GpcPatternHandle,
    IN  BOOLEAN         ForceRemoval
    )
{

    GPC_STATUS	    Status = GPC_STATUS_SUCCESS;
    PPATTERN_BLOCK  pPattern;
    PCLIENT_BLOCK   pClient;
    PPROTOCOL_BLOCK pProtocol;
    ULONG           Flags;
    ULONG			CfIndex;
    ULONG			ProtocolId;

	TRACE(PATTERN, ClientHandle, GpcPatternHandle, "GpcRemovePattern");

    DBGPRINT(PATTERN, ("GpcRemovePattern: Client=%X Pattern=%X\n", 
                       ClientHandle, GpcPatternHandle));

    VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);
    VERIFY_OBJECT(GpcPatternHandle, GPC_ENUM_PATTERN_TYPE);

    pClient = (PCLIENT_BLOCK)ClientHandle;
    pPattern = (PPATTERN_BLOCK)GpcPatternHandle;

    ASSERT(pClient);
    ASSERT(pPattern);

    CfIndex = pClient->pCfBlock->AssignedIndex;
    ProtocolId = pPattern->ProtocolTemplate;
    pProtocol = &glData.pProtocols[ProtocolId];

    //
    // If the pattern has already been removed by the ADAPTER (mostly WAN link)
    // going down, just return with an error. The memory is valid since the 
    // ProxyRemovePattern function added a REF.
    // 
    NDIS_LOCK(&pPattern->Lock);

    if (!ForceRemoval && (pPattern->State != GPC_STATE_READY)) {

        NDIS_UNLOCK(&pPattern->Lock);
        
        return GPC_STATUS_INVALID_HANDLE;

    } else {
        
        NDIS_UNLOCK(&pPattern->Lock);

    }

	//
	// determine weather its a specific or generic pattern
	//

    Flags = pPattern->Flags;

    if (TEST_BIT_ON(Flags, PATTERN_SPECIFIC)) {

        //
        // this is a specific pattern, call the appropriate routine
        // to remove from db
        //

        Status = RemoveSpecificPattern(
                                       pClient,
                                       pProtocol,
                                       pPattern,
                                       ForceRemoval
                                       );
    } else {

        //
        // this is a generic pattern, call the appropriate routine
        // to remove from db
        //

        Status = RemoveGenericPattern(
                                      pClient,
                                      pProtocol,
                                      pPattern
                                      );
    }

	TRACE(PATTERN, Status, 0, "GpcRemovePattern==>");

    if (NT_SUCCESS(Status)) {

        if (TEST_BIT_ON(Flags, PATTERN_SPECIFIC)) {

            ProtocolStatInc(ProtocolId,DeletedSp);
            ProtocolStatDec(ProtocolId,CurrentSp);

            NdisInterlockedDecrement(&pProtocol->SpecificPatternCount);            
            

        } else {

            ProtocolStatInc(ProtocolId,DeletedGp);
            ProtocolStatDec(ProtocolId,CurrentGp);

            NdisInterlockedDecrement(&pProtocol->GenericPatternCount);            
            

        }

    }

    DBGPRINT(PATTERN, ("GpcRemovePattern: Client=%X Pattern=%X, Status=%X\n", 
                       ClientHandle, GpcPatternHandle,Status));

    return Status;
}




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

GpcClassifyPattern -

Called by the client to classify a pattern and get back a client blob
context and a classification handle.

Arguments
	ClientHandle			- client handle
    ProtocolTemplate		- the protocol template to use
    pPattern				- pointer to pattern
    pClientCfInfoContext	- OUT, the client's blob context
    pClassificationHandle	- OUT, classification handle

Returns
	GPC_STATUS: GPC_STATUS_NOT_FOUND

************************************************************************
*/
GPC_STATUS
GpcClassifyPattern(
	IN		GPC_HANDLE				ClientHandle,
    IN		ULONG					ProtocolTemplate,
    IN		PVOID			        pPattern,
    OUT		PGPC_CLIENT_HANDLE		pClientCfInfoContext,	// optional
    IN OUT	PCLASSIFICATION_HANDLE	pClassificationHandle,
    IN		ULONG					Offset,
    IN		PULONG					pValue,
    IN		BOOLEAN					bNoCache
    )
{
    GPC_STATUS		Status;
    PPATTERN_BLOCK	pPatternBlock;
    PCLIENT_BLOCK	pClient;
    PPROTOCOL_BLOCK	pProtocol;
    PGPC_IP_PATTERN	pIp = (PGPC_IP_PATTERN)pPattern;
    KIRQL           CHirql;
    PBLOB_BLOCK     pBlob;

	TRACE(CLASSIFY, ClientHandle, *pClassificationHandle, "GpcClassifyPattern<==");

    VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);

    ASSERT(ClientHandle);
    ASSERT(pPattern);
    //ASSERT(pClientCfInfoContext);
    ASSERT(pClassificationHandle);

    Status = GPC_STATUS_SUCCESS;

    if (ProtocolTemplate >= GPC_PROTOCOL_TEMPLATE_MAX) {

        return GPC_STATUS_INVALID_PARAMETER;
    }

    pProtocol = &glData.pProtocols[ProtocolTemplate];

    //
    // Optimization - check if there are any patterns installed
    //

    if (pProtocol->SpecificPatternCount == 0 
        &&
        pProtocol->GenericPatternCount == 0 ) {
        
        if (pClientCfInfoContext) {
            *pClientCfInfoContext = NULL;
        }
        *pClassificationHandle = (CLASSIFICATION_HANDLE)0;

        DBGPRINT(CLASSIFY, ("GpcClassifyPattern: Client=%X no patterns returned %X\n", 
                            ClientHandle, GPC_STATUS_NOT_FOUND));

        TRACE(CLASSIFY, ClientHandle, GPC_STATUS_NOT_FOUND, "GpcClassifyPattern (1)" );

        return GPC_STATUS_NOT_FOUND;
    }

    pClient = (PCLIENT_BLOCK)ClientHandle;

    if (ProtocolTemplate == GPC_PROTOCOL_TEMPLATE_IP) {

        pIp = (PGPC_IP_PATTERN)pPattern;
        pIp->Reserved[0] = pIp->Reserved[1] = pIp->Reserved[2] = 0;

        DBGPRINT(CLASSIFY, ("GpcClassifyPattern: Client=%X, CH=%d\n", 
                            ClientHandle, *pClassificationHandle));
        DBGPRINT(CLASSIFY, ("IP: ifc={%d,%d} src=%08X:%04x, dst=%08X:%04x, prot=%d rsv=%x,%x,%x\n", 
                            pIp->InterfaceId.InterfaceId,
                            pIp->InterfaceId.LinkId,
                            pIp->SrcAddr,
                            pIp->gpcSrcPort,
                            pIp->DstAddr,
                            pIp->gpcDstPort,
                            pIp->ProtocolId,
                            pIp->Reserved[0],
                            pIp->Reserved[1],
                            pIp->Reserved[2]
                            ));
    }

    ProtocolStatInc(ProtocolTemplate, ClassificationRequests);

    //
    // verify the classification handle, if it's valid, simply return
    //

    if (*pClassificationHandle && (pClientCfInfoContext || pValue)) {

        Status = GetClientCtxAndUlongFromCfInfo(ClientHandle,
                                                pClassificationHandle,
                                                pClientCfInfoContext,
                                                Offset,
                                                pValue
                                                );

        ProtocolStatInc(ProtocolTemplate, PatternsClassified);

        DBGPRINT(CLASSIFY, ("GpcClassifyPattern: Client=%X returned immediate CH %d\n", 
                            pClient, *pClassificationHandle));

        TRACE(CLASSIFY, pClient, *pClassificationHandle, "GpcClassifyPattern (2)" );

        return Status;
    }

    //
    // there pattern needs to be classified
    // this should find the classification handle
    //

    Status = InternalSearchPattern(
                                    pClient, 
                                    pProtocol, 
                                    pPattern,
                                    &pPatternBlock,
                                    pClassificationHandle,
                                    bNoCache
                                    );
    
    if (*pClassificationHandle && (pClientCfInfoContext || pValue)) {

        Status = GetClientCtxAndUlongFromCfInfo(ClientHandle,
                                                pClassificationHandle,
                                                pClientCfInfoContext,
                                                Offset,
                                                pValue
                                                );

    } else if ((!NT_SUCCESS(Status)) && 
                pPatternBlock && 
                pClientCfInfoContext) {
        // it is likely that we could not allocate the Auto Specific pattern
        // just try to send the context anyway.

        READ_LOCK(&glData.ChLock, &CHirql);
        
        pBlob = GetBlobFromPattern(pPatternBlock, GetCFIndexFromClient(ClientHandle));

        if(pBlob) {

            *pClientCfInfoContext = pBlob->arClientCtx[GetClientIndexFromClient(ClientHandle)];

        } else {

            Status = GPC_STATUS_NOT_FOUND;

        }

        READ_UNLOCK(&glData.ChLock, CHirql); 

    } else if (!*pClassificationHandle) {

        //
        // none found, 
        //

        if (pClientCfInfoContext) {
            *pClientCfInfoContext = NULL;
        }

        Status = GPC_STATUS_NOT_FOUND;
    
    } else {

        Status = GPC_STATUS_SUCCESS;

    }

    if (pPatternBlock) {

        //DereferencePattern(pPatternBlock, pClient->pCfBlock);

        ProtocolStatInc(ProtocolTemplate, PatternsClassified);
    }

	TRACE(CLASSIFY, pPatternBlock, Status, "GpcClassifyPattern==>");

    DBGPRINT(CLASSIFY, ("GpcClassifyPattern: Client=%X returned Pattern=%X, CH=%d, Status=%X\n", 
                        pClient, pPattern, *pClassificationHandle, Status));
    return Status;
}



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

GpcClassifyPacket -

Called by the client to classify a packet and get back a client blob
context and a classification handle.
Content is extracted from the packet and placed into a protocol specific
structure (IP).
For IP, if fragmentation is ON for the client:
   o First fragment will create a hash table entry
   o Other fragments will be looked in the hash by the packet ID
   o Last fragment will cause entry to be deleted.

Arguments
	ClientHandle			- client handle
    ProtocolTemplate		- the protocol template
    pNdisPacket				- ndis packet
    TransportHeaderOffset	- byte offset of the start of the transport
							  header from the beginning of the packet
    pClientCfInfoContext	- OUT, client blob context
    pClassificationHandle	- OUT, classification handle

Returns
	GPC_STATUS

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

GPC_STATUS
GpcClassifyPacket(
	IN	GPC_HANDLE				ClientHandle,
    IN	ULONG					ProtocolTemplate,
    IN	PVOID					pPacket,
    IN	ULONG					TransportHeaderOffset,
    IN  PTC_INTERFACE_ID		pInterfaceId,
    OUT	PGPC_CLIENT_HANDLE		pClientCfInfoContext,	//optional
    OUT	PCLASSIFICATION_HANDLE	pClassificationHandle
    )
{
    GPC_STATUS				Status = GPC_STATUS_SUCCESS;
    PNDIS_PACKET			pNdisPacket = NULL;
    PCLIENT_BLOCK			pClient;
    PCF_BLOCK				pCf;
    PPATTERN_BLOCK			pPattern = NULL;
    PPROTOCOL_BLOCK			pProtocol;
    PBLOB_BLOCK				pBlob = NULL;
    ULONG					CfIndex;
    int						i;
    GPC_IP_PATTERN			IpPattern;
    GPC_IPX_PATTERN			IpxPattern;
    PVOID					pKey = NULL;
    PVOID					pAddr;
    UINT					Len, Tot;
    PNDIS_BUFFER			pNdisBuf1, pNdisBuf2;
    PIP_HEADER              pIpHdr;
    PIPX_HEADER             pIpxHdr;
    USHORT         			PacketId;
    USHORT         			FragOffset;
    UINT           			IpHdrLen;
    PUDP_HEADER    			pUDPHdr;
    UCHAR          			PktProtocol;
    BOOLEAN					bFragment = FALSE;
    BOOLEAN					bLastFragment = FALSE;
    BOOLEAN					bFirstFragment = FALSE;

	TRACE(CLASSIFY, ClientHandle, pNdisPacket, "GpcClassifyPacket");
    
    DBGPRINT(CLASSIFY, ("GpcClassifyPacket: Client=%X CH=%d\n", 
                        ClientHandle, *pClassificationHandle));

    VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);

    ASSERT(pPacket);
    ASSERT(ClientHandle);
    //ASSERT(pClientCfInfoContext);
    ASSERT(pClassificationHandle);

    if (ProtocolTemplate >= GPC_PROTOCOL_TEMPLATE_MAX) {

        return GPC_STATUS_INVALID_PARAMETER;
    }

    pProtocol = &glData.pProtocols[ProtocolTemplate];

    //
    // Optimization - check if there are any patterns installed
    //

    if (pProtocol->SpecificPatternCount == 0
        &&
        pProtocol->GenericPatternCount == 0 ) {
        
        if (pClientCfInfoContext) {
            *pClientCfInfoContext = NULL;
        }
        *pClassificationHandle = 0;

        DBGPRINT(CLASSIFY, ("GpcClassifyPacket: Client=%X no patterns returned %X\n", 
                            ClientHandle, GPC_STATUS_NOT_FOUND));

        return GPC_STATUS_NOT_FOUND;
    }

    pClient = (PCLIENT_BLOCK)ClientHandle;
    pNdisPacket = (PNDIS_PACKET)pPacket;

    //
    // get the classification handle from the packet
    // if there - extract the blob pointer and the client blob context
    // directly and return
    //

    //
    // o/w, we need to look inside the packet
    // Parse the packet into a pattern and make a db search
    // first match a specific pattern, and then search the generic
    // database(s) for the given CF
    //

    pCf = pClient->pCfBlock;

    CfIndex = pCf->AssignedIndex;

    ProtocolStatInc(ProtocolTemplate,ClassificationRequests);

    *pClassificationHandle = 0;

    //
    // get the pattern from the packet
    //

    //
    // get the first NDIS buffer - assuming it is a MAC header
    //

    NdisGetFirstBufferFromPacket(pNdisPacket,
                                 &pNdisBuf1,   // Ndis buffer 1 desc.
                                 &pAddr,       // buffer VA
                                 &Len,         // buffer length
                                 &Tot          // total length (all buffs)
                                 );

    ASSERT(Tot > TransportHeaderOffset);

    while (Len <= TransportHeaderOffset) {
        
        //
        // Transport header is not in this buffer,
        // try the next buffer
        //

        TransportHeaderOffset -= Len;
        NdisGetNextBuffer(pNdisBuf1, &pNdisBuf2);
        ASSERT(pNdisBuf2); // should never happen!!
        NdisQueryBuffer(pNdisBuf2, &pAddr, &Len);
        pNdisBuf1 = pNdisBuf2;
    }

    switch (ProtocolTemplate) {

    case GPC_PROTOCOL_TEMPLATE_IP:

        //
        // fill the pattern with '0'
        //
        
        RtlZeroMemory(&IpPattern, sizeof(IpPattern));

        //
        // parse IP packet here...
        //

        pIpHdr = (PIP_HEADER)(((PUCHAR)pAddr) + TransportHeaderOffset);
        IpHdrLen = (pIpHdr->iph_verlen & (uchar)~IP_VER_FLAG) << 2;
        
        FragOffset = pIpHdr->iph_offset & IP_OFFSET_MASK;
        FragOffset = net_short(FragOffset) * 8;

        PacketId = pIpHdr->iph_id;

        //
        // check for fragmentation
        //

        bFragment = (pIpHdr->iph_offset & IP_MF_FLAG) || (FragOffset > 0);
        bFirstFragment = bFragment && (FragOffset == 0);
        bLastFragment = bFragment && 
            TEST_BIT_OFF(pIpHdr->iph_offset, IP_MF_FLAG);

        //
        // sanity check - doesn't make sense to have a single fragment
        //

        ASSERT(!bFirstFragment || !bLastFragment);

        if (TEST_BIT_ON(pClient->Flags, GPC_FLAGS_FRAGMENT) &&
            (bFragment && ! bFirstFragment)) {
            
            //
            // client is interested in fragmentation and this is a
            // a fragment, but not the first one.
            // It will be handled later when we find the pattern
            //

            Status = HandleFragment(
                                    pClient,
                                    pProtocol,
                                    bFirstFragment,    // first frag
                                    bLastFragment,     // last frag
                                    PacketId,
                                    &pPattern,
                                    &pBlob
                                    );

        } else {

            //
            // not a fragment, or is the first one - we have to search db
            //

            IpPattern.SrcAddr = pIpHdr->iph_src;
            IpPattern.DstAddr = pIpHdr->iph_dest;
            IpPattern.ProtocolId = pIpHdr->iph_protocol;
            
            //
            // case the ProtocolId and fill the appropriate union
            //
            
            switch (IpPattern.ProtocolId) {
                
            case IPPROTO_IP:
                //
                // we have everything so far
                //

                break;


            case IPPROTO_TCP:
            case IPPROTO_UDP:

                //
                // need to get those port numbers
                //

                if (IpHdrLen < Len) {

                    //
                    // the UDP/TCP header is in the same buffer
                    // 

                    pUDPHdr = (PUDP_HEADER)((PUCHAR)pIpHdr + IpHdrLen);
                    
                } else {

                    //
                    // get the next buffer
                    //
                    
                    NdisGetNextBuffer(pNdisBuf1, &pNdisBuf2);
                    ASSERT(pNdisBuf2);
            
                    if (IpHdrLen > Len) {
                
                        //
                        // There is an optional header buffer, so get the next
                        // buffer to reach the udp/tcp header
                        //
                        
                        pNdisBuf1 = pNdisBuf2;
                        NdisGetNextBuffer(pNdisBuf1, &pNdisBuf2);
                        ASSERT(pNdisBuf2);
                    }
            
                    NdisQueryBuffer(pNdisBuf2, &pUDPHdr, &Len);
                }

                IpPattern.gpcSrcPort = pUDPHdr->uh_src;
                IpPattern.gpcDstPort = pUDPHdr->uh_dest;
#if INTERFACE_ID
                IpPattern.InterfaceId.InterfaceId = pInterfaceId->InterfaceId;
                IpPattern.InterfaceId.LinkId = pInterfaceId->LinkId;
#endif
                break;
                
            case IPPROTO_ICMP:
            case IPPROTO_IGMP:
            default:

                // 
                // The default will cover all IP_PROTO_RAW packets. Note that in this case, all we care about
                // is the InterfaceID
                //
#if INTERFACE_ID
                IpPattern.InterfaceId.InterfaceId = pInterfaceId->InterfaceId;
                IpPattern.InterfaceId.LinkId = pInterfaceId->LinkId;
#endif
                break;

            case IPPROTO_IPSEC:

                pKey = NULL;
                Status = GPC_STATUS_NOT_SUPPORTED;
            }
            
            pKey = &IpPattern;
            break;
        }
        
        DBGPRINT(CLASSIFY, ("IP: ifc={%d,%d} src=%X:%x, dst=%X:%x, prot=%x, rsv=%x,%x,%x \n", 
                            IpPattern.InterfaceId.InterfaceId,
                            IpPattern.InterfaceId.LinkId,
                            IpPattern.SrcAddr,
                            IpPattern.gpcSrcPort,
                            IpPattern.DstAddr,
                            IpPattern.gpcDstPort,
                            IpPattern.ProtocolId,
                            IpPattern.Reserved[0],
                            IpPattern.Reserved[1],
                            IpPattern.Reserved[2]
                            ));
        break;
        

    case GPC_PROTOCOL_TEMPLATE_IPX:

        //
        // fill the pattern with '0'
        //
        
        RtlZeroMemory(&IpxPattern, sizeof(IpxPattern));

        //
        // parse IPX packet here...
        //

        pIpxHdr = (PIPX_HEADER)(((PUCHAR)pAddr) + TransportHeaderOffset);

        //
        // source
        //
        IpxPattern.Src.NetworkAddress = *(ULONG *)pIpxHdr->SourceNetwork;
        RtlMoveMemory(IpxPattern.Src.NodeAddress, pIpxHdr->SourceNode,6);
        IpxPattern.Src.Socket = pIpxHdr->SourceSocket;

        //
        // destination
        //
        IpxPattern.Dest.NetworkAddress = *(ULONG *)pIpxHdr->DestinationNetwork;
        RtlMoveMemory(IpxPattern.Dest.NodeAddress, pIpxHdr->DestinationNode,6);
        IpxPattern.Dest.Socket = pIpxHdr->DestinationSocket;

        pKey = &IpxPattern;

        break;
        
    default:
        Status = GPC_STATUS_INVALID_PARAMETER;

    }

    if (NT_SUCCESS(Status) && pPattern == NULL) {

        //
        // no failure so far but no pattern found either
        // search for the pattern
        //

        ASSERT(pKey);

        //
        // if there is a match, the pattern ref count will be bumped
        // up and we need to release it when we're done.
        //

        Status = InternalSearchPattern(
                                         pClient, 
                                         pProtocol, 
                                         pKey,
                                         &pPattern,
                                         pClassificationHandle,
                                         FALSE
                                         );
    }

    if (*pClassificationHandle) {
        
        if (pClientCfInfoContext) {

            Status = GpcGetCfInfoClientContext(ClientHandle,
                                              *pClassificationHandle,
                                              pClientCfInfoContext);
        }

        ProtocolStatInc(ProtocolTemplate, PacketsClassified);

    } else {

        //ASSERT(pBlob == NULL);

        //
        // none found, or some other error occured.
        //

        if (pClientCfInfoContext) {
            *pClientCfInfoContext = NULL;
        }

        *pClassificationHandle = 0;

        Status = GPC_STATUS_NOT_FOUND;
    }

	TRACE(CLASSIFY, pPattern, Status, "GpcClassifyPacket==>");

    DBGPRINT(CLASSIFY, ("GpcClassifyPacket: Client=%X returned Pattern=%X, CH=%d, Status=%X\n", 
                        pClient, pPattern, *pClassificationHandle, Status));
    return Status;
}





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

GpcEnumCfInfo -

	Called to enumerate CfInfo's (and attached filters).
    For each CfInfo, GPC will return the CfInfo blob and the list of 
    pattern attached to it.

Arguments

	ClientHandle	- the calling client
    pBlob			- the next cfinfo to enumerate, NULL for the first
    pBlobCount		- in: requested; out: returned
    pBufferSize		- in: allocated; out: bytes returned
    Buffer			- output buffer

Returns
	GPC_STATUS

************************************************************************
*/
GPC_STATUS
GpcEnumCfInfo(
	IN     GPC_HANDLE				ClientHandle,
    IN OUT PHANDLE					pCfInfoHandle,
    OUT    PHANDLE					pCfInfoMapHandle,
    IN OUT PULONG					pCfInfoCount,
    IN OUT PULONG					pBufferSize,
    IN     PGPC_ENUM_CFINFO_BUFFER	Buffer
    )
{
    GPC_STATUS			Status = GPC_STATUS_SUCCESS;
    GPC_STATUS 			st;
    PBLOB_BLOCK			pBlob = NULL;
    PCF_BLOCK			pCf;
    PLIST_ENTRY			pEntry, pHead;
    PPATTERN_BLOCK		pPattern;
    ULONG				cCfInfo = 0;
    ULONG				cTotalBytes = 0;
    ULONG				cPatterns, cValidPatterns;
    ULONG				size, cValidSize;
    ULONG				PatternMaskLen;
    ULONG				PatternSize;
    ULONG				i;
    PCHAR				p, q;
    PGENERIC_PATTERN_DB	pGenDb;
    UNICODE_STRING		CfInfoName;
    PGPC_GEN_PATTERN	pGenPattern;
    BOOLEAN				bEnum;
    KIRQL				ReadIrql;
    KIRQL				irql;
    PCLIENT_BLOCK		pNotifiedClient;
    GPC_CLIENT_HANDLE	NotifiedClientCtx;
    BOOLEAN             found = FALSE;
    UNICODE_STRING      UniStr;

    //
    //  debug checks
    //

    ASSERT(ClientHandle);
    ASSERT(pCfInfoHandle);
    ASSERT(pCfInfoMapHandle);
    ASSERT(pCfInfoCount);
    ASSERT(pBufferSize);
    ASSERT(Buffer);

    cValidPatterns  = 0;

    VERIFY_OBJECT(ClientHandle, GPC_ENUM_CLIENT_TYPE);

    pCf = ((PCLIENT_BLOCK)ClientHandle)->pCfBlock;

    //NDIS_LOCK(&pCf->Lock);
    
    RSC_WRITE_LOCK(&pCf->ClientSync, &irql);

    //
    // check if we start from a previous blob
    //

    if (*pCfInfoHandle) {

        pBlob = (PBLOB_BLOCK)*pCfInfoHandle;

        NDIS_LOCK(&pBlob->Lock);

        if (pBlob->State == GPC_STATE_REMOVE) {
            
            //
            // the blob has been marked for removal
            //

            NDIS_UNLOCK(&pBlob->Lock);
            //NDIS_UNLOCK(&pCf->Lock);

            RSC_WRITE_UNLOCK(&pCf->ClientSync, irql);
            
            *pCfInfoMapHandle = NULL;

            return STATUS_DATA_ERROR;
        }

        //NDIS_UNLOCK(&pBlob->Lock);

    } else {

        //
        // find the first (good) blob to enumerate.
        //
            
        //
        // Need to take pCf->Lock to manipulate or 
        // traverse the Blobs on it
        //
        NDIS_LOCK(&pCf->Lock);

        if (IsListEmpty(&pCf->BlobList)) {

            //
            // no blobs to enumerate
            //

            *pCfInfoCount = 0;
            *pBufferSize = 0;
            *pCfInfoMapHandle = NULL;

            //NDIS_UNLOCK(&pCf->Lock);

            NDIS_UNLOCK(&pCf->Lock);

            RSC_WRITE_UNLOCK(&pCf->ClientSync, irql);

            return GPC_STATUS_SUCCESS;

        } else {

            //
            // Find a good Blob (something that's not getting deleted)
            //
            pEntry = pCf->BlobList.Flink;

            while (&pCf->BlobList != pEntry) {
            
                pBlob = CONTAINING_RECORD(pEntry, BLOB_BLOCK, CfLinkage);
                NDIS_LOCK(&pBlob->Lock);

                if ((pBlob->State == GPC_STATE_READY) && 
                    (pBlob->ObjectType != GPC_ENUM_INVALID)) {
                    
                    found = TRUE;
                    break;


                } else {

                    //Aha! The first Blob is bad!!
                    pEntry = pEntry->Flink;
                    NDIS_UNLOCK(&pBlob->Lock);
                }

            }
            
            //
            // Couldn't find anything to enumerate.
            if (!found) {
                
                //No Blobs to enumerate

                *pCfInfoCount = 0;
                *pBufferSize = 0;
                *pCfInfoMapHandle = NULL;
    
                NDIS_UNLOCK(&pCf->Lock);

                //NDIS_UNLOCK(&pCf->Lock);
                RSC_WRITE_UNLOCK(&pCf->ClientSync, irql);
    
                return GPC_STATUS_SUCCESS;

            }
        }
        
        NDIS_UNLOCK(&pCf->Lock);

    }

    ASSERT(pBlob);

    *pCfInfoMapHandle = pBlob->ClHandle;

    //
    // at this point, we should have a blob pointer that we can 
    // start enumerating. The CF is still lock, so we can safely
    // walk the BlobList
    // The blob lock is also taken so we can scan the pattern list
    //

    for ( ; ; ) {	// we'll break out from this

        //NDIS_LOCK(&pBlob->Lock);

        //NdisInterlockedIncrement(&pBlob->RefCount);

        //ASSERT (pBlob->State != GPC_STATE_REMOVE);
 
        //NDIS_UNLOCK(&pBlob->Lock);

        pHead = &pBlob->PatternList;
        pEntry = pHead->Flink;
        
        //
        // Calculate how much space is needed for just one CfInfo
        // and all of its filters
        //
        
        size = sizeof(GPC_ENUM_CFINFO_BUFFER) + pBlob->ClientDataSize;

        // 
        // patterns might become invalid while we try to enum the CF, so we set cValidSize here
        // we have to align cValidSize so that the next CfInfo starts at a word boundary.
        //

        size = ((size + (sizeof(PVOID)-1)) & ~(sizeof(PVOID)-1));
        cValidSize = size;

        //
        // Count the patterns
        //
       
        for (cPatterns = 0, PatternMaskLen = 0;
             pHead != pEntry; 
             cPatterns++, pEntry = pEntry->Flink) {

            pPattern = CONTAINING_RECORD(pEntry, 
                                         PATTERN_BLOCK, 
                                         BlobLinkage[pCf->AssignedIndex]);
            
            PatternMaskLen += (sizeof(GPC_GEN_PATTERN) +
                               2 * glData.pProtocols[pPattern->ProtocolTemplate].PatternSize);

        }

        //
        // check if we have enough buffer space
        //
        size += PatternMaskLen;
        cValidPatterns = 0;

        if ((cTotalBytes + size) <= *pBufferSize) {

            //
            // yes, we can squeeze one more...
            //
            pEntry = pHead->Flink;

            pGenPattern = &Buffer->GenericPattern[0];

            for (i = 0; 
                 ((i < cPatterns) && (pEntry != pHead)); 
                 i++, pEntry = pEntry->Flink) {

                //
                // fill all the patterns + masks in
                //

                pPattern = CONTAINING_RECORD(pEntry, 
                                             PATTERN_BLOCK,
                                             BlobLinkage[pCf->AssignedIndex] );

                NDIS_LOCK(&pPattern->Lock);
                
                // Check for pattern's state...
                //

                if (GPC_STATE_READY != pPattern->State) {
                    
                    // don't try to list it out if its being removed!
                    NDIS_UNLOCK(&pPattern->Lock);
                    continue;

                }

                cValidSize += (sizeof(GPC_GEN_PATTERN) +
                         2 * glData.pProtocols[pPattern->ProtocolTemplate].PatternSize);


                PatternSize = glData.pProtocols[pPattern->ProtocolTemplate].PatternSize;
                pGenPattern->ProtocolId = pPattern->ProtocolTemplate;
                pGenPattern->PatternSize = PatternSize;
                pGenPattern->PatternOffset = sizeof(GPC_GEN_PATTERN);
                pGenPattern->MaskOffset = pGenPattern->PatternOffset + PatternSize;

                p = ((PUCHAR)pGenPattern) + pGenPattern->PatternOffset;

                cValidPatterns++;

                //
                // get the pattern and mask bits
                //

                if (TEST_BIT_ON(pPattern->Flags, PATTERN_SPECIFIC)) {

                    //
                    // this is a specific pattern
                    //

                    READ_LOCK(&glData.pProtocols[pPattern->ProtocolTemplate].SpecificDb.Lock, &ReadIrql);

                    ASSERT(pPattern->DbCtx);

                    q = GetKeyPtrFromSpecificPatternHandle
                        (((SpecificPatternHandle)pPattern->DbCtx));

                    RtlMoveMemory(p, q, PatternSize);
                    
                    p += PatternSize;

                    //
                    // that's a specific pattern, remember?
                    //

                    NdisFillMemory(p, PatternSize, (CHAR)0xff);

                    READ_UNLOCK(&glData.pProtocols[pPattern->ProtocolTemplate].SpecificDb.Lock, ReadIrql);

                } else {

                    pGenDb = &pCf->arpGenericDb[pPattern->ProtocolTemplate][pPattern->Priority];

                    READ_LOCK(&pGenDb->Lock, &ReadIrql);

                    //
                    // generic pattern
                    //

                    ASSERT(pPattern->DbCtx);

                    q = GetKeyPtrFromPatternHandle(pGenDb->pRhizome, 
                                                   pPattern->DbCtx);

                    RtlMoveMemory(p, q, PatternSize);
                    
                    p += PatternSize;

                    //
                    // mask
                    //

                    q = GetMaskPtrFromPatternHandle(pGenDb->pRhizome, 
                                                    pPattern->DbCtx);

                    RtlMoveMemory(p, q, PatternSize);

                    READ_UNLOCK(&pGenDb->Lock, ReadIrql);

                }
                
                p += PatternSize;
                pGenPattern = (PGPC_GEN_PATTERN)p;
                
                NDIS_UNLOCK(&pPattern->Lock);
                    
            } // for (i = 0; ...)

            //
            // we can now fill the CfInfo data.
            // 'pGenPattern' now points to the place where we can safely
            // store the CfInfo structure, and update the pointer
            //

            Buffer->InstanceNameLength = 0;
            pNotifiedClient = pBlob->pNotifiedClient;
            NotifiedClientCtx = pBlob->NotifiedClientCtx;

            st = GPC_STATUS_FAILURE;

            if (pNotifiedClient) {

                if (pNotifiedClient->FuncList.ClGetCfInfoName &&
                    NotifiedClientCtx) {

                    st = pNotifiedClient->FuncList.ClGetCfInfoName(
                                           pNotifiedClient->ClientCtx,
                                           NotifiedClientCtx,
                                           &CfInfoName
                                           );
                
                    if (CfInfoName.Length >= MAX_STRING_LENGTH * sizeof(WCHAR))
                            CfInfoName.Length = (MAX_STRING_LENGTH-1) * sizeof(WCHAR);
                    
                    //
                    // RajeshSu claims this can never happen.
                    //
                    ASSERT(NT_SUCCESS(st));

                }

            } 

            if (NT_SUCCESS(st)) {

                //
                // copy the instance name
                //
                
                Buffer->InstanceNameLength = CfInfoName.Length;
                RtlMoveMemory(Buffer->InstanceName, 
                              CfInfoName.Buffer,
                              CfInfoName.Length
                              );
            } else {

                //
                // generate a default name
                //
                if (NotifiedClientCtx) {

                    RtlInitUnicodeString(&UniStr, L"Flow <ClientNotified>");

                } else {

                    RtlInitUnicodeString(&UniStr, L"Flow <unknown name>");

                }


                RtlCopyMemory(Buffer->InstanceName, UniStr.Buffer, UniStr.Length);

                Buffer->InstanceNameLength = UniStr.Length;
                
            }

            Buffer->InstanceName[Buffer->InstanceNameLength/sizeof(WCHAR)] = L'\0';
                
            //
            // 'pGenPattern' should point to the location right after the last
            // mask, so we fill the CfInfo data there
            //

            //NDIS_LOCK(&pBlob->Lock);

            RtlMoveMemory(pGenPattern, 
                          pBlob->pClientData, 
                          pBlob->ClientDataSize);

            Buffer->Length          = cValidSize;
            Buffer->CfInfoSize      = pBlob->ClientDataSize;
            
            Buffer->CfInfoOffset    = (ULONG)((PCHAR)pGenPattern 
                                              - (PCHAR)Buffer);	// offset to structure
            Buffer->PatternCount    = cValidPatterns;
            Buffer->PatternMaskLen  = PatternMaskLen;
            Buffer->OwnerClientCtx  = pBlob->pOwnerClient->ClientCtx;

            //
            // release the blob lock we've got earlier
            //
            NDIS_UNLOCK(&pBlob->Lock);
            
            //
            // update total counts
            //
            cCfInfo++;
            cTotalBytes += cValidSize;
            Buffer = (PGPC_ENUM_CFINFO_BUFFER)((PCHAR)Buffer + cValidSize);

            pEntry = pBlob->CfLinkage.Flink;

            //
            // advance to the next blob in the list
            //

            if (pEntry == &pCf->BlobList) {

                //
                // end of blob list, reset the blob to NULL and return 
                //
                
                pBlob = NULL;
                *pCfInfoMapHandle = NULL;
                
                break;
            }

            pBlob = CONTAINING_RECORD(pEntry,
                                       BLOB_BLOCK, 
                                       CfLinkage);
            *pCfInfoMapHandle = pBlob->ClHandle;

            if (cCfInfo == *pCfInfoCount) {

                //
                // enough CfInfo's filled
                //

                break;
            }

            //
            // lock the blob for the next cycle
            //

            NDIS_LOCK(&pBlob->Lock);

        } else { // if (cTotalBytes + size <= *pBufferSize)...

            //
            // size is too small, set return values and break
            //

            //DereferenceBlob(&pBlob);

            if (cCfInfo == 0) {

                Status = GPC_STATUS_INSUFFICIENT_BUFFER;
            }

            //
            // release the blob lock we've got earlier
            //

            NDIS_UNLOCK(&pBlob->Lock);

            break;

        }

    } // for (;;")

    //NDIS_UNLOCK(&pCf->Lock);

    RSC_WRITE_UNLOCK(&pCf->ClientSync, irql);
    
    *pCfInfoHandle = (GPC_HANDLE)pBlob;
    *pCfInfoCount = cCfInfo;
    *pBufferSize = cTotalBytes;

    return Status;
}