starting mouse class driver Win NT

I am working on a windows NT 4.0 workstation where the mouse class driver startup is set to manual ( for a good reason ) rather than system.
I wish to start the mouse class driver programmatically. Can anyone let me know how ? I use Borland C++ Builder 4.0 enterprise edition.
Thanks - Roger
LVL 2
Roger AlcindorAsked:
Who is Participating?
I wear a lot of hats...

"The solutions and answers provided on Experts Exchange have been extremely helpful to me over the last few years. I wear a lot of hats - Developer, Database Administrator, Help Desk, etc., so I know a lot of things but not a lot about one thing. Experts Exchange gives me answers from people who do know a lot about one thing, in a easy to use platform." -Todd S.

jkrCommented:
Kernel mode drivers can be treated like regular Win32 services...

Use

void    StartService        (   LPCTSTR             pszName,
                                int                 argc,
                                const wchar_t**     argv
                            )
{
    SC_HANDLE   schService;
    SC_HANDLE   schSCManager;

    schSCManager    =   OpenSCManager   (   NULL,                   // machine (NULL == local)
                                            NULL,                   // database (NULL == default)
                                            SC_MANAGER_ALL_ACCESS   // access required
                                        );
    if  (   schSCManager)
        {
            schService  =   OpenService (   schSCManager,
                                            pszName,
                                            SERVICE_ALL_ACCESS
                                        );

            if  (   schService)
                {
                    // try to start the service
                    if  (   StartService    (   schService,
                                                argc,
                                                argv
                                            )
                        )
                        {
                            wprintf (   TEXT    (   "Starting %s."),
                                        pszName
                                    );

                            Sleep   (   1000 );

                            while   (   QueryServiceStatus  (   schService,
                                                                &g_ssStatus
                                                            )
                                    )
                                    {
                                        if  (       SERVICE_START_PENDING   
                                                ==  g_ssStatus.dwCurrentState
                                            )
                                            {
                                                wprintf (   TEXT    (   "."));
                                                Sleep( 1000 );
                                            }
                                        else
                                                break;
                                    }

                            if  (   SERVICE_RUNNING ==  g_ssStatus.dwCurrentState)
                                    wprintf (   TEXT    (   "\n%s started.\n"),
                                                pszName
                                            );
                            else
                                    wprintf (   TEXT    (   "\n%s failed to start.\n"),
                                                pszName
                                            );

                        }

                CloseServiceHandle  (   schService);
            }
            else
                wprintf (   TEXT    (   "OpenService failed - %s\n"),
                            GetLastErrorText    (   g_szErr,    ERROR_BUFSZ)
                        );

            CloseServiceHandle  (   schSCManager);
        }
    else
            wprintf (   TEXT    (   "OpenSCManager failed - %s\n"),
                        GetLastErrorText    (   g_szErr,    ERROR_BUFSZ)
                    );
}

and provide 'mouclass' as the pszName parameter.

Feel free to ask if you encounter problems!
0

Experts Exchange Solution brought to you by

Your issues matter to us.

Facing a tech roadblock? Get the help and guidance you need from experienced professionals who care. Ask your question anytime, anywhere, with no hassle.

Start your 7-day free trial
jkrCommented:
BTW: Here's another sample how to programmatically load a driver at runtime - it's part of the 'filemon' source code available on www.sysinternals.com

/******************************************************************************
*
*       FileMon - File System Monitor for Windows NT/9x
*            
*            Copyright (c) 1996 Mark Russinovich and Bryce Cogswell
*
*            See readme.txt for terms and conditions.
*
*          PROGRAM: Instdrv.c
*
*          PURPOSE: Loads and unloads the Filemon device driver. This code
*            is taken from the instdrv example in the NT DDK.
*
******************************************************************************/
#include <windows.h>
#include <stdlib.h>
#include <string.h>


/****************************************************************************
*
*    FUNCTION: InstallDriver( IN SC_HANDLE, IN LPCTSTR, IN LPCTSTR)
*
*    PURPOSE: Creates a driver service.
*
****************************************************************************/
BOOL InstallDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName, IN LPCTSTR ServiceExe )
{
    SC_HANDLE  schService;

    //
    // NOTE: This creates an entry for a standalone driver. If this
    //       is modified for use with a driver that requires a Tag,
    //       Group, and/or Dependencies, it may be necessary to
    //       query the registry for existing driver information
    //       (in order to determine a unique Tag, etc.).
    //

    schService = CreateService( SchSCManager,          // SCManager database
                                DriverName,           // name of service
                                DriverName,           // name to display
                                SERVICE_ALL_ACCESS,    // desired access
                                SERVICE_KERNEL_DRIVER, // service type
                                SERVICE_DEMAND_START,  // start type
                                SERVICE_ERROR_NORMAL,  // error control type
                                ServiceExe,            // service's binary
                                NULL,                  // no load ordering group
                                NULL,                  // no tag identifier
                                NULL,                  // no dependencies
                                NULL,                  // LocalSystem account
                                NULL                   // no password
                                );
    if ( schService == NULL )
        return FALSE;

    CloseServiceHandle( schService );

    return TRUE;
}


