Windows/cdenable/ntcd.cpp

/*
 *  ntcd.cpp - Interface to cdenable.sys driver
 *
 *  Basilisk II (C) 1997-2008 Christian Bauer
 *
 *  Windows platform specific code copyright (C) Lauri Pesonen
 *
 *  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.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"
#include <windows.h>

extern "C" {

#include <winioctl.h>
#include <winsvc.h>
#include "ntcd.h"
#include "cdenable.h"

static char *sDriverShort   = "cdenable";
static char *sDriverLong  = "System32\\Drivers\\cdenable.sys";
static char *sCompleteName  = "\\\\.\\cdenable";

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// Start type must be SERVICE_AUTO_START or lower, in order
// it to start automatically and allow the mechanism work
// for users with no admin rights.
static BOOL InstallDriver(
  IN SC_HANDLE  SchSCManager,
  IN LPCTSTR    DriverName,
  IN LPCTSTR    ServiceExe
)
{
  SC_HANDLE  schService;
  DWORD      err;

  schService = CreateService (
                SchSCManager,          // SCManager database
    DriverName,            // name of service
    DriverName,            // name to display
    SERVICE_ALL_ACCESS,    // desired access
    SERVICE_KERNEL_DRIVER, // service type
                SERVICE_AUTO_START,              // 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) {
      err = GetLastError();
      if (err == ERROR_SERVICE_EXISTS) {
                                  return TRUE;
      } else {
                      return FALSE;
      }
  }
  CloseServiceHandle (schService);
  return TRUE;
}

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

static BOOL StartDriver(
  IN SC_HANDLE  SchSCManager,
  IN LPCTSTR    DriverName
) {
  SC_HANDLE  schService;
  BOOL       ret;
  DWORD      err;

  schService = OpenService (SchSCManager,
                            DriverName,
                            SERVICE_ALL_ACCESS
                            );
  if (schService == NULL) return FALSE;
  ret = StartService (schService,    // service identifier
                      0,             // number of arguments
                      NULL           // pointer to arguments
                      );
  if(ret == 0) {
    err = GetLastError();
    if (err == ERROR_SERVICE_ALREADY_RUNNING) {
                        ret = TRUE;
    } else {
                        ret = FALSE;
                }
  }
  CloseServiceHandle (schService);
  return ret;
}

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

static BOOL __cdecl start_driver( void )
{
        SC_HANDLE   schSCManager;
        BOOL ret = FALSE;

        schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
        if(!schSCManager) return(FALSE);
        if(!InstallDriver( schSCManager, sDriverShort, sDriverLong )) {
                CloseServiceHandle( schSCManager );
                return(FALSE);
        }
        ret = StartDriver( schSCManager, sDriverShort );
        if(!ret) {
                (void)RemoveDriver( schSCManager, sDriverShort );
        }
        CloseServiceHandle( schSCManager );
        return( ret );
}

static BOOL __cdecl stop_driver( void )
{
        SC_HANDLE   schSCManager;
        BOOL ret = FALSE;

        schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
        if(!schSCManager) return(FALSE);
        if(StopDriver( schSCManager, sDriverShort )) ret = TRUE;
        CloseServiceHandle( schSCManager );
        return( ret );
}

static BOOL __cdecl remove_driver( void )
{
        SC_HANDLE   schSCManager;
        BOOL ret = FALSE;

        schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
        if(!schSCManager) return(FALSE);
        if(RemoveDriver( schSCManager, sDriverShort )) ret = TRUE;
        CloseServiceHandle( schSCManager );
        return( ret );
}


// Exported stuff begins

int CdenableSysReadCdBytes( HANDLE h, DWORD start, DWORD count, char *buf )
{
  HANDLE   hDevice;
  int      ret;
        DWORD            nb;
        DWORD    in_buffer[10];
        DWORD    out_buffer[10];

  ret = 0;

        in_buffer[0] = (DWORD)h;
        in_buffer[1] = (DWORD)start;
        in_buffer[2] = (DWORD)count;
        in_buffer[3] = (DWORD)buf;
        out_buffer[0] = 0;

  hDevice = CreateFile (sCompleteName,
                        GENERIC_READ | GENERIC_WRITE,
                        0,
                        NULL,
                        OPEN_EXISTING,
                        FILE_ATTRIBUTE_NORMAL,
                        NULL
                        );

  if (hDevice == ((HANDLE)-1)) {
    ret = 0;
        } else {
                if ( DeviceIoControl(   hDevice,
                                        IOCTL_CDENABLE_READ,
                                        (LPVOID)in_buffer, 16,
                                        (LPVOID)out_buffer, 4,
                                        &nb, NULL ) )
                {
                        if(out_buffer[0] != 0) ret = count;
                }
    CloseHandle (hDevice);
  }

  return ret;
}

int CdenableSysReadCdSectors( HANDLE h, DWORD start, DWORD count, char *buf )
{
        return( CdenableSysReadCdBytes( h, (start<<11), (count<<11), buf ) );
}

int CdenableSysWriteCdBytes( HANDLE h, DWORD start, DWORD count, char *buf )
{
        return( 0 );

        /*
  HANDLE   hDevice;
  int      ret;
        DWORD            nb;
        DWORD    in_buffer[10];
        DWORD    out_buffer[10];

  ret = 0;

        in_buffer[0] = (DWORD)h;
        in_buffer[1] = (DWORD)start;
        in_buffer[2] = (DWORD)count;
        in_buffer[3] = (DWORD)buf;
        out_buffer[0] = 0;

  hDevice = CreateFile (sCompleteName,
                        GENERIC_READ | GENERIC_WRITE,
                        0,
                        NULL,
                        OPEN_EXISTING,
                        FILE_ATTRIBUTE_NORMAL,
                        NULL
                        );

  if (hDevice == ((HANDLE)-1)) {
    ret = 0;
        } else {
                if ( DeviceIoControl(   hDevice,
                                        IOCTL_CDENABLE_WRITE,
                                        (LPVOID)in_buffer, 16,
                                        (LPVOID)out_buffer, 4,
                                        &nb, NULL ) )
                {
                        if(out_buffer[0] != 0) ret = count;
                }
    CloseHandle (hDevice);
  }

  return ret;
        */
}

