windows-server-2003/net/1394/arp/sys/fake.c

/*++

Copyright (c) 1999-2000  Microsoft Corporation

Module Name:

    fake.c

Abstract:

    Fake versions of various external calls (ndis, ip...).
    Used for debugging and component testing only.

    To enable, define ARPDBG_FAKE_APIS in ccdefs.h

Revision History:

    Who         When        What
    --------    --------    ----------------------------------------------
    josephj     03-22-98    Created

Notes:

--*/
#include <precomp.h>


#if ARPDBG_FAKE_APIS

//
// File-specific debugging defaults.
//
#define TM_CURRENT   TM_FAKE


//=========================================================================
//                  L O C A L   P R O T O T Y P E S
//=========================================================================



#if RM_EXTRA_CHECKING
    #define LOCKROOTOBJ(_pHdr, _pSR)            \
            RmWriteLockObject(                  \
                    (_pHdr)->pRootObject,       \
                    0,                          \
                    (_pSR)                      \
                    )
#else       // !RM_EXTRA_CHECKING
    #define LOCKROOTOBJ(_pHdr, _pSR)            \
            RmWriteLockObject(                  \
                    (_pHdr)->pRootObject,       \
                    (_pSR)                      \
                    )
#endif      // !RM_EXTRA_CHECKING

#define UNLOCKROOTOBJ(_pHdr, _pSR)          \
        RmUnlockObject(                     \
                (_pHdr)->pRootObject,       \
                (_pSR)                      \
                )

typedef
VOID
(*PFN_FAKE_COMPLETIONCALLBACK)(
    struct _FAKETASK *pFTask
);


// This task structure holds a union of the information required for the completions
// of the various apis that are being faked.
//
typedef struct _FAKETASK
{
    RM_TASK TskHdr;

    //  Client's context to pass back
    //
    PVOID                   pClientContext;

    // Client object the call is associated.
    //
    PRM_OBJECT_HEADER       pOwningObject;

    //  The status to report in the asynchronous completion fn.
    //
    NDIS_STATUS             Status;

    //  Milliseconds to delay before calling the async completion fn.
    //
    UINT                    DelayMs;

    //  Wheather to call the completion fn at DPC or PASSIVE IRQL level.
    //
    INT                     fDpc;

    // This is used solely to switch to DPC level when asynchronously
    // calling the completion callback.
    //
    NDIS_SPIN_LOCK          NdisLock;

    // This is used solely to wait DelayMs ms if required.
    //
    NDIS_TIMER              Timer;

    // This is used solely to switch to a different (and PASSIVE) context.
    //
    NDIS_WORK_ITEM          WorkItem;

    // This is used only for fake NdisClMakeCall
    //
    PCO_CALL_PARAMETERS     CallParameters;

    // This is used only for fake NdisCoSendPackets
    //
    PNDIS_PACKET            pNdisPacket;

    // The actual completion callback function;
    //
    PFN_FAKE_COMPLETIONCALLBACK pfnCompletionCallback;

} FAKETASK;


VOID
arpFakeMakeCallCompletionCallback(
    struct _FAKETASK *pFTask
);


VOID
arpFakeCloseCallCompletionCallback(
    struct _FAKETASK *pFTask
);


VOID
arpFakeSendPacketsCompletionCallback(
    struct _FAKETASK *pFTask
);


NDIS_STATUS
arpDbgAllocateFakeTask(
    IN  PRM_OBJECT_HEADER           pParentObject,
    IN  PFN_RM_TASK_HANDLER         pfnHandler,
    IN  UINT                        Timeout,
    IN  const char *                szDescription,
    OUT PRM_TASK                    *ppTask,
    IN  PRM_STACK_RECORD            pSR
    );

VOID
arpDbgFakeTaskDelete(
    PRM_OBJECT_HEADER pObj,
    PRM_STACK_RECORD psr
    );

RM_STATIC_OBJECT_INFO
FakeTasks_StaticInfo = 
{
    0,                      // TypeUID
    0,                      // TypeFlags
    "FAKE Task",            // TypeName
    0,                      // Timeout

    NULL,                   // pfnCreate
    arpDbgFakeTaskDelete,   // pfnDelete
    NULL,                   // pfnVerifier

    0,                      // length of resource table
    NULL                    // Resource Table
};


