/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    monrqust.c

Abstract:

    This module contains the Mon requests thread and
    the handler for Mon requests.

Author:

    Michael Jarus (mjarus) 21-Jan-1992

Environment:

    User Mode Only

Revision History:

--*/

#define WIN32_ONLY
#include "os2ses.h"
#include "event.h"
#include "trans.h"
#include "monitor.h"
#include "mon.h"
#include <stdio.h>


USHORT  RegSize[] = { MIN_KBD_MON_BUFFER, 127 };
USHORT  RWSize[] = { sizeof(KBD_MON_PACKAGE),
                     sizeof(MOU_MON_PACKAGE) };

extern CRITICAL_SECTION    QueueInputCriticalSection;

DWORD
MonQueueClose(IN  HANDLE   hMon);

DWORD
InitMonitor()
{
    RtlZeroMemory(&MonBuffTable[0].MonHeader, sizeof(MonBuffTable));
    MonQueue = NULL;

    MonitorEvent = CreateEventW(
                                NULL,
                                FALSE,              /* auto reset */
                                TRUE,
                                NULL);

    if (MonitorEvent == NULL)
    {
#if DBG
        DbgPrint("OS2SES(InitMonitor): unable to create event for Monitor\n");
#endif
        return 1L;
    }

    KbdLastKeyDown = FALSE;

    LastKbdMon = NULL;
    LastMouMon = NULL;

    return(0L);
}


BOOL
ServeMonRequest(IN  PMONREQUEST     PReq,
                OUT PVOID           PStatus,
                IN  PVOID           pMsg,
                OUT PULONG          pReply)
{
    DWORD               Rc;

    Rc = *(PDWORD) PStatus = 0;

    switch (PReq->Request)
    {
        case MONOpen:
            Rc = *(PDWORD) PStatus = MonOpen(PReq->d.OpenClose.MonDevice,
                                             &(PReq->d.OpenClose.hMON));
            break;

        case MONReg:
            Rc = *(PDWORD) PStatus = MonReg(&(PReq->d.Reg));
            break;

        case MONRead:
            Rc = *(PDWORD) PStatus = MonRead(&(PReq->d.rwParms),
                                             pReply,
                                             pMsg);
            break;

        case MONWrite:
            Rc = *(PDWORD) PStatus = MonWrite(&(PReq->d.rwParms),
                                              pReply,
                                              pMsg);
            break;

        case MONClose:
            Rc = *(PDWORD) PStatus = MonClose(PReq->d.OpenClose.hMON);
            break;

        default:
            Rc = *(PDWORD) PStatus = ERROR_MON_INVALID_PARMS;
#if DBG
            IF_OD2_DEBUG( OS2_EXE )
            {
                DbgPrint("OS2SES(MonRequest): Unknown Mon request = %X\n",
                          PReq->Request);
            }
#endif
    }

    return(TRUE);  // Continue
}


DWORD
MonOpen(IN  MONDEVNUMBER DevType,
        OUT PHANDLE      hMon)
{
        DWORD       Rc;

    /*
     * allocate buffer for header & queue
     */

    if (DevType == KbdDevice)
    {
        Rc = InitQueue((PKEY_EVENT_QUEUE *)hMon);
    } else if (DevType == MouseDevice)
    {
        Rc = InitMouQueue((PMOU_EVENT_QUEUE *)hMon);
    } else /* if (DevType == Lpt1Device) */
    {
#if DBG
        IF_OD2_DEBUG( MON )
            IF_OD2_DEBUG( OS2_EXE )
                DbgPrint("OS2SES(MonOpen): illegal device\n");
#endif

        return(ERROR_MONITOR_NOT_SUPPORTED);
    }

    if (Rc)
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonOpen): unable to allocate handle\n");
#endif

        return(ERROR_NOT_ENOUGH_MEMORY);
    }

    ((PKEY_EVENT_QUEUE)*hMon)->MonHdr.DevType = DevType;
    ((PKEY_EVENT_QUEUE)*hMon)->MonHdr.MonStat = MON_STAT_OPEN;   // Mon-Open
    ((PKEY_EVENT_QUEUE)*hMon)->MonHdr.NextMon = NULL;

