i_opencbm.c

Go to the documentation of this file.

/*
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 *
 *  Copyright 1999-2001 Michael Klein <michael(dot)klein(at)puffin(dot)lb(dot)shuttle(dot)de>
 *  Copyright 2001-2004, 2007-2009, 2011 Spiro Trikaliotis
 *
 *  Parts are Copyright
 *      Jouko Valta <jopi(at)stekt(dot)oulu(dot)fi>
 *      Andreas Boose <boose(at)linux(dot)rz(dot)fh-hannover(dot)de>
*/

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

#define DBG_USERMODE

#ifndef DBG_PROGNAME
    #define DBG_PROGNAME "OPENCBM-XA1541.DLL"
#endif // #ifndef DBG_PROGNAME

#include "debug.h"

#include <winioctl.h>
#include "cbmioctl.h"

#include <stdlib.h>
#include <stddef.h>

#include "i_opencbm.h"

#include "version.h"

#define OPENCBM_PLUGIN 
#include "archlib.h"


/*-------------------------------------------------------------------*/
/*--------- REGISTRY FUNCTIONS --------------------------------------*/

static int
cbm_get_default_port(VOID)
{
    DWORD ret;
    HKEY regKey;

    FUNC_ENTER();

    DBG_PPORT((DBG_PREFIX "cbm_get_default_port()"));

    // Open a registry key to HKLM<%REGKEY_SERVICE%>

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                     CBM_REGKEY_SERVICE,
                     0,
                     KEY_QUERY_VALUE,
                     &regKey)
       )
    {
        DBG_WARN((DBG_PREFIX "RegOpenKeyEx() failed!"));
        FUNC_LEAVE_BOOL(FALSE);
    }

    // now, get the number of the port to use

    if (RegGetDWORD(regKey, CBM_REGKEY_SERVICE_DEFAULTLPT, &ret) != ERROR_SUCCESS)
    {
        DBG_WARN((DBG_PREFIX "No " CBM_REGKEY_SERVICE "\\" CBM_REGKEY_SERVICE_DEFAULTLPT 
            " value, setting 0."));
        ret = 0;
    }

    // We're done, close the registry handle.

    RegCloseKey(regKey);

    DBG_PPORT((DBG_PREFIX "RETURN: cbm_get_default_port() == %u", ret));

    FUNC_LEAVE_INT(ret);
}

/*-------------------------------------------------------------------*/
/*--------- ASYNCHRONOUS IO FUNCTIONS -------------------------------*/

static HANDLE CancelEvent = NULL;
static HANDLE CancelCallbackEvent = NULL;
static ULONG  InCancellableState  = 0;

VOID
WaitForIoCompletionInit(VOID)
{
    FUNC_ENTER();

    //
    // Create the events for prematurely cancelling I/O request
    //

    CancelEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    DBG_ASSERT(CancelEvent != NULL);

    CancelCallbackEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    DBG_ASSERT(CancelCallbackEvent != NULL);

    FUNC_LEAVE();
}

VOID
WaitForIoCompletionDeinit(VOID)
{
    FUNC_ENTER();

    //
    // Delete the event which is used for prematurely 
    // cancelling I/O request
    //
    if (CancelEvent != NULL)
        CloseHandle(CancelEvent);

    FUNC_LEAVE();
}

VOID
WaitForIoCompletionCancelAll(VOID)
{
    FUNC_ENTER();

    if (InterlockedExchange(&InCancellableState, 0) != 0)
    {
        //
        // signal the event which is used for prematurely 
        // cancelling I/O request
        //

        SetEvent(CancelEvent);

        //
        // Wait to be signalled that the current I/O request
        // has been cancelled.
        //

        WaitForSingleObject(CancelCallbackEvent, INFINITE);
    }

    FUNC_LEAVE();
}