NDIS_STATUS
arpDbgFakeCompletionTask(
    IN  struct _RM_TASK *           pTask,
    IN  RM_TASK_OPERATION           Code,
    IN  UINT_PTR                    UserParam,  // Unused
    IN  PRM_STACK_RECORD            pSR
    );


//=========================================================================
//                  F A K E      N D I S     E N T R Y P O I N T S
//=========================================================================


NDIS_STATUS
arpDbgFakeNdisClMakeCall(
    IN  NDIS_HANDLE             NdisVcHandle,
    IN OUT PCO_CALL_PARAMETERS  CallParameters,
    IN  NDIS_HANDLE             ProtocolPartyContext    OPTIONAL,
    OUT PNDIS_HANDLE            NdisPartyHandle,        OPTIONAL
    IN  PRM_OBJECT_HEADER       pOwningObject,
    IN  PVOID                   pClientContext,
    IN  PRM_STACK_RECORD        pSR
    )
/*++

Routine Description:

    Fake version of NdisClMakeCall.

--*/
{
    ENTER("FakeNdisClMakeCall", 0x3d4195ae)
    NDIS_STATUS Status;
    NDIS_STATUS AsyncStatus;
    UINT DelayMs;
    
    DBGMARK(0xced41a61);
    RM_ASSERT_NOLOCKS(pSR);
    ASSERT(NdisPartyHandle==NULL);
    ASSERT(ProtocolPartyContext==NULL);
    ASSERT(NdisVcHandle != NULL);


    do
    {
        static
        OUTCOME_PROBABILITY
        StatusOutcomes[] = 
        {
            {NDIS_STATUS_SUCCESS,   1},     // Return NDIS_STATUS_SUCCESS
            {NDIS_STATUS_FAILURE,   1}      // Return NDIS_STATUS_FAILURE
        };

        static
        OUTCOME_PROBABILITY
        DelayMsOutcomes[] = 
        {
            {0,         5},     // Delay 0ms, etc...
            {10,        5},
            {100,       5},
            {1000,      1},
            {10000,     1}
        };

        static
        OUTCOME_PROBABILITY
        AsyncOutcomes[] = 
        {
            {TRUE,      1},     // Complete Async
            {FALSE,     1}      // Complete Sync
        };
        
        static
        OUTCOME_PROBABILITY
        DpcOutcomes[] = 
        {
            {TRUE,      1},     // Complete at DPC level
            {FALSE,     1}      // Complete at PASSIVE level
        };

        FAKETASK *pMCTask;


        // We serialize calls to arpGenRandomInt by claiming the root object's
        // lock...
        //
        LOCKROOTOBJ(pOwningObject, pSR);

        // Get the status we're supposed to return.
        //
        Status =
        AsyncStatus = (NDIS_STATUS) arpGenRandomInt(
                                     StatusOutcomes,
                                     ARRAY_LENGTH(StatusOutcomes)
                                     );

        // Determine if we're to return synchronously or complete
        // asynchronously...
        //
        if (!arpGenRandomInt(AsyncOutcomes, ARRAY_LENGTH(AsyncOutcomes)))
        {
            // We're to return synchronously.
            //
            UNLOCKROOTOBJ(pOwningObject, pSR);
            break;
        }

        // 
        // We're to complete asynchronously...
        //

        DelayMs             = arpGenRandomInt(
                                        DelayMsOutcomes,
                                        ARRAY_LENGTH(DelayMsOutcomes)
                                        );

        if (DelayMs == 0)
        {
            // We're to immediately indicatie async completion...
            // (we don't mess with IRQ levels if we're returning here..)
            //
            UNLOCKROOTOBJ(pOwningObject, pSR);
            ArpCoMakeCallComplete(
                        AsyncStatus,
                        pClientContext,
                        NULL,
                        CallParameters
                        );
            Status = NDIS_STATUS_PENDING;
            break;
        }

        // We're to indicate status sometime in the future -- in a different context.
        // Start a task to do this...
        //

        Status = arpDbgAllocateFakeTask(
                            pOwningObject,              // pParentObject,
                            arpDbgFakeCompletionTask,   // pfnHandler,
                            0,                          // Timeout,
                            "Task:Fake NdisClMakeCall", // szDescription,
                            &(PRM_TASK) pMCTask,
                            pSR
                            );
        if (FAIL(Status))
        {
            // Couldn't allocate task. Call callback right away...
            //
            UNLOCKROOTOBJ(pOwningObject, pSR);
            ArpCoMakeCallComplete(
                        AsyncStatus,
                        pClientContext,
                        NULL,
                        CallParameters
                        );
            Status = NDIS_STATUS_PENDING;
            break;
        }

        
        // Initialize pMCTask...
        //
        pMCTask->pClientContext     = pClientContext;
        pMCTask->pOwningObject      = pOwningObject;
        pMCTask->Status             = AsyncStatus;
        pMCTask->DelayMs            = DelayMs;
        pMCTask->fDpc               = arpGenRandomInt(
                                            DpcOutcomes,
                                            ARRAY_LENGTH(DpcOutcomes)
                                            );
        pMCTask->CallParameters =  CallParameters;
        pMCTask->pfnCompletionCallback = arpFakeMakeCallCompletionCallback;

        UNLOCKROOTOBJ(pOwningObject, pSR);

        (void) RmStartTask(
                    &pMCTask->TskHdr,
                    0, // UserParam (unused)
                    pSR
                    );

        Status = NDIS_STATUS_PENDING;

    } while (FALSE);


    RM_ASSERT_NOLOCKS(pSR);
    EXIT();

    return Status;
}