#if DBG
    IF_OD2_DEBUG( MON )
    {
        DbgPrint("OS2SES(MonOpen): return address %lx\n", *hMon);
    }
#endif

    return(0L);
}


DWORD
MonReg(IN  PMON_REG MonReg)
{
        DWORD           Rc;
        BOOL            NewReg = FALSE;
        PMON_HEADER     NextMon, NewMonHeader;
        PKEY_EVENT_QUEUE    hMon;

    /*
     * make sure buffer are not used for other monitor
     */

    if ((FindMonitorBuffer(MonReg->In, MonReg->ProcessId)) ||
        (FindMonitorBuffer(MonReg->Out, MonReg->ProcessId)))
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonReg): buffer already reg\n");
#endif

        return ERROR_MON_INVALID_PARMS;
    }

    hMon = (PKEY_EVENT_QUEUE)MonReg->hMON;

#if DBG
    IF_OD2_DEBUG( MON )
    {
        DbgPrint("OS2SES(MonReg): hMon address %lx\n", hMon);
    }
#endif

    if ((MonReg->InSize < RegSize[hMon->MonHdr.DevType]) ||
        (MonReg->OutSize < RegSize[hMon->MonHdr.DevType]))
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonReg): buffer too small\n");
#endif

        return ERROR_NOT_ENOUGH_MEMORY;
    }

    if (hMon->MonHdr.MonStat != MON_STAT_OPEN)
    {
        /*
         * queue in use, allocate new one
         */

#if DBG
        IF_OD2_DEBUG( MON )
        {
            DbgPrint("OS2SES(MonReg): allocate new queue\n");
        }
#endif

        NewReg = TRUE;

        if ((Rc = MonOpen(hMon->MonHdr.DevType,
                          (PHANDLE)&NewMonHeader)))
        {
#if DBG
            DbgPrint("OS2SES(MonReg): unable to allocate handle\n");
#endif
            return Rc;
        }

        NextMon = (PMON_HEADER)hMon;

        while (NextMon->NextMon != NULL)
        {
            NextMon = NextMon->NextMon;
        }

#if DBG
        IF_OD2_DEBUG( MON )
        {
            DbgPrint("OS2SES(MonReg): find place\n");
        }
#endif

    } else
        NewMonHeader = (PMON_HEADER)hMon;

    NewMonHeader->MonReg = *MonReg;

    /*
     * add monitor to the device-queue
     */

    Rc = AddMonitor(NewMonHeader, (PMON_HEADER *)
        ((NewMonHeader->DevType == KbdDevice) ?
             (PMON_HEADER *) &KbdMonQueue : (PMON_HEADER *) &MouMonQueue));

    if (Rc)
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonReg): unable to register\n");
#endif

        if (NewReg)
        {
            HeapFree(HandleHeap, 0,
                     (LPSTR)  NewMonHeader->MemoryStartAddress);
        }

        return(Rc);
    }

    /*
     * add buffer to table of monitor-buffer
     */

    AddMonitorBuffer(MonReg->In, NewMonHeader, MonReg->ProcessId);
    AddMonitorBuffer(MonReg->Out, NewMonHeader, MonReg->ProcessId);

    NewMonHeader->MonStat = MON_STAT_REG;   // Mon-Open-And-Reg

    if (NewReg)
    {
        NextMon->NextMon = NewMonHeader;
    }

    MonReg->InSize = RWSize[NewMonHeader->DevType];
    MonReg->OutSize = RWSize[NewMonHeader->DevType];

    return(0L);
}