int CdenableSysWriteCdSectors( HANDLE h, DWORD start, DWORD count, char *buf )
{
        // return( CdenableSysWriteCdBytes( h, (start<<11), (count<<11), buf ) );
        return( 0 );
}

BOOL CdenableSysInstallStart(void)
{
        return(start_driver());
}

void CdenableSysStopRemove(void)
{
        stop_driver();
        remove_driver();
}

DWORD CdenableSysGetVersion( void )
{
  HANDLE   hDevice;
  DWORD    ret;
        DWORD            nb;
        DWORD    out_buffer[10];

  ret = 0;
        out_buffer[0] = 0;
  hDevice = CreateFile (sCompleteName,
                        GENERIC_READ | GENERIC_WRITE,
                        0,
                        NULL,
                        OPEN_EXISTING,
                        FILE_ATTRIBUTE_NORMAL,
                        NULL
                        );
  if (hDevice == ((HANDLE)-1)) {
    ret = 0;
        } else {
                if ( DeviceIoControl(   hDevice,
                                        IOCTL_CDENABLE_GET_VERSION,
                                        NULL, 0,
                                        (LPVOID)out_buffer, 4,
                                        &nb, NULL ) )
                {
                        ret = out_buffer[0];
                }
    CloseHandle (hDevice);
  }
  return ret;
}

#ifdef __cplusplus
} //extern "C"
#endif