NDIS_STATUS
arpDbgFakeNdisClCloseCall(
    IN  NDIS_HANDLE             NdisVcHandle,
    IN  NDIS_HANDLE             NdisPartyHandle         OPTIONAL,
    IN  PVOID                   Buffer                  OPTIONAL,
    IN  UINT                    Size,                   OPTIONAL
    IN  PRM_OBJECT_HEADER       pOwningObject,
    IN  PVOID                   pClientContext,
    IN  PRM_STACK_RECORD        pSR
    )
/*++

Routine Description:

    Fake version of NdisClCloseCall.

--*/
{
    ENTER("FakeNdisClCloseCall", 0x7d8bbd3c)
    NDIS_STATUS Status;
    NDIS_STATUS AsyncStatus;
    UINT        DelayMs;
    
    DBGMARK(0x228fac3a);
    RM_ASSERT_NOLOCKS(pSR);
    ASSERT(NdisPartyHandle==NULL);
    ASSERT(NdisVcHandle != NULL);


    do
    {

        static
        OUTCOME_PROBABILITY
        DelayMsOutcomes[] = 
        {
            {0,         5},     // Delay 0ms, etc...
            {10,        5},
            {100,       5},
            {1000,      1},
            {10000,     1}
        };

        static
        OUTCOME_PROBABILITY
        AsyncOutcomes[] = 
        {
            {TRUE,      1},     // Complete Async
            {FALSE,     1}      // Complete Sync
        };
        
        static
        OUTCOME_PROBABILITY
        DpcOutcomes[] = 
        {
            {TRUE,      1},     // Complete at DPC level
            {FALSE,     1}      // Complete at PASSIVE level
        };

        FAKETASK *pCCTask;


        // We serialize calls to arpGenRandomInt by claiming the root object's
        // lock...
        //
        LOCKROOTOBJ(pOwningObject, pSR);

        // Get the status we're supposed to return.
        //
        Status =
        AsyncStatus = NDIS_STATUS_SUCCESS; // We never fail this call.

        // Determine if we're to return synchronously or complete
        // asynchronously...
        //
        if (!arpGenRandomInt(AsyncOutcomes, ARRAY_LENGTH(AsyncOutcomes)))
        {
            // We're to return synchronously.
            //
            UNLOCKROOTOBJ(pOwningObject, pSR);
            break;
        }

        // 
        // We're to complete asynchronously...
        //

        DelayMs             = arpGenRandomInt(
                                        DelayMsOutcomes,
                                        ARRAY_LENGTH(DelayMsOutcomes)
                                        );

        if (DelayMs == 0)
        {
            // We're to immediately indicatie async completion...
            // (we don't mess with IRQ levels if we're returning here..)
            //
            UNLOCKROOTOBJ(pOwningObject, pSR);
            ArpCoCloseCallComplete(
                    AsyncStatus,
                    pClientContext,
                    NULL
                    );
            Status = NDIS_STATUS_PENDING;
            break;
        }

        Status = arpDbgAllocateFakeTask(
                            pOwningObject,          // pParentObject,
                            arpDbgFakeCompletionTask,   // pfnHandler,
                            0,                          // Timeout,
                            "Task:Fake NdisClCloseCall", // szDescription,
                            &(PRM_TASK) pCCTask,
                            pSR
                            );
        if (FAIL(Status))
        {
            // Couldn't alloc task; lets call callback right now and return pending.
            //
            UNLOCKROOTOBJ(pOwningObject, pSR);
            ArpCoCloseCallComplete(
                    AsyncStatus,
                    pClientContext,
                    NULL
                    );
            Status = NDIS_STATUS_PENDING;
            break;
        }

        
        // Initialize pCCTask...
        //
        pCCTask->pClientContext     = pClientContext;
        pCCTask->pOwningObject      = pOwningObject;
        pCCTask->Status             = AsyncStatus;
        pCCTask->DelayMs            = DelayMs;
        pCCTask->fDpc               = arpGenRandomInt(
                                            DpcOutcomes,
                                            ARRAY_LENGTH(DpcOutcomes)
                                            );
        pCCTask->pfnCompletionCallback = arpFakeCloseCallCompletionCallback;

        UNLOCKROOTOBJ(pOwningObject, pSR);

        (void) RmStartTask(
                    &pCCTask->TskHdr,
                    0, // UserParam (unused)
                    pSR
                    );

        Status = NDIS_STATUS_PENDING;

    } while (FALSE);


    RM_ASSERT_NOLOCKS(pSR);
    EXIT();

    return Status;
}