DWORD
MonRead(IN OUT PMON_RW rwParms,
        OUT    PULONG  pReply,
        IN     PVOID   pMsg)
{
    PMON_HEADER     MonHeader;
    USHORT          Length = 0;
    DWORD           MonBuf, Rc;

    /*
     *  check legalty of BUFFER-In, Size of DataBuffer and Monitor state
     */

    if (!(MonBuf = FindMonitorBuffer(rwParms->MonBuffer, rwParms->ProcessId)) ||
        (MonBuf == -1L))
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonRead): unable to find buffer\n");
#endif

        return(ERROR_MON_INVALID_PARMS);
    }

    MonHeader = (PMON_HEADER)MonBuf;

    if (MonHeader->MonReg.In != rwParms->MonBuffer)
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonRead): illegal monitor buffer\n");
#endif

        return(ERROR_MON_INVALID_PARMS);
    }

    if (rwParms->Length < RWSize[MonHeader->DevType])
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonRead): buffer too small\n");
#endif

        return(ERROR_MON_BUFFER_TOO_SMALL);
    }

    if (MonHeader->MonStat != MON_STAT_REG)
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonRead): state not ok\n");
#endif

        //ASSERT(FALSE);

//        return(ERROR_MON_INVALID_PARMS);
    }

    /*
     *  read event if available
     */

    MonHeader->MonStat = MON_STAT_READ;

    Rc = GetMonInput(
                        RWSize[MonHeader->DevType],
                        (PKEY_EVENT_QUEUE)MonHeader,
                        rwParms,
                        pMsg,
                        pReply
                        );

    if ( *pReply != 0 )
    {
        MonHeader->MonStat = MON_STAT_REG;
    }

    return (Rc);
}


DWORD
MonWrite(IN  PMON_RW rwParms,
         OUT PULONG  pReply,
         IN  PVOID   pMsg)
{
    PMON_HEADER     MonHeader;
    USHORT          Length = 0;
    DWORD           MonBuf, Rc;

    UNREFERENCED_PARAMETER(pMsg);
    UNREFERENCED_PARAMETER(pReply);

    /*
     *  check legalty of BUFFER-Out, Size of DataBuffer and Monitor state
     */

    if (!(MonBuf = FindMonitorBuffer(rwParms->MonBuffer, rwParms->ProcessId)) ||
        (MonBuf == -1L))
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonWrite): unable to find buffer\n");
#endif

        return(ERROR_MON_INVALID_PARMS);
    }

    MonHeader = (PMON_HEADER)MonBuf;

    if (MonHeader->MonReg.Out != rwParms->MonBuffer)
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonWrite): illegal monitor buffer\n");
#endif

        return(ERROR_MON_INVALID_PARMS);
    }

    if (rwParms->Length < RWSize[MonHeader->DevType])
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonWrite): buffer too small\n");
#endif

        return(ERROR_MON_INVALID_PARMS);
    }

    if (rwParms->Length > RWSize[MonHeader->DevType])  // BUGBUG
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonWrite): buffer too big\n");
#endif

        return(ERROR_MON_DATA_TOO_LARGE);
    }

    if (MonHeader->MonStat == MON_STAT_OPEN)
    {
#if DBG
        IF_OD2_DEBUG( MON )
            DbgPrint("OS2SES(MonWrite): state not ok\n");
#endif

        return(ERROR_MON_INVALID_PARMS);
    }

    /*
     *  write event
     */

#if DBG
    IF_OD2_DEBUG( MON )
    {
        DbgPrint("OS2SES(MonWrite): (before) from queue %lx, to queue %lx\n",
            MonHeader, MonHeader->NextQueue );
    }
#endif

    Rc = PutMonInput(
                         RWSize[MonHeader->DevType],
                         (PKEY_EVENT_QUEUE)MonHeader->NextQueue,
                         1,
                         //rwParms,
                         (PKBD_MON_PACKAGE)&(rwParms->ioBuff[0]),
                         pMsg,
                         pReply);

    // BUGBUG if not enough place

    return( Rc );
}


DWORD
MonClose(IN  HANDLE   hMon)
{
    PMON_HEADER     NextMon, MonHeader = (PMON_HEADER)hMon;

    while (MonHeader)
    {
        NextMon = MonHeader->NextMon;
        MonQueueClose((HANDLE)MonHeader);
        MonHeader = NextMon;
    }

    return(0L);
}


