/*++

Copyright (c) 1990-2000  Microsoft Corporation

Module Name:

    packet32.c

Abstract:


Author:

    BrianL

Environment:

    User mode only.

Notes:


Future:



Revision History:

--*/

#define UNICODE 1

#include <windows.h>
#include <windowsx.h> // for GlobalAllocPtr and GlobalFreePtr
#include <ntddpack.h>

#include <packet32.h>

TCHAR   szWindowTitle[] = TEXT("PACKET32");


#if DBG

#define ODS(_x) OutputDebugString(TEXT(_x))

#else

#define ODS(_x)

#endif






PVOID
PacketOpenAdapter(
    LPTSTR   AdapterName
    )
/*++

Routine Description:

    This rotine opens an instance of the adapter

Arguments:

    AdapterName - unicode name of the adapter to open

Return Value:

    SUCCESS - returns a pointer to an adapter object
    FAILURE - NULL

--*/


{

    LPADAPTER  lpAdapter;
    ULONG     Error;
    
    ODS("Packet32: PacketOpenAdapter\n");

    lpAdapter=(LPADAPTER)GlobalAllocPtr(
                             GMEM_MOVEABLE | GMEM_ZEROINIT,
                             sizeof(ADAPTER)
                             );


    if (lpAdapter==NULL) {

        ODS("Packet32: PacketOpenAdapter GlobalAlloc Failed\n");

        return NULL;

    }

    wsprintf(
        lpAdapter->SymbolicLink,
        TEXT("\\\\.\\%s"),
        &AdapterName[12]
        );

    lpAdapter->hFile=CreateFile(lpAdapter->SymbolicLink,
                         GENERIC_WRITE | GENERIC_READ,
                         0,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_OVERLAPPED,
                         0
                         );

    if (lpAdapter->hFile != INVALID_HANDLE_VALUE)
        return lpAdapter;

    Error = GetLastError();

    ODS("Packet32: PacketOpenAdapter Could not open adapter\n");

    GlobalFreePtr(
        lpAdapter
        );

    return NULL;


}


VOID
PacketCloseAdapter(
    LPADAPTER   lpAdapter
    )
/*++

Routine Description:

    This rotine closes a previouly opened adapter

Arguments:

    Adapter object returned from PacketOpenAdapter

Return Value:


--*/
{

    ODS("Packet32: PacketCloseAdapter\n");

    CloseHandle(lpAdapter->hFile);

    GlobalFreePtr(lpAdapter);

}




PVOID
PacketAllocatePacket(
    LPADAPTER   AdapterObject
    )

{
/*++

Routine Description:

    This rotine this routine allocates a packet object for use
    in sending a receiveing packets

Arguments:

    Adapter object returned from PacketOpenAdapter

Return Value:

    SUCCESS - returns packet object
    FAILURE - NULL

--*/

    LPPACKET    lpPacket;

    lpPacket=(LPPACKET)GlobalAllocPtr(
                             GMEM_MOVEABLE | GMEM_ZEROINIT,
                             sizeof(PACKET)
                             );

    if (lpPacket==NULL) {

        ODS("Packet32: PacketAllocateSendPacket: GlobalAlloc Failed\n");

        return NULL;

    }

    lpPacket->OverLapped.hEvent=CreateEvent(
                        NULL,
                        FALSE,
                        FALSE,
                        NULL
                        );

    if (lpPacket->OverLapped.hEvent==NULL) {

        ODS("Packet32: PacketAllocateSendPacket: CreateEvent Failed\n");

        GlobalFreePtr(lpPacket);

        return NULL;
    }

    return lpPacket;

}

VOID
PacketFreePacket(
    LPPACKET    lpPacket
    )

{
    CloseHandle(lpPacket->OverLapped.hEvent);

    GlobalFreePtr(lpPacket);

}

VOID
PacketInitPacket(
    LPPACKET    lpPacket,
    PVOID       Buffer,
    UINT        Length
    )
/*++

Routine Description:

    This rotine initializes a packet object to point to
    a memory buffer described by Start address and length

Arguments:

    lpPacket   -  Packet object returned by PacketAllocatePacket

    Buffer     -  Begining address of a memory buffer

    Length     -  Length of memory buffer

Return Value:


--*/

{

    lpPacket->Buffer=Buffer;
    lpPacket->Length=Length;

}