VOID
arpDbgFakeNdisCoSendPackets(
    IN  NDIS_HANDLE             NdisVcHandle,
    IN  PPNDIS_PACKET           PacketArray,
    IN  UINT                    NumberOfPackets,
    IN  PRM_OBJECT_HEADER       pOwningObject,
    IN  PVOID                   pClientContext
    )
/*++

Routine Description:

    Fake version of NdisCoSendPackets.

--*/
{
    ENTER("FakeNdisCoSendPackets", 0x98c6a8aa)
    NDIS_STATUS Status;
    NDIS_STATUS AsyncStatus;
    UINT        DelayMs;
    RM_DECLARE_STACK_RECORD(sr)
    
    DBGMARK(0x3be1b902);
    ASSERT(NumberOfPackets==1);

    do
    {
        static
        OUTCOME_PROBABILITY
        StatusOutcomes[] = 
        {
            {NDIS_STATUS_SUCCESS,   1},     // Return NDIS_STATUS_SUCCESS
            {NDIS_STATUS_FAILURE,   1}      // Return NDIS_STATUS_FAILURE
        };

        static
        OUTCOME_PROBABILITY
        DelayMsOutcomes[] = 
        {
            {0,         5},     // Delay 0ms, etc...
            {10,        5},
            {100,       5},
            {1000,      1},
            {10000,     1}
        };
        
        static
        OUTCOME_PROBABILITY
        DpcOutcomes[] = 
        {
            {TRUE,      1},     // Complete at DPC level
            {FALSE,     1}      // Complete at PASSIVE level
        };

        FAKETASK *pSPTask;


        // We serialize calls to arpGenRandomInt by claiming the root object's
        // lock...
        //
        LOCKROOTOBJ(pOwningObject, &sr);

        // Get the status we're supposed to return.
        //
        Status =
        AsyncStatus = (NDIS_STATUS) arpGenRandomInt(
                                     StatusOutcomes,
                                     ARRAY_LENGTH(StatusOutcomes)
                                     );

        // Compute the delay amount.
        //
        DelayMs             = arpGenRandomInt(
                                            DelayMsOutcomes,
                                            ARRAY_LENGTH(DelayMsOutcomes)
                                            );
        if (DelayMs == 0)
        {
            UNLOCKROOTOBJ(pOwningObject, &sr);
            // We're to immediately indicatie async completion...
            // (we don't mess with IRQ levels if we're returning here..)
            //
            ArpCoSendComplete(
                AsyncStatus,
                pClientContext,
                *PacketArray
                );
            break;
        }

        //
        // Nonzero delay -- start task to complete this.
        //

        Status = arpDbgAllocateFakeTask(
                            pOwningObject,              // pParentObject,
                            arpDbgFakeCompletionTask,   // pfnHandler,
                            0,                          // Timeout,
                            "Task:Fake NdisCoSendPackets", // szDescription,
                            &(PRM_TASK) pSPTask,
                            &sr
                            );
        if (FAIL(Status))
        {
            UNLOCKROOTOBJ(pOwningObject, &sr);
            // Fail...
            //
            ArpCoSendComplete(
                AsyncStatus,
                pClientContext,
                *PacketArray
                );
            break;
        }

        
        // Initialize pSPTask...
        //
        pSPTask->pClientContext     = pClientContext;
        pSPTask->pOwningObject      = pOwningObject;
        pSPTask->Status             = AsyncStatus;
        pSPTask->DelayMs            = DelayMs;
        pSPTask->fDpc               = arpGenRandomInt(
                                            DpcOutcomes,
                                            ARRAY_LENGTH(DpcOutcomes)
                                            );
        pSPTask->pNdisPacket        = *PacketArray;
        pSPTask->pfnCompletionCallback = arpFakeSendPacketsCompletionCallback;

        UNLOCKROOTOBJ(pOwningObject, &sr);

        (void) RmStartTask(
                    &pSPTask->TskHdr,
                    0, // UserParam (unused)
                    &sr
                    );

        Status = NDIS_STATUS_PENDING;

    } while (FALSE);

    RM_ASSERT_NOLOCKS(&sr);
    EXIT();

}