VOID
WaitForIoCompletionConstruct(LPOVERLAPPED Overlapped)
{
    FUNC_ENTER();

    memset(Overlapped, 0, sizeof(*Overlapped));
    Overlapped->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

    DBG_ASSERT(Overlapped->hEvent != NULL);

    FUNC_LEAVE();
}

BOOL
WaitForIoCompletion(BOOL Result, CBM_FILE HandleDevice, LPOVERLAPPED Overlapped, DWORD *BytesTransferred)
{
    BOOL result = Result;
    HANDLE handleList[2] = { CancelEvent, Overlapped->hEvent };

    FUNC_ENTER();

    DBG_ASSERT(Overlapped != NULL);
    DBG_ASSERT(BytesTransferred != NULL);

    if (!Result)
    {
        // deal with the error code 
        switch (GetLastError()) 
        { 
            case ERROR_IO_PENDING:
            {
                int tmp;

                //
                // Make sure WaitForIoCompletionCancelAll() knows it has to signal us
                //

                tmp = InterlockedExchange(&InCancellableState, 1);
                DBG_ASSERT(tmp == 0);

                //
                // wait for the operation to finish
                //

                if (WaitForMultipleObjects(2, handleList, FALSE, INFINITE) == WAIT_OBJECT_0)
                {
                    CancelIo(HandleDevice);

                    // we are told to cancel this event
                    *BytesTransferred = 0;
                    result = FALSE;
                    SetEvent(CancelCallbackEvent);
                }
                else
                {
                    //
                    // WaitForIoCompletionCancelAll() does not need to alert us anymore
                    //

                    if (InterlockedExchange(&InCancellableState, 0) == 0)
                    {
                        //
                        // In case we were signalled, make sure 
                        // WaitForIoCompletionCancelAll() does not hang
                        //

                        SetEvent(CancelCallbackEvent);
                    }

                    // check on the results of the asynchronous read 
                    result = GetOverlappedResult(HandleDevice, Overlapped, 
                        BytesTransferred, FALSE) ; 
                }
                break;
            }
         }
    }

    CloseHandle(Overlapped->hEvent);

    FUNC_LEAVE_BOOL(result ? TRUE : FALSE);
}

/*-------------------------------------------------------------------*/
/*--------- OPENCBM ARCH FUNCTIONS ----------------------------------*/

const char * CBMAPIDECL
opencbm_plugin_get_driver_name(const char * const Port)
{
    static char driverName[] = "\\\\.\\opencbm0";
    char *ret;

    int portNumber = 0;

    FUNC_ENTER();

    ret = NULL;

    if (Port != NULL)
    {
        portNumber = strtoul(Port, NULL, 10);
    }

    if (portNumber <= 10)
    {
        if (portNumber == 0)
        {
            // PortNumber 0 has special meaning: Find out the default value

            portNumber = cbm_get_default_port();
        }

        driverName[strlen(driverName)-1] = (portNumber ? portNumber-1 : 0) + '0';
        ret = driverName;
    }

    FUNC_LEAVE_STRING(ret);
}

int CBMAPIDECL
opencbm_plugin_driver_open(CBM_FILE *HandleDevice, const char * const Port)
{
    const char *driverName;

    FUNC_ENTER();

    // Get the name of the driver to be opened

    driverName = opencbm_plugin_get_driver_name(Port);

    if (driverName == NULL)
    {
        // there was a problem, thus, fail this call!

        *HandleDevice = INVALID_HANDLE_VALUE;
    }
    else 
    {
        // Open the device

        *HandleDevice = CreateFile(driverName,
            GENERIC_READ | GENERIC_WRITE, // we need read and write access
            0,
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
            NULL);
    }

    DBG_ASSERT(*HandleDevice != INVALID_HANDLE_VALUE);

    FUNC_LEAVE_INT(*HandleDevice == INVALID_HANDLE_VALUE);
}

void CBMAPIDECL
opencbm_plugin_driver_close(CBM_FILE HandleDevice)
{
    FUNC_ENTER();

    DBG_ASSERT(HandleDevice != 0);

    CloseHandle(HandleDevice);

    FUNC_LEAVE();
}