Revision:	1.4
Committed:	2008-01-01T09:40:34Z (16 years, 10 months ago) by gbeauche
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.3:	+1 -1 lines
Log Message:	Happy New Year!
#	Content
1	/*
2	* ntcd.cpp - Interface to cdenable.sys driver
3	*
4	* Basilisk II (C) 1997-2008 Christian Bauer
5	*
6	* Windows platform specific code copyright (C) Lauri Pesonen
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21	*/
22
23	#include "sysdeps.h"
24	#include <windows.h>
25
26	extern "C" {
27
28	#include <winioctl.h>
29	#include <winsvc.h>
30	#include "ntcd.h"
31	#include "cdenable.h"
32
33	static char *sDriverShort = "cdenable";
34	static char *sDriverLong = "System32\\Drivers\\cdenable.sys";
35	static char *sCompleteName = "\\\\.\\cdenable";
36
37	#ifdef _DEBUG
38	#define new DEBUG_NEW
39	#undef THIS_FILE
40	static char THIS_FILE[] = __FILE__;
41	#endif
42
43	// Start type must be SERVICE_AUTO_START or lower, in order
44	// it to start automatically and allow the mechanism work
45	// for users with no admin rights.
46	static BOOL InstallDriver(
47	IN SC_HANDLE SchSCManager,
48	IN LPCTSTR DriverName,
49	IN LPCTSTR ServiceExe
50	)
51	{
52	SC_HANDLE schService;
53	DWORD err;
54
55	schService = CreateService (
56	SchSCManager, // SCManager database
57	DriverName, // name of service
58	DriverName, // name to display
59	SERVICE_ALL_ACCESS, // desired access
60	SERVICE_KERNEL_DRIVER, // service type
61	SERVICE_AUTO_START, // SERVICE_DEMAND_START, // start type
62	SERVICE_ERROR_NORMAL, // error control type
63	ServiceExe, // service's binary
64	NULL, // no load ordering group
65	NULL, // no tag identifier
66	NULL, // no dependencies
67	NULL, // LocalSystem account
68	NULL // no password
69	);
70
71	if (schService == NULL) {
72	err = GetLastError();
73	if (err == ERROR_SERVICE_EXISTS) {
74	return TRUE;
75	} else {
76	return FALSE;
77	}
78	}
79	CloseServiceHandle (schService);
80	return TRUE;
81	}
82
83	static BOOL RemoveDriver(
84	IN SC_HANDLE SchSCManager,
85	IN LPCTSTR DriverName
86	)
87	{
88	SC_HANDLE schService;
89	BOOL ret;
90
91	schService = OpenService (SchSCManager,
92	DriverName,
93	SERVICE_ALL_ACCESS
94	);
95	if (schService == NULL) return FALSE;
96	ret = DeleteService (schService);
97	CloseServiceHandle (schService);
98	return ret;
99	}
100
101	static BOOL StartDriver(
102	IN SC_HANDLE SchSCManager,
103	IN LPCTSTR DriverName
104	) {
105	SC_HANDLE schService;
106	BOOL ret;
107	DWORD err;
108
109	schService = OpenService (SchSCManager,
110	DriverName,
111	SERVICE_ALL_ACCESS
112	);
113	if (schService == NULL) return FALSE;
114	ret = StartService (schService, // service identifier
115	0, // number of arguments
116	NULL // pointer to arguments
117	);
118	if(ret == 0) {
119	err = GetLastError();
120	if (err == ERROR_SERVICE_ALREADY_RUNNING) {
121	ret = TRUE;
122	} else {
123	ret = FALSE;
124	}
125	}
126	CloseServiceHandle (schService);
127	return ret;
128	}
129
130	static BOOL StopDriver(
131	IN SC_HANDLE SchSCManager,
132	IN LPCTSTR DriverName
133	)
134	{
135	SC_HANDLE schService;
136	BOOL ret;
137	SERVICE_STATUS serviceStatus;
138
139	schService = OpenService (SchSCManager,
140	DriverName,
141	SERVICE_ALL_ACCESS
142	);
143	if (schService == NULL) return FALSE;
144	ret = ControlService (schService,
145	SERVICE_CONTROL_STOP,
146	&serviceStatus
147	);
148	CloseServiceHandle (schService);
149	return ret;
150	}
151
152	static BOOL __cdecl start_driver( void )
153	{
154	SC_HANDLE schSCManager;
155	BOOL ret = FALSE;
156
157	schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
158	if(!schSCManager) return(FALSE);
159	if(!InstallDriver( schSCManager, sDriverShort, sDriverLong )) {
160	CloseServiceHandle( schSCManager );
161	return(FALSE);
162	}
163	ret = StartDriver( schSCManager, sDriverShort );
164	if(!ret) {
165	(void)RemoveDriver( schSCManager, sDriverShort );
166	}
167	CloseServiceHandle( schSCManager );
168	return( ret );
169	}
170
171	static BOOL __cdecl stop_driver( void )
172	{
173	SC_HANDLE schSCManager;
174	BOOL ret = FALSE;
175
176	schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
177	if(!schSCManager) return(FALSE);
178	if(StopDriver( schSCManager, sDriverShort )) ret = TRUE;
179	CloseServiceHandle( schSCManager );
180	return( ret );
181	}
182
183	static BOOL __cdecl remove_driver( void )
184	{
185	SC_HANDLE schSCManager;
186	BOOL ret = FALSE;
187
188	schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
189	if(!schSCManager) return(FALSE);
190	if(RemoveDriver( schSCManager, sDriverShort )) ret = TRUE;
191	CloseServiceHandle( schSCManager );
192	return( ret );
193	}
194
195
196
197	// Exported stuff begins
198
199	int CdenableSysReadCdBytes( HANDLE h, DWORD start, DWORD count, char *buf )
200	{
201	HANDLE hDevice;
202	int ret;
203	DWORD nb;
204	DWORD in_buffer[10];
205	DWORD out_buffer[10];
206
207	ret = 0;
208
209	in_buffer[0] = (DWORD)h;
210	in_buffer[1] = (DWORD)start;
211	in_buffer[2] = (DWORD)count;
212	in_buffer[3] = (DWORD)buf;
213	out_buffer[0] = 0;
214
215	hDevice = CreateFile (sCompleteName,
216	GENERIC_READ \| GENERIC_WRITE,
217	0,
218	NULL,
219	OPEN_EXISTING,
220	FILE_ATTRIBUTE_NORMAL,
221	NULL
222	);
223
224	if (hDevice == ((HANDLE)-1)) {
225	ret = 0;
226	} else {
227	if ( DeviceIoControl( hDevice,
228	IOCTL_CDENABLE_READ,
229	(LPVOID)in_buffer, 16,
230	(LPVOID)out_buffer, 4,
231	&nb, NULL ) )
232	{
233	if(out_buffer[0] != 0) ret = count;
234	}
235	CloseHandle (hDevice);
236	}
237
238	return ret;
239	}
240
241	int CdenableSysReadCdSectors( HANDLE h, DWORD start, DWORD count, char *buf )
242	{
243	return( CdenableSysReadCdBytes( h, (start<<11), (count<<11), buf ) );
244	}
245
246	int CdenableSysWriteCdBytes( HANDLE h, DWORD start, DWORD count, char *buf )
247	{
248	return( 0 );
249
250	/*
251	HANDLE hDevice;
252	int ret;
253	DWORD nb;
254	DWORD in_buffer[10];
255	DWORD out_buffer[10];
256
257	ret = 0;
258
259	in_buffer[0] = (DWORD)h;
260	in_buffer[1] = (DWORD)start;
261	in_buffer[2] = (DWORD)count;
262	in_buffer[3] = (DWORD)buf;
263	out_buffer[0] = 0;
264
265	hDevice = CreateFile (sCompleteName,
266	GENERIC_READ \| GENERIC_WRITE,
267	0,
268	NULL,
269	OPEN_EXISTING,
270	FILE_ATTRIBUTE_NORMAL,
271	NULL
272	);
273
274	if (hDevice == ((HANDLE)-1)) {
275	ret = 0;
276	} else {
277	if ( DeviceIoControl( hDevice,
278	IOCTL_CDENABLE_WRITE,
279	(LPVOID)in_buffer, 16,
280	(LPVOID)out_buffer, 4,
281	&nb, NULL ) )
282	{
283	if(out_buffer[0] != 0) ret = count;
284	}
285	CloseHandle (hDevice);
286	}
287
288	return ret;
289	*/
290	}
291
292	int CdenableSysWriteCdSectors( HANDLE h, DWORD start, DWORD count, char *buf )
293	{
294	// return( CdenableSysWriteCdBytes( h, (start<<11), (count<<11), buf ) );
295	return( 0 );
296	}
297
298	BOOL CdenableSysInstallStart(void)
299	{
300	return(start_driver());
301	}
302
303	void CdenableSysStopRemove(void)
304	{
305	stop_driver();
306	remove_driver();
307	}
308
309	DWORD CdenableSysGetVersion( void )
310	{
311	HANDLE hDevice;
312	DWORD ret;
313	DWORD nb;
314	DWORD out_buffer[10];
315
316	ret = 0;
317	out_buffer[0] = 0;
318	hDevice = CreateFile (sCompleteName,
319	GENERIC_READ \| GENERIC_WRITE,
320	0,
321	NULL,
322	OPEN_EXISTING,
323	FILE_ATTRIBUTE_NORMAL,
324	NULL
325	);
326	if (hDevice == ((HANDLE)-1)) {
327	ret = 0;
328	} else {
329	if ( DeviceIoControl( hDevice,
330	IOCTL_CDENABLE_GET_VERSION,
331	NULL, 0,
332	(LPVOID)out_buffer, 4,
333	&nb, NULL ) )
334	{
335	ret = out_buffer[0];
336	}
337	CloseHandle (hDevice);
338	}
339	return ret;
340	}
341
342	#ifdef __cplusplus
343	} //extern "C"
344	#endif
345