DWORD
MonQueueClose(IN  HANDLE   hMon)
{
    PMON_HEADER     MonHeader = (PMON_HEADER)hMon;

    if (MonHeader->MonStat >= MON_STAT_REG)
    {
        /*
         * Monitor are reg - DeReg :
         * remove monitor & delete entried in table
         */

        RemoveMonitor(MonHeader, (PMON_HEADER *)
            ((MonHeader->DevType == KbdDevice) ?
            (PMON_HEADER *) &KbdMonQueue :
            (PMON_HEADER *) &MouMonQueue));

        DelMonitorBuffer(MonHeader);
    }

    /*
     * Free header from heap
     */

    HeapFree(HandleHeap, 0,
             (LPSTR)  MonHeader->MemoryStartAddress);

    return(0L);
}


DWORD
FindMonitorBuffer(IN  PVOID  Buffer,
                  IN  ULONG  ProcessId)
{
    ULONG       i, FreeCount = 0;

    for ( i = 0 ; i < MON_BUFFER_TABLE_SIZE ; i++ )
    {
        if ((MonBuffTable[i].Buffer == Buffer) &&
            (MonBuffTable[i].ProcessId == ProcessId))
        {
            return((DWORD)MonBuffTable[i].MonHeader);
        } else if (!MonBuffTable[i].Buffer)
        {
            FreeCount++;
        }

    }

    if (FreeCount < 2)
    {
        return((DWORD)-1L);           // no place for new 2 buffers
    }

    return(0L);
}


DWORD
AddMonitorBuffer(IN  PVOID        Buffer,
                 IN  PMON_HEADER  MonHeader,
                 IN  ULONG        ProcessId)
{
    ULONG       i, FindCount = 0;

    for ( i = 0 ; i < MON_BUFFER_TABLE_SIZE ; i++ )
    {
        if (!MonBuffTable[i].Buffer)
        {
            MonBuffTable[i].Buffer = Buffer;
            MonBuffTable[i].MonHeader = MonHeader;
            MonBuffTable[i].ProcessId = ProcessId;

            return((DWORD)MonBuffTable[i].MonHeader);
        }
    }

    ASSERT( FALSE );

    return(0L);
}


DWORD
DelMonitorBuffer(IN  PMON_HEADER  MonHeader)
{
    ULONG       i, FindCount = 0;

    for ( i = 0 ; i < MON_BUFFER_TABLE_SIZE ; i++ )
    {
        if (MonBuffTable[i].MonHeader == MonHeader)
        {
            RtlZeroMemory(&(MonBuffTable[i]), sizeof(MON_BUFFER_TABLE));
            FindCount++;
        }
    }

    ASSERT( FindCount == 2 );

    return(0L);
}


DWORD
NewKbdQueue(IN  PKEY_EVENT_QUEUE  NewKbdQueue)
{

    if (WaitForSingleObject( MonitorEvent, INFINITE ))
    {
        return(ERROR_MONITOR_NOT_SUPPORTED);
    }

    if (LastKbdMon != NULL)
    {
        LastKbdMon->MonHdr.NextQueue = (PMON_HEADER)NewKbdQueue;
    } else
        KbdMonQueue = NewKbdQueue;

    SetEvent( MonitorEvent );

    return(0L);
}