BOOL 
cbm_ioctl(IN CBM_FILE HandleDevice, IN DWORD ControlCode, 
#if DBG
          IN char *TextControlCode, 
#endif // #if DBG
          IN PVOID InBuffer, IN ULONG InBufferSize, OUT PVOID OutBuffer, IN ULONG OutBufferSize)
{
    OVERLAPPED overlapped;
    DWORD dwBytesReturned;

    BOOL returnValue;

    FUNC_ENTER();

    WaitForIoCompletionConstruct(&overlapped);

    // Perform the IOCTL

    returnValue = DeviceIoControl(HandleDevice, ControlCode, InBuffer, InBufferSize,
        OutBuffer, OutBufferSize, &dwBytesReturned, &overlapped);

    returnValue = WaitForIoCompletion(returnValue, HandleDevice, &overlapped, &dwBytesReturned);

    // If an error occurred, output it (in the DEBUG version of this file

    if (!returnValue)
    {
        DBG_ERROR((DBG_PREFIX "%s: Error code = %u", TextControlCode, GetLastError()));
    }
    else
    {
        // Check if the number of bytes returned equals the wanted number

        if (dwBytesReturned != OutBufferSize) 
        {
            DBG_WARN((DBG_PREFIX "%s: OutBufferSize = %u, but dwBytesReturned = %u",
                TextControlCode, OutBufferSize, dwBytesReturned));
        }
    }

    FUNC_LEAVE_BOOL(returnValue);
}

/*-------------------------------------------------------------------*/
/*--------- DEVICE DRIVER HANDLING FUNCTIONS  -----------------------*/


BOOL
cbm_driver_start(VOID)
{
    SC_HANDLE schManager;
    SC_HANDLE schService;
    DWORD err;
    BOOL ret;

    FUNC_ENTER();

    ret = TRUE;

    schManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);

    if (schManager == NULL)
    {
       DBG_ERROR((DBG_PREFIX "Could not open service control manager!"));
       FUNC_LEAVE_BOOL(FALSE);
    }

    schService = OpenService(schManager, OPENCBM_DRIVERNAME, SERVICE_ALL_ACCESS);

    if (schService == NULL)
    {
        DBG_ERROR((DBG_PREFIX "OpenService (0x%02x)", GetLastError()));
        FUNC_LEAVE_BOOL(FALSE);
    }

    ret = StartService(schService, 0, NULL);

    if (ret)
    {
        DBG_SUCCESS((DBG_PREFIX "StartService"));
    }
    else
    {
        err = GetLastError();

        if (err == ERROR_SERVICE_ALREADY_RUNNING)
        {
            /* If the service is already running, don't treat it
             * as an error, but as a warning, and report success!
             */

            DBG_WARN((DBG_PREFIX "StartService, (ERROR_SERVICE_ALREADY_RUNNING)"));

            ret = TRUE;
        }
        else
        {
            DBG_ERROR((DBG_PREFIX "StartService (0x%02x)", err));
        }
    }

    CloseServiceHandle(schService);

    // Close the SCM: We don't need it anymore

    CloseServiceHandle(schManager);

    FUNC_LEAVE_BOOL(ret);
}


BOOL
cbm_driver_stop(VOID)
{
    SERVICE_STATUS  serviceStatus;
    SC_HANDLE schManager;
    SC_HANDLE schService;
    BOOL ret;

    FUNC_ENTER();

    schManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);

    schService = OpenService(schManager, OPENCBM_DRIVERNAME, SERVICE_ALL_ACCESS);

    if (schManager == NULL)
    {
       DBG_ERROR((DBG_PREFIX "Could not open service control manager!"));
       FUNC_LEAVE_BOOL(FALSE);
    }

    if (schService == NULL)
    {
        DBG_ERROR((DBG_PREFIX "OpenService (0x%02x)", GetLastError()));
        FUNC_LEAVE_BOOL(FALSE);
    }

    ret = ControlService(schService, SERVICE_CONTROL_STOP, &serviceStatus);

    if (ret)
    {
        DBG_SUCCESS((DBG_PREFIX "ControlService"));
    }
    else
    {
        DBG_ERROR((DBG_PREFIX "ControlService (0x%02x)", GetLastError()));
    }

    CloseServiceHandle(schService);

    // Close the SCM: We don't need it anymore

    CloseServiceHandle(schManager);

    FUNC_LEAVE_BOOL(ret);
}