NDIS_STATUS
arpDbgFakeCompletionTask(
    IN  struct _RM_TASK *           pTask,
    IN  RM_TASK_OPERATION           Code,
    IN  UINT_PTR                    UserParam,
    IN  PRM_STACK_RECORD            pSR
    )
/*++

Routine Description:

        This task is to complete the fake api asynchronously after the
        specified delay, with the specified status, and at the specified
        IRQL (passive/dpc).

Arguments:
    
    UserParam   for (Code ==  RM_TASKOP_START)          : unused

--*/
{
    NDIS_STATUS         Status  = NDIS_STATUS_FAILURE;
    FAKETASK          * pFTask =  (FAKETASK *) pTask;
    ENTER("FakeCompletionTask", 0xc319c5c2)

    // Following are the list of pending states for this task.
    //
    enum
    {
        PEND_ResumedAfterDelay,
        PEND_SwitchedToAsync,
    };

    switch(Code)
    {

        case RM_TASKOP_START:
        {

            TR_WARN((
                "START: Delay=%lu; fDpc=%lu; Status=%lu\n",
                    pFTask->DelayMs,
                    pFTask->fDpc,
                    pFTask->Status
                ));

            if (pFTask->DelayMs!=0)
            {
                //  Non-zero delay -- let's resume after the delay...
                //
                RmSuspendTask(pTask, PEND_ResumedAfterDelay, pSR);

                RmResumeTaskDelayed(
                    pTask, 
                    0,
                    pFTask->DelayMs,
                    &pFTask->Timer,
                    pSR
                    );
            }
            else
            {
                // No delay is requested. Switch to async right away...
                //
                RmSuspendTask(pTask, PEND_SwitchedToAsync, pSR);

                RmResumeTaskAsync(
                    pTask,
                    0,
                    &pFTask->WorkItem,
                    pSR
                    );
            }

            RM_ASSERT_NOLOCKS(pSR);
            Status = NDIS_STATUS_PENDING;

        }
        break;

        case  RM_TASKOP_PENDCOMPLETE:
        {

            switch(RM_PEND_CODE(pTask))
            {
                case PEND_ResumedAfterDelay:
                {
                    // We've waited around for pFTask->DelayMs ms; Now
                    // switch to passive...
                    //
                    RmSuspendTask(pTask, PEND_SwitchedToAsync, pSR);

                    RmResumeTaskAsync(
                        pTask,
                        0,
                        &pFTask->WorkItem,
                        pSR
                        );
                    Status = NDIS_STATUS_PENDING;
                }
                break;

                case PEND_SwitchedToAsync:
                {
                    //
                    // We should now be at PASSIVE IRQL.
                    // Call the completion routine either at DPC or PASSIVE irql.
                    //

                    if (pFTask->fDpc)
                    {
                        //  We need to call the routine at DPC level.
                        //
                        NdisAllocateSpinLock(&pFTask->NdisLock);
                        NdisAcquireSpinLock(&pFTask->NdisLock);
                    }

                    // Call the completion routine.
                    //
                    pFTask->pfnCompletionCallback(pFTask);

                    // If required, release the lock we held earlier.
                    //
                    if (pFTask->fDpc)
                    {
                        NdisReleaseSpinLock(&pFTask->NdisLock);
                    }
                    Status = pFTask->Status;
        
                } // end case  PEND_OnStart
                break;
    

                default:
                {
                    ASSERTEX(!"Unknown pend op", pTask);
                }
                break;
    

            } // end switch(RM_PEND_CODE(pTask))

        } // case RM_TASKOP_PENDCOMPLETE
        break;

        case RM_TASKOP_END:
        {
            Status = (NDIS_STATUS) UserParam;

        }
        break;

        default:
        {
            ASSERTEX(!"Unexpected task op", pTask);
        }
        break;

    } // switch (Code)

    RM_ASSERT_NOLOCKS(pSR);
    EXIT()

    return Status;
}