BOOL
PacketSendPacket(
    LPADAPTER   AdapterObject,
    LPPACKET    lpPacket,
    BOOLEAN     Sync
    )
/*++

Routine Description:

    This rotine sends a packet to the adapter

Arguments:

    AdapterObject  - AdapterObject return by PacketOpenAdapter

    lpPacket       - Packet object returned by PacketAllocatePacket and initialized
                     by PacketInitPacket

    Sync           - TRUE if service should wait for packet to transmit


Return Value:

    SUCCESS - TRUE if succeeded and SYNC==TRUE
    FAILURE -

--*/

{
    BOOL      Result;

    DWORD      BytesTransfered;


    lpPacket->OverLapped.Offset=0;
    lpPacket->OverLapped.OffsetHigh=0;

    if (!ResetEvent(lpPacket->OverLapped.hEvent)) {

        return FALSE;

    }

    Result=WriteFile(
              AdapterObject->hFile,
              lpPacket->Buffer,
              lpPacket->Length,
              &BytesTransfered,
              &lpPacket->OverLapped
              );
    if(!Result) {
    
        if (GetLastError() == ERROR_IO_PENDING) {
            if (Sync) {
                //
                //  They want to wait for I/O to complete
                //
                Result=GetOverlappedResult(
                           AdapterObject->hFile,
                           &lpPacket->OverLapped,
                           &BytesTransfered,
                           TRUE
                           );

            } else {
                //
                //  They don't want to wait, they will call PacketWaitPacket to get
                //  The real result
                //
                Result=TRUE;

            }
        }
    }
    return Result;
}



BOOL
PacketReceivePacket(
    LPADAPTER   AdapterObject,
    LPPACKET    lpPacket,
    BOOLEAN     Sync,
    PULONG      BytesReceived
    )
/*++

Routine Description:

    This rotine issues a receive request from the adapter

Arguments:

    AdapterObject  - AdapterObject return by PacketOpenAdapter

    lpPacket       - Packet object returned by PacketAllocatePacket and initialized
                     by PacketInitPacket

    Sync           - TRUE if service should wait for packet to transmit


Return Value:

    SUCCESS - TRUE if succeeded and SYNC==TRUE
    FAILURE -

--*/


{
    BOOL      Result;

    lpPacket->OverLapped.Offset=0;
    lpPacket->OverLapped.OffsetHigh=0;

    if (!ResetEvent(lpPacket->OverLapped.hEvent)) {

        return FALSE;

    }

    Result=ReadFile(
              AdapterObject->hFile,
              lpPacket->Buffer,
              lpPacket->Length,
              BytesReceived,
              &lpPacket->OverLapped
              );
    if(!Result) {
    
        if (GetLastError() == ERROR_IO_PENDING) {

            if (Sync) {
                //
                //  They want to wait
                //
                Result=GetOverlappedResult(
                           AdapterObject->hFile,
                           &lpPacket->OverLapped,
                           BytesReceived,
                           TRUE
                           );


            } else {
                //
                //  They don't want to wait, they will call PacketWaitPacket to get
                //  The real result
                //
                Result=TRUE;

            }
        }
    }
    return Result;
}


BOOL
PacketWaitPacket(
    LPADAPTER  AdapterObject,
    LPPACKET   lpPacket,
    PULONG     BytesReceived
    )
/*++

Routine Description:

    This routine waits for an overlapped IO on a packet to complete
    Called if the send or receive call specified FALSE for the Sync parmeter

Arguments:

    AdapterObject  - AdapterObject return by PacketOpenAdapter

    lpPacket       - Packet object returned by PacketAllocatePacket and initialized
                     by PacketInitPacket

Return Value:

    SUCCESS - TRUE if overlapped call succeeded
    FAILURE -

--*/

{


    return GetOverlappedResult(
               AdapterObject->hFile,
               &lpPacket->OverLapped,
               BytesReceived,
               TRUE
               );


}


BOOL
PacketResetAdapter(
    LPADAPTER  AdapterObject
    )
/*++

Routine Description:

    This rotuine resets the adapter. This will complete all pending sends receives and requests

Arguments:

    AdapterObject  - AdapterObject return by PacketOpenAdapter

Return Value:

    SUCCESS - TRUE if overlapped call succeeded
    FAILURE -

--*/

{
    UINT       BytesReturned;

    return DeviceIoControl(