BOOL
cbm_driver_install(OUT PULONG Buffer, IN ULONG BufferLen)
{
    PCBMT_I_INSTALL_OUT outBuffer;
    CBM_FILE HandleDevice;

    FUNC_ENTER();

    DBG_ASSERT(Buffer != NULL);
    DBG_ASSERT(BufferLen >= sizeof(ULONG));

    outBuffer = (PCBMT_I_INSTALL_OUT) Buffer;

    DBG_ASSERT(outBuffer != NULL);

    if (opencbm_plugin_driver_open(&HandleDevice, 0) == 0)
    {
        outBuffer->ErrorFlags = CBM_I_DRIVER_INSTALL_0_IOCTL_FAILED;
        cbm_ioctl(HandleDevice, CBMCTRL(I_INSTALL), NULL, 0, Buffer, BufferLen);
        opencbm_plugin_driver_close(HandleDevice);
    }
    else
    {
        outBuffer->ErrorFlags = CBM_I_DRIVER_INSTALL_0_FAILED;
        DBG_ERROR((DBG_PREFIX "Driver could not be openend"));
    }

    // if there is room in the given buffer, set the dll version

    if (BufferLen >= sizeof(outBuffer->DllVersion) + offsetof(CBMT_I_INSTALL_OUT, DllVersion))
    {
        outBuffer->DllVersion =
            CBMT_I_INSTALL_OUT_MAKE_VERSION(OPENCBM_VERSION_MAJOR, OPENCBM_VERSION_MINOR,
                                            OPENCBM_VERSION_SUBMINOR, OPENCBM_VERSION_DEVEL);
    }

    // if there is even room for the dll version extension, set the dll version extension

    if (BufferLen >= sizeof(outBuffer->DllVersionEx) + offsetof(CBMT_I_INSTALL_OUT, DllVersionEx))
    {
        outBuffer->DllVersionEx =
            CBMT_I_INSTALL_OUT_MAKE_VERSION_EX(OPENCBM_VERSION_PATCHLEVEL);
    }

    FUNC_LEAVE_INT(
        (  (outBuffer->ErrorFlags != CBM_I_DRIVER_INSTALL_0_IOCTL_FAILED)
        && (outBuffer->ErrorFlags != CBM_I_DRIVER_INSTALL_0_FAILED)
        ) ? FALSE : TRUE);
}

BOOL
IsDriverStartedAutomatically(VOID)
{
    DWORD ret;
    BOOL automaticStart;
    HKEY regKey;

    FUNC_ENTER();

    automaticStart = FALSE;

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                     CBM_REGKEY_SERVICE,
                     0,
                     KEY_QUERY_VALUE,
                     &regKey)
       )
    {
        DBG_WARN((DBG_PREFIX "RegOpenKeyEx() failed!"));
        FUNC_LEAVE_BOOL(FALSE);
    }

    // now, get the number of the port to use

    if (RegGetDWORD(regKey, "Start", &ret) != ERROR_SUCCESS)
    {
        DBG_ERROR((DBG_PREFIX "No " CBM_REGKEY_SERVICE "\\Start value!"));
    }
    else
    {
        if (ret == SERVICE_AUTO_START)
        {
            automaticStart = TRUE;
        }
    }

    // We're done, close the registry handle.

    RegCloseKey(regKey);

    FUNC_LEAVE_BOOL(automaticStart);
}