NDIS_STATUS
arpDbgAllocateFakeTask(
    IN  PRM_OBJECT_HEADER           pParentObject,
    IN  PFN_RM_TASK_HANDLER         pfnHandler,
    IN  UINT                        Timeout,
    IN  const char *                szDescription,
    OUT PRM_TASK                    *ppTask,
    IN  PRM_STACK_RECORD            pSR
    )
/*++

Routine Description:

    Allocates and initializes a task of subtype FAKETASK.

Arguments:

    pParentObject       - Object that is to be the parent of the allocated task.
    pfnHandler          - The task handler for the task.
    Timeout             - Unused.
    szDescription       - Text describing this task.
    ppTask              - Place to store pointer to the new task.

Return Value:

    NDIS_STATUS_SUCCESS if we could allocate and initialize the task.
    NDIS_STATUS_RESOURCES otherwise
--*/
{
    FAKETASK *pFTask;
    NDIS_STATUS Status;
        
    ARP_ALLOCSTRUCT(pFTask, MTAG_DBGINFO);
    Status = NDIS_STATUS_RESOURCES;
    *ppTask = NULL;

    if (pFTask != NULL)
    {

        RmInitializeTask(
                    &(pFTask->TskHdr),
                    pParentObject,
                    pfnHandler,
                    &FakeTasks_StaticInfo,
                    szDescription,
                    Timeout,
                    pSR
                    );
        *ppTask = &(pFTask->TskHdr);
        Status = NDIS_STATUS_SUCCESS;
    }

    return Status;
}


VOID
arpDbgFakeTaskDelete (
    PRM_OBJECT_HEADER pObj,
    PRM_STACK_RECORD psr
    )
/*++

Routine Description:

    Actually free the specified task.

Arguments:

    pObj        - Actually the task to be freed.

--*/
{
    ARP_FREE(pObj);
}


INT
arpGenRandomInt(
    OUTCOME_PROBABILITY *rgOutcomes,
    UINT                cOutcomes
    )
/*++

Routine Description:

    Generate a new sample given the specified probability distribution.


Arguments:

    rgOutcomes      - Array of outcomes from which to select the random
                      sample.
    cOutcomes       - Number of elements in the above array.

Return Value:

    Random integer

--*/
{
    ULONG   u, sum, partsum;
    OUTCOME_PROBABILITY *pOp, *pOpEnd;

    // Get a nicely-random number.
    //
    u = ran1x();

    // Run through weights, computing the sum of weights...
    //
    pOp = pOpEnd = rgOutcomes;
    pOpEnd += cOutcomes;
    sum=0;
    for(; pOp<pOpEnd; pOp++)
    {
        sum += pOp->Weight;
    }

    // It's really meaningless to pass in a pPD with zero sum of weights.
    // We return 0 in this case. 
    //
    if (sum == 0)           return 0;               // EARLY RETURN

    // Make u range from 0..sum-1 inclusive
    //
    u ^= u>>16; // Get more randomness in the lower 16 bits for mod below...
    u %= sum;

    // Now go through the array of outcomes, computing the partial sum (partsum)
    // of weigths, and picking the FIRST outcome at array position X such that
    // u < partsum.
    //
    partsum=0;
    pOp = pOpEnd = rgOutcomes;
    pOpEnd += cOutcomes;
    for(; pOp<pOpEnd; pOp++)
    {
        partsum += pOp->Weight;
        if (u < partsum)
        {
            break;  // Found it!
        }
    }

    ASSERT(pOp<pOpEnd);

    return pOp->Outcome;
}