/****************************************************************************
*
*    FUNCTION: StartDriver( IN SC_HANDLE, IN LPCTSTR)
*
*    PURPOSE: Starts the driver service.
*
****************************************************************************/
BOOL StartDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
{
    SC_HANDLE  schService;
    BOOL       ret;

    schService = OpenService( SchSCManager,
                              DriverName,
                              SERVICE_ALL_ACCESS
                              );
    if ( schService == NULL )
        return FALSE;

    ret = StartService( schService, 0, NULL )
       || GetLastError() == ERROR_SERVICE_ALREADY_RUNNING;

    CloseServiceHandle( schService );

    return ret;
}



/****************************************************************************
*
*    FUNCTION: OpenDevice( IN LPCTSTR, HANDLE *)
*
*    PURPOSE: Opens the device and returns a handle if desired.
*
****************************************************************************/
BOOL OpenDevice( IN LPCTSTR DriverName, HANDLE * lphDevice )
{
    TCHAR    completeDeviceName[64];
    HANDLE   hDevice;

    //
    // Create a \\.\XXX device name that CreateFile can use
    //
    // NOTE: We're making an assumption here that the driver
    //       has created a symbolic link using it's own name
    //       (i.e. if the driver has the name "XXX" we assume
    //       that it used IoCreateSymbolicLink to create a
    //       symbolic link "\DosDevices\XXX". Usually, there
    //       is this understanding between related apps/drivers.
    //
    //       An application might also peruse the DEVICEMAP
    //       section of the registry, or use the QueryDosDevice
    //       API to enumerate the existing symbolic links in the
    //       system.
    //

    wsprintf( completeDeviceName, TEXT("\\\\.\\%s"), DriverName );

    hDevice = CreateFile( completeDeviceName,
                          GENERIC_READ | GENERIC_WRITE,
                          0,
                          NULL,
                          OPEN_EXISTING,
                          FILE_ATTRIBUTE_NORMAL,
                          NULL
                          );
    if ( hDevice == ((HANDLE)-1) )
        return FALSE;

      // If user wants handle, give it to them.  Otherwise, just close it.
      if ( lphDevice )
            *lphDevice = hDevice;
      else
          CloseHandle( hDevice );

    return TRUE;
}



/****************************************************************************
*
*    FUNCTION: StopDriver( IN SC_HANDLE, IN LPCTSTR)
*
*    PURPOSE: Has the configuration manager stop the driver (unload it)
*
****************************************************************************/
BOOL StopDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
{
    SC_HANDLE       schService;
    BOOL            ret;
    SERVICE_STATUS  serviceStatus;

    schService = OpenService( SchSCManager, DriverName, SERVICE_ALL_ACCESS );
    if ( schService == NULL )
        return FALSE;

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

    CloseServiceHandle( schService );

    return ret;
}


/****************************************************************************
*
*    FUNCTION: RemoveDriver( IN SC_HANDLE, IN LPCTSTR)
*
*    PURPOSE: Deletes the driver service.
*
****************************************************************************/
BOOL RemoveDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
{
    SC_HANDLE  schService;
    BOOL       ret;

    schService = OpenService( SchSCManager,
                              DriverName,
                              SERVICE_ALL_ACCESS
                              );

    if ( schService == NULL )
        return FALSE;

    ret = DeleteService( schService );

    CloseServiceHandle( schService );

    return ret;
}


/****************************************************************************
*
*    FUNCTION: UnloadDeviceDriver( const TCHAR *)
*
*    PURPOSE: Stops the driver and has the configuration manager unload it.
*
****************************************************************************/
BOOL UnloadDeviceDriver( const TCHAR * Name )
{
      SC_HANDLE      schSCManager;

      schSCManager = OpenSCManager(      NULL,                 // machine (NULL == local)
                                          NULL,                 // database (NULL == default)
                                                      SC_MANAGER_ALL_ACCESS // access required
                                                );

      StopDriver( schSCManager, Name );
      RemoveDriver( schSCManager, Name );
      
      CloseServiceHandle( schSCManager );

      return TRUE;
}



/****************************************************************************
*
*    FUNCTION: LoadDeviceDriver( const TCHAR, const TCHAR, HANDLE *)
*
*    PURPOSE: Registers a driver with the system configuration manager
*       and then loads it.
*
****************************************************************************/
BOOL LoadDeviceDriver( const TCHAR * Name, const TCHAR * Path, HANDLE * lphDevice )
{
      SC_HANDLE      schSCManager;
      BOOL            okay;

      schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );

      // Remove previous instance
      RemoveDriver( schSCManager, Name );

      // Ignore success of installation: it may already be installed.
      InstallDriver( schSCManager, Name, Path );

      // Ignore success of start: it may already be started.
      StartDriver( schSCManager, Name );

      // Do make sure we can open it.
      okay = OpenDevice( Name, lphDevice );

       CloseServiceHandle( schSCManager );

      return okay;
}
0
Roger AlcindorAuthor Commented:
Adjusted points to 200
0
Roger AlcindorAuthor Commented:
Thanks for the answer jkr and also comments.
Will take you up on your offer of help if needed.

Roger
0
It's more than this solution.Get answers and train to solve all your tech problems - anytime, anywhere.Try it for free Edge Out The Competitionfor your dream job with proven skills and certifications.Get started today Stand Outas the employee with proven skills.Start learning today for free Move Your Career Forwardwith certification training in the latest technologies.Start your trial today
Microsoft Development

From novice to tech pro — start learning today.