DWORD AddMonitor(IN  PMON_HEADER  NewMonHeader,
                 IN  PMON_HEADER  *pMonQueue)
{
    PMON_HEADER MonHeader, LastMonHeader = NULL;
    USHORT      Index;
#if DBG
    PMON_HEADER DbgMonHeader;
#endif

    /*
     * Positioning in chain
     * --------------------
     * 1st registered as FIRST
     *   ...
     * last registered as FIRST
     * last registered as DEFAULT
     *   ...
     * 1st registered as DEFAULT
     * last registered as END
     *   ...
     * 1st registered as END
     */

    if (NewMonHeader->MonReg.Pos > MONITOR_END)
    {
        /*
         * ignore MONITOR_SPECIAL
         */

        NewMonHeader->MonReg.Pos -= 3;
        NewMonHeader->Flag = 1;
    }

    /*
     * Translate Position:
     *       FIRST = 0
     *       DEFAULT = 1
     *       END = 2
     *       device (kbd/mouse) = 3
     *
     *  when looking for the place, DEFAULT is assign also to FIRST
     */

    if (NewMonHeader->MonReg.Pos < MONITOR_END)
    {
        /*
         * XOR MONITOR_FIRST & MONITOR_DEFAULT
         */

        NewMonHeader->MonReg.Pos = 1 - NewMonHeader->MonReg.Pos;
    }

    Index = (USHORT)NewMonHeader->MonReg.Pos;

    if (Index == 0)
    {
        Index = 1;          // last FIRST is equivalent to 1st DEFAULT
    }

    if (WaitForSingleObject( MonitorEvent, INFINITE ))
    {
        return(ERROR_MONITOR_NOT_SUPPORTED);
    }

    MonHeader = *pMonQueue;

    /*
     *  find the place in chain
     */

    while (MonHeader->MonReg.Pos < (ULONG)Index)
    {
        LastMonHeader = MonHeader;
        MonHeader = MonHeader->NextQueue;

    }

    NewMonHeader->NextQueue = MonHeader;

    if (LastMonHeader == NULL)
    {
        NewMonHeader->NextQueue = *pMonQueue;
        *pMonQueue = NewMonHeader;
    } else
    {
        NewMonHeader->NextQueue = LastMonHeader->NextQueue;
        LastMonHeader->NextQueue = NewMonHeader;
    }

    if ((MonHeader->MonReg.Pos == 3) &&      // we add the last queue in chain for Kbd
        (*pMonQueue == (PMON_HEADER)KbdMonQueue ))
    {
        LastKbdMon = (PKEY_EVENT_QUEUE)NewMonHeader;
    }

    SetEvent( MonitorEvent );

#if DBG
    DbgMonHeader = *pMonQueue;

    IF_OD2_DEBUG( MON )
    {
        while (DbgMonHeader->NextQueue)
        {
            DbgPrint("OS2SES(AddMonitor): Current %lx, next %lx\n", DbgMonHeader, DbgMonHeader->NextQueue);

            DbgMonHeader = DbgMonHeader->NextQueue;
        }

        DbgPrint("OS2SES(MonReg): %lx ... %lx, (%lx) %lx, %lx (%lx) ... %lx, %lx\n",
            KbdMonQueue, LastMonHeader,
            (LastMonHeader) ? LastMonHeader->NextQueue : NULL,
            NewMonHeader, NewMonHeader->NextQueue, MonHeader, LastKbdMon, KbdQueue);
    }
#endif

    return(0L);
}


DWORD
RemoveMonitor(IN  PMON_HEADER  OldMonHeader,
              IN  PMON_HEADER  *pMonQueue)
{
    PMON_HEADER MonHeader, LastMonHeader = NULL;

    if (WaitForSingleObject( MonitorEvent, INFINITE ))
    {
        return(ERROR_MONITOR_NOT_SUPPORTED);
    }

    MonHeader = *pMonQueue;

    /*
     *  find the place in chain
     */

    while (MonHeader != NULL && MonHeader != OldMonHeader)
    {
        LastMonHeader = MonHeader;
        MonHeader = MonHeader->NextQueue;
    }

    if (MonHeader == NULL)
    {
        return(0);
    }

    if (LastMonHeader == NULL)
    {
        *pMonQueue = MonHeader->NextQueue;
    } else
        LastMonHeader->NextQueue = MonHeader->NextQueue;

    if ((OldMonHeader->NextQueue->MonReg.Index == 3) &&      // we remove the last queue in chain for Kbd
        (*pMonQueue == (PMON_HEADER)KbdMonQueue ))
    {
        if (LastMonHeader == NULL)
        {
            LastKbdMon = NULL;
        } else
            LastKbdMon = (PKEY_EVENT_QUEUE)LastMonHeader;
    }

    SetEvent( MonitorEvent );

    return(0L);
}