static long g_idum;

unsigned long ran1x(void)
/*++

Routine Description:

    Closely based on ran1() from "Numerical Recipes in C." ISBN 0 521 43108 5
    (except that it returns unsigned long instead of float, and uses g_idum
     instead of input arg long *idum).

    Pretty uniform and uncorrelated from sample to sample; also individual bits are
    pretty random. We need these properties.

Return Value:

    Random unsigned integer.

--*/
{
    #define IA      16807
    #define IM      RAN1X_MAX
    #define IQ      127773
    #define IR      2836
    #define NTAB    32
    #define NDIV    (1+(IM-1)/NTAB)

    int j;
    long k;
    static long iy=0;
    static long iv[NTAB];

    if (g_idum <= 0 || !iy)
    {
        //
        // Initialization code... (I'm not really sure if iy or g_idum can
        // go to zero in the course of operation, so I'm leaving this
        // initialization code here instead of moving it to sranx1x).
        //

        if (-g_idum < 1)
        {
            g_idum = 1;
        }
        else
        {
            g_idum = -g_idum;
        }
        for (j=NTAB+7;j>=0;j--)
        {
            k = g_idum/IQ;
            g_idum = IA*(g_idum-k*IQ)-IR*k;
            if (g_idum<0)
            {
                g_idum += IM;
            }
            if (j<NTAB)
            {
                iv[j] = g_idum;
            }
        }
        iy=iv[0];
    }

    k=g_idum/IQ;
    g_idum=IA*(g_idum-k*IQ)-IR*k;
    if (g_idum<0)
    {
        g_idum += IM;
    }
    j = iy/NDIV;
    iy = iv[j];
    iv[j] = g_idum;

    // iy ranges from 1 .. (IM-1)
    //
    return (unsigned long) iy;
}

void
sran1x(
    unsigned long seed
    )
/*++

Routine Description:

    Sets the seed used by ran1x.

--*/
{
    g_idum = (long) seed;

    //
    // Make sure the seed is -ve, to trigger ran1x initialization code above.
    //

    if (g_idum > 0)
    {
        g_idum = -g_idum;
    }
    if (g_idum==0)
    {
        g_idum = -1;
    }
}


VOID
arpFakeMakeCallCompletionCallback(
    struct _FAKETASK *pFTask
)
/*++

Routine Description:

    Calls ARP's makecall completion callback.

Arguments:

    pFTask  - Task in whose context this callback is to be made. The task
              contains information used in calling the makecall  completion
              callback.
--*/
{
    // Call the make call completion routine.
    //
    ArpCoMakeCallComplete(
                pFTask->Status,
                (NDIS_HANDLE)  pFTask->pClientContext,
                NULL,
                pFTask->CallParameters
                );
}


VOID
arpFakeCloseCallCompletionCallback(
    struct _FAKETASK *pFTask
)
/*++

Routine Description:

    Calls ARP's closecall completion callback.

Arguments:

    pFTask  - Task in whose context this callback is to be made. The task
              contains information used in calling the closecall  completion
              callback.
--*/
{
        ArpCoCloseCallComplete(
                pFTask->Status,
                (NDIS_HANDLE)  pFTask->pClientContext,
                NULL
                );
}


VOID
arpFakeSendPacketsCompletionCallback(
    struct _FAKETASK *pFTask
)
/*++

Routine Description:

    Calls ARP's cosendpackets completion callback.

Arguments:

    pFTask  - Task in whose context this callback is to be made. The task
              contains information used in calling the cosendpackets  completion
              callback.
--*/
{
        ArpCoSendComplete(
                pFTask->Status,
                (NDIS_HANDLE)  pFTask->pClientContext,
                pFTask->pNdisPacket
                );
}

#endif // ARPDBG_FAKE_APIS