// packet32.c - PacketInit PacketOpenAdapter PacketCloseAdapter
//              PacketAllocatePacket PacketFreePacket PacketInitPacket
//              PacketSendPacket PacketReceivePacket PacketWaitPacket
//              PacketResetAdapter PacketRequest PacketSetFilter
//              PacketGetAddr StartPacketDriver PacketGetAdapterNames
//              PacketGetName
// 
// Author: Christopher Chlap chrisc@fir.canberra.edu.au 28. November, 1997
//

// #define UNICODE 1

#include <windows.h>
#include <windowsx.h>

#include "packet32.h"

//------------------------------------------------------------------------
//
//  Globals
//
//------------------------------------------------------------------------

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

//------------------------------------------------------------------------
//
//  Prototypes
//
//------------------------------------------------------------------------

#if DBG

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

#else

#define ODS(_x)

#endif

BOOLEAN StartPacketDriver(LPTSTR ServiceName);

//------------------------------------------------------------------------
//
//  PacketInit - Start the Packet Driver
//
//      Args:   DllHandle   - not used
//              Option      - attach or detach
//              Context     - not used
//
//------------------------------------------------------------------------

BOOLEAN PacketInit(
    IN PVOID DllHandle,
    IN ULONG Option,
    IN PCONTEXT Context OPTIONAL)

{
    BOOLEAN     Status;

    ODS("Packet32: DllEntry\n");


    switch (Option) {

        case DLL_PROCESS_ATTACH:

            Status = StartPacketDriver(TEXT("PACKET"));

        case DLL_PROCESS_DETACH:

        default:

            break;
    }
    return Status;
}

//------------------------------------------------------------------------
//
//  PacketOpenAdapter - Open the named adapter
//
//      Args:   AdapterName - the UNICODE registry name of the adapter
//
//   Returns:   pointer to an Adapter or NULL
// 
//------------------------------------------------------------------------

PVOID PacketOpenAdapter(LPTSTR AdapterName)
{
    LPADAPTER  lpAdapter;
    BOOLEAN    Result;

    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%s"),
        DOSNAMEPREFIX,
        &AdapterName[8]);

    Result = DefineDosDevice(
        DDD_RAW_TARGET_PATH,
        &lpAdapter->SymbolicLink[4],
        AdapterName);

    if (Result) {

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

        if (lpAdapter->hFile != INVALID_HANDLE_VALUE)

            return lpAdapter;
    }

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

    GlobalFreePtr(lpAdapter);

    return NULL;

}

//------------------------------------------------------------------------
//
//  PacketCloseAdapter - Close the specified adapter
//
//      Args:   lpAdapter - pointer to an adapter object
//
//   Returns:   
// 
//------------------------------------------------------------------------

VOID PacketCloseAdapter(LPADAPTER lpAdapter)

{
    ODS("Packet32: PacketCloseAdapter\n");

    CloseHandle(lpAdapter->hFile);

    GlobalFreePtr(lpAdapter);

}

//------------------------------------------------------------------------
//
//  PacketAllocatePacket - allocate a Packet for send and receive
//
//      Args:   none
//
//   Returns:   pointer to a Packet or NULL   
// 
//------------------------------------------------------------------------

PVOID PacketAllocatePacket()

{
    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;
}

//------------------------------------------------------------------------
//
//  PacketFreePacket - release a Packet
//
//      Args:   lpPacket - pointer to a Packet
//
//   Returns:
// 
//------------------------------------------------------------------------

VOID PacketFreePacket(LPPACKET lpPacket)

{
    CloseHandle(lpPacket->OverLapped.hEvent);

    GlobalFreePtr(lpPacket);
}

//------------------------------------------------------------------------
//
//  PacketInitPacket - initialize an allocated Packet
//
//      Args:   lpPacket - pointer to a Packet
//              Buffer   - buffer pointer
//              Length   - length of buffer
//
//   Returns:
// 
//------------------------------------------------------------------------

VOID PacketInitPacket(LPPACKET lpPacket, PVOID Buffer, UINT Length)
{
    lpPacket->Buffer = Buffer;
    lpPacket->Length = Length;
}

//------------------------------------------------------------------------
//
//  PacketSendPacket - send a Packet
//
//      Args:   lpAdapter - pointer to an Adapter
//              lpPacket  - pointer to a Packet
//              Sync      - synchronous or asynchronous I/O
//
//   Returns:   TRUE - synchronous operation completed or
//                     asynchronous operation is pending
// 
//------------------------------------------------------------------------

BOOLEAN PacketSendPacket(LPADAPTER lpAdapter,
                         LPPACKET lpPacket,
                         BOOLEAN Sync)
{
    BOOLEAN Result;

    DWORD   BytesTransfered;

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

    if (!ResetEvent(lpPacket->OverLapped.hEvent)) return FALSE;

    Result=WriteFile(lpAdapter->hFile,
                     lpPacket->Buffer,
                     lpPacket->Length,
                     &BytesTransfered,
                     &lpPacket->OverLapped);

    if (Sync) Result = GetOverlappedResult(lpAdapter->hFile,
                                           &lpPacket->OverLapped,
                                           &BytesTransfered,
                                           TRUE);
    else 
    
        Result = TRUE;

    return Result;
}

//------------------------------------------------------------------------
//
//  PacketReceivePacket - receive a Packet
//
//      Args:   lpAdapter   - pointer to an Adapter
//              lpPacket    - pointer to a Packet
//              Sync        - synchronous or asynchronous I/O
//              BytesReveived   - pointer to number of bytes received
//
//   Returns:   TRUE  - synchronous operation completed or
//                      asynchronous operation is pending
// 
//------------------------------------------------------------------------

BOOLEAN PacketReceivePacket(LPADAPTER lpAdapter,
                            LPPACKET  lpPacket,
                            BOOLEAN   Sync,
                            PULONG    BytesReceived)
{
    BOOLEAN Result;

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

    if (!ResetEvent(lpPacket->OverLapped.hEvent)) return FALSE;

    Result = ReadFile(lpAdapter->hFile,
                      lpPacket->Buffer,
                      lpPacket->Length,
                      BytesReceived,
                      &lpPacket->OverLapped);

    if (Sync) Result = GetOverlappedResult(lpAdapter->hFile,
                                           &lpPacket->OverLapped,
                                           BytesReceived,
                                           TRUE);
    else 
        
        Result = TRUE;

    return Result;

}

//------------------------------------------------------------------------
//
//  PacketWaitPacket - wait for an asynchronous operation to complete
//
//      Args:   lpAdapter     - pointer to an Adapter object
//              lpPacket      - pointer to a Packet
//              BytesReceived - pointer to a bytes received ULONG