trunk/Src/wptFileDisk.c

/*
    Control program for a virtual disk driver for Windows NT/2000/XP.
    Copyright (C) 1999, 2000, 2001, 2002 Bo Brantén.

    Heavily modified for the use with Cryptdisk by Timo Schulz
    (C) 2004 Timo Schulz

    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 <windows.h>
#include <winioctl.h>
#include <stdio.h>
#include <sys/types.h>

#include "openpgp.h"

/* remember to change the values in wptErrors.h also */
#define CDISK_ERR_LOCK   201
#define CDISK_ERR_MOUNT  202
#define CDISK_ERR_UMOUNT 203
#define CDISK_ERR_OPEN   204
#define CDISK_ERR_BUSY   205
#define CDISK_ERR_QUERY  206

#define MAX_KEYS                64
#define MAX_KEYHASH             32
#define MAX_KEY_LENGTH          50
#define CCVERSION               0x04

#define DEVICE_BASE_NAME    "\\FileDisk"
#define DEVICE_DIR_NAME     "\\Device"          DEVICE_BASE_NAME
#define DEVICE_NAME_PREFIX  DEVICE_DIR_NAME     DEVICE_BASE_NAME

#define FILE_DEVICE_FILE_DISK       0x8000

#define IOCTL_FILE_DISK_OPEN_FILE   CTL_CODE(FILE_DEVICE_FILE_DISK, 0x800, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define IOCTL_FILE_DISK_CLOSE_FILE  CTL_CODE(FILE_DEVICE_FILE_DISK, 0x801, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define IOCTL_FILE_DISK_QUERY_FILE  CTL_CODE(FILE_DEVICE_FILE_DISK, 0x802, METHOD_BUFFERED, FILE_READ_ACCESS)

typedef struct _OPEN_FILE_INFORMATION {
    USHORT          version;
    LARGE_INTEGER   FileSize;
    BOOLEAN         ReadOnly;
    USHORT          KeyType;            //0 None 1 2Fish 2 AES256
    USHORT          KeyNum;
    USHORT          KeyLength;
    USHORT          FileNameLength;
    UCHAR           Key[MAX_KEYS][MAX_KEYHASH];
    UCHAR           DriveLetter;
    UCHAR           FileName[1];
} OPEN_FILE_INFORMATION, *POPEN_FILE_INFORMATION;

static void 
print_lasterr (char * prefix)
{
    LPVOID msg;

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER |
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        GetLastError(),
        0,
        (LPTSTR) &msg,
        0,
        NULL
        );
    MessageBox (NULL, (LPTSTR)msg, prefix, MB_ICONERROR|MB_OK);
    LocalFree (msg);
}


static void
add_key (POPEN_FILE_INFORMATION ka, const char * key, size_t len)
{
    gpg_md_t md;

    if (ka->KeyNum >= MAX_KEYS) 
        return;

    switch (ka->KeyType) {
    case 1: /* 2fish */
        md = gpg_md_open (MD_RMD160);
        ka->KeyLength=20;
        break;
    case 2: /* AES256 */
        md = gpg_md_open (MD_SHA512);
        ka->KeyLength=32;       
        break;
    case 3: /* AES128 */
        md = gpg_md_open (MD_SHA256);
        ka->KeyLength=16;
        break;
    case 4: /* AES192 */
        ka->KeyLength=24;
        md = gpg_md_open (MD_SHA384);
        break;
    }
    gpg_md_write (md, (char *)key, len);
    gpg_md_final (md);
    memcpy (ka->Key[ka->KeyNum++], gpg_md_read (md), ka->KeyLength);
    gpg_md_close (md);
}


int
filedisk_mount (int                     DeviceNumber,
                POPEN_FILE_INFORMATION  ofi,
                char                    drivelet,
                BOOLEAN                 CdImage)
{
    char    VolumeName[] = "\\\\.\\ :";
    char    DeviceName[255];
    HANDLE  Device;
    DWORD   BytesReturned;

    VolumeName[4] = drivelet;

    Device = CreateFile (VolumeName,
                         GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_NO_BUFFERING,
                         NULL);
    if (Device != INVALID_HANDLE_VALUE) {
        SetLastError (ERROR_BUSY);
        print_lasterr (&VolumeName[4]);
        return CDISK_ERR_BUSY;
    }

    if (CdImage)
        sprintf (DeviceName, DEVICE_NAME_PREFIX "Cd" "%u", DeviceNumber);
    else
        sprintf (DeviceName, DEVICE_NAME_PREFIX "%u", DeviceNumber);

    if (!DefineDosDevice (DDD_RAW_TARGET_PATH,
                          &VolumeName[4],
                          DeviceName)) {
        print_lasterr (&VolumeName[4]);
        return CDISK_ERR_OPEN;
    }

    Device = CreateFile (VolumeName,
                         GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_NO_BUFFERING,
                         NULL);

    if (Device == INVALID_HANDLE_VALUE) {
        print_lasterr (&VolumeName[4]);
        DefineDosDevice (DDD_REMOVE_DEFINITION, &VolumeName[4], NULL);
        return CDISK_ERR_OPEN;
    }

    if (!DeviceIoControl (Device,
                          IOCTL_FILE_DISK_OPEN_FILE,
                          ofi,
                          sizeof(OPEN_FILE_INFORMATION) + ofi->FileNameLength - 1,
                          NULL, 0, &BytesReturned, NULL)) {
        print_lasterr ("Cryptdisk Error");
        DefineDosDevice (DDD_REMOVE_DEFINITION, &VolumeName[4], NULL);
        return CDISK_ERR_MOUNT;
    }

    return 0;
}


static int 
filedisk_unmount2 (char drivelet, int flags, int forced)
{
    char    VolumeName[60] = "\\\\.\\ :";
    HANDLE  Device;
    DWORD   BytesReturned;

    if (!flags)
        VolumeName[4] = drivelet;
    else if (flags & 1)
        sprintf(VolumeName,"\\\\.\\FileDisk%d", drivelet);
    else if (flags & 2)
        sprintf(VolumeName,"\\\\.\\FileDiskCd%d",drivelet);

    Device = CreateFile (VolumeName,
                         GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_NO_BUFFERING,
                         NULL);
    if (Device == INVALID_HANDLE_VALUE) {
        if (forced)
            print_lasterr(&VolumeName[4]);
        return CDISK_ERR_OPEN;
    }

    if (!DeviceIoControl (Device, 
                          FSCTL_LOCK_VOLUME,
                          NULL, 0, NULL, 0,
                          &BytesReturned, NULL)) {
        if (forced) {
            print_lasterr(&VolumeName[4]);
            return CDISK_ERR_LOCK;
        }
    }

    if (!DeviceIoControl (Device,
                          IOCTL_FILE_DISK_CLOSE_FILE,
                          NULL, 0, NULL, 0, 
                          &BytesReturned, NULL )) {
        if (forced)
            print_lasterr ("Cryptdisk Error");
        return CDISK_ERR_UMOUNT;
    }

    if (!DeviceIoControl (
        Device, FSCTL_DISMOUNT_VOLUME,
        NULL, 0, NULL, 0,
        &BytesReturned, NULL)) {
        if (forced)
            print_lasterr (&VolumeName[4]);
        return CDISK_ERR_UMOUNT;
    }

    if (!DeviceIoControl (Device, 
                          FSCTL_UNLOCK_VOLUME,
                          NULL, 0, NULL, 0,
                          &BytesReturned, NULL)) {
        if (forced) {
            print_lasterr (&VolumeName[4]);
            return CDISK_ERR_LOCK;
        }
    }

    CloseHandle (Device);

    if (!DefineDosDevice (
        DDD_REMOVE_DEFINITION,
        &VolumeName[4], NULL)) {
        if (forced)
            print_lasterr (&VolumeName[4]);
        return CDISK_ERR_UMOUNT;
    }

    return 0;
}

int 
filedisk_unmount (char drivelet, int forced)
{           
    char i;

    if (drivelet) {
        int rc = filedisk_unmount2 (drivelet, 0, forced);
        if (rc) 
            print_lasterr ("Unmount´");
        return rc;
    }
    for (i=0; i<20;i++) {
        if (filedisk_unmount2 (i, 1, 0) == CDISK_ERR_OPEN)
            break;
    }
    for (i=0; i<20;i++) {
        if (filedisk_unmount2 (i, 2, 0) == CDISK_ERR_OPEN)
            break;
    }
    return 0;
}


int
filedisk_status (char drivelet, LARGE_INTEGER * size, int * rdonly)
{
    char                    VolumeName[] = "\\\\.\\ :";
    HANDLE                  Device;
    POPEN_FILE_INFORMATION  ofi;
    DWORD                   BytesReturned;

    VolumeName[4] = drivelet;

    Device = CreateFile (VolumeName,
                         GENERIC_READ,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_FLAG_NO_BUFFERING,
                        NULL);

    if (Device == INVALID_HANDLE_VALUE) {
        print_lasterr(&VolumeName[4]);
        return CDISK_ERR_OPEN;
    }

    ofi = malloc (sizeof(OPEN_FILE_INFORMATION) + MAX_PATH);

    if (!DeviceIoControl (Device,
                          IOCTL_FILE_DISK_QUERY_FILE,
                          NULL,
                          0,
                          ofi,
                          sizeof(OPEN_FILE_INFORMATION) + MAX_PATH,
                          &BytesReturned, NULL)) {
        print_lasterr (&VolumeName[4]);
        return CDISK_ERR_QUERY;
    }

    if (BytesReturned < sizeof(OPEN_FILE_INFORMATION)) {
        SetLastError (ERROR_INSUFFICIENT_BUFFER);
        print_lasterr (&VolumeName[4]);
        return CDISK_ERR_QUERY;
    }

    if (size)
        *size = ofi->FileSize;
    if (rdonly)
        *rdonly = ofi->ReadOnly;

    return 0;
}


POPEN_FILE_INFORMATION
filedisk_init_info (int devnum, char drivelet, const char * file,
                    int ro, int cd_img, unsigned long size, const char * key,
                    int keyalgo)
{
    POPEN_FILE_INFORMATION pfi;

    pfi = calloc (1, sizeof(OPEN_FILE_INFORMATION) + strlen (file) + 7);

    pfi->version = CCVERSION;
    if (file[0] == '\\') {
        if (file[1] == '\\' && file[2] != '.') {
            /* \\server\share\path\filedisk.img */
            strcpy(pfi->FileName, "\\??\\UNC");
            strcat(pfi->FileName, file + 1);
        }
        else /* \Device\Harddisk0\Partition1\path\filedisk.img */
            strcpy(pfi->FileName, file);
    }   
    else { // c:\path\filedisk.img
        strcpy (pfi->FileName, "\\??\\");
        strcat (pfi->FileName, file);
    }

    pfi->FileNameLength = (USHORT) strlen (pfi->FileName);
    pfi->ReadOnly = ro? TRUE : FALSE;
    if (cd_img)
        pfi->ReadOnly = TRUE;
    if (size)
        pfi->FileSize.QuadPart = size * 1024;
    if (key) {
        if (keyalgo < 1 || keyalgo > 4)
            pfi->KeyType = 1;
        else
            pfi->KeyType = keyalgo;
        add_key (pfi, key, strlen (key));
    }

    return pfi;
}


void
filedisk_free_info (POPEN_FILE_INFORMATION pfi)
{
    if (!pfi)
        return;
    free (pfi);
}

1	twoaday	2	/*
2			Control program for a virtual disk driver for Windows NT/2000/XP.
3			Copyright (C) 1999, 2000, 2001, 2002 Bo Brantén.
4
5			Heavily modified for the use with Cryptdisk by Timo Schulz
6			(C) 2004 Timo Schulz
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			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16			You should have received a copy of the GNU General Public License
17			along with this program; if not, write to the Free Software
18			Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include <windows.h>
22			#include <winioctl.h>
23			#include <stdio.h>
24			#include <sys/types.h>
25
26			#include "openpgp.h"
27
28			/* remember to change the values in wptErrors.h also */
29			#define CDISK_ERR_LOCK 201
30			#define CDISK_ERR_MOUNT 202
31			#define CDISK_ERR_UMOUNT 203
32			#define CDISK_ERR_OPEN 204
33			#define CDISK_ERR_BUSY 205
34			#define CDISK_ERR_QUERY 206
35
36			#define MAX_KEYS 64
37			#define MAX_KEYHASH 32
38			#define MAX_KEY_LENGTH 50
39			#define CCVERSION 0x04
40
41			#define DEVICE_BASE_NAME "\\FileDisk"
42			#define DEVICE_DIR_NAME "\\Device" DEVICE_BASE_NAME
43			#define DEVICE_NAME_PREFIX DEVICE_DIR_NAME DEVICE_BASE_NAME
44
45			#define FILE_DEVICE_FILE_DISK 0x8000
46
47			#define IOCTL_FILE_DISK_OPEN_FILE CTL_CODE(FILE_DEVICE_FILE_DISK, 0x800, METHOD_BUFFERED, FILE_READ_ACCESS \| FILE_WRITE_ACCESS)
48			#define IOCTL_FILE_DISK_CLOSE_FILE CTL_CODE(FILE_DEVICE_FILE_DISK, 0x801, METHOD_BUFFERED, FILE_READ_ACCESS \| FILE_WRITE_ACCESS)
49			#define IOCTL_FILE_DISK_QUERY_FILE CTL_CODE(FILE_DEVICE_FILE_DISK, 0x802, METHOD_BUFFERED, FILE_READ_ACCESS)
50
51			typedef struct _OPEN_FILE_INFORMATION {
52			USHORT version;
53			LARGE_INTEGER FileSize;
54			BOOLEAN ReadOnly;
55			USHORT KeyType; //0 None 1 2Fish 2 AES256
56			USHORT KeyNum;
57			USHORT KeyLength;
58			USHORT FileNameLength;
59			UCHAR Key[MAX_KEYS][MAX_KEYHASH];
60			UCHAR DriveLetter;
61			UCHAR FileName[1];
62			} OPEN_FILE_INFORMATION, *POPEN_FILE_INFORMATION;
63
64			static void
65			print_lasterr (char * prefix)
66			{
67			LPVOID msg;
68
69			FormatMessage(
70			FORMAT_MESSAGE_ALLOCATE_BUFFER \|
71			FORMAT_MESSAGE_FROM_SYSTEM \|
72			FORMAT_MESSAGE_IGNORE_INSERTS,
73			NULL,
74			GetLastError(),
75			0,
76			(LPTSTR) &msg,
77			0,
78			NULL
79			);
80			MessageBox (NULL, (LPTSTR)msg, prefix, MB_ICONERROR\|MB_OK);
81			LocalFree (msg);
82			}
83
84
85			static void
86			add_key (POPEN_FILE_INFORMATION ka, const char * key, size_t len)
87			{
88			gpg_md_t md;
89
90			if (ka->KeyNum >= MAX_KEYS)
91			return;
92
93			switch (ka->KeyType) {
94			case 1: /* 2fish */
95			md = gpg_md_open (MD_RMD160);
96			ka->KeyLength=20;
97			break;
98			case 2: /* AES256 */
99			md = gpg_md_open (MD_SHA512);
100			ka->KeyLength=32;
101			break;
102			case 3: /* AES128 */
103			md = gpg_md_open (MD_SHA256);
104			ka->KeyLength=16;
105			break;
106			case 4: /* AES192 */
107			ka->KeyLength=24;
108			md = gpg_md_open (MD_SHA384);
109			break;
110			}
111			gpg_md_write (md, (char *)key, len);
112			gpg_md_final (md);
113			memcpy (ka->Key[ka->KeyNum++], gpg_md_read (md), ka->KeyLength);
114			gpg_md_close (md);
115			}
116
117
118			int
119			filedisk_mount (int DeviceNumber,
120			POPEN_FILE_INFORMATION ofi,
121			char drivelet,
122			BOOLEAN CdImage)
123			{
124			char VolumeName[] = "\\\\.\\ :";
125			char DeviceName[255];
126			HANDLE Device;
127			DWORD BytesReturned;
128
129			VolumeName[4] = drivelet;
130
131			Device = CreateFile (VolumeName,
132			GENERIC_READ \| GENERIC_WRITE,
133			FILE_SHARE_READ \| FILE_SHARE_WRITE,
134			NULL,
135			OPEN_EXISTING,
136			FILE_FLAG_NO_BUFFERING,
137			NULL);
138			if (Device != INVALID_HANDLE_VALUE) {
139			SetLastError (ERROR_BUSY);
140			print_lasterr (&VolumeName[4]);
141			return CDISK_ERR_BUSY;
142			}
143
144			if (CdImage)
145			sprintf (DeviceName, DEVICE_NAME_PREFIX "Cd" "%u", DeviceNumber);
146			else
147			sprintf (DeviceName, DEVICE_NAME_PREFIX "%u", DeviceNumber);
148
149			if (!DefineDosDevice (DDD_RAW_TARGET_PATH,
150			&VolumeName[4],
151			DeviceName)) {
152			print_lasterr (&VolumeName[4]);
153			return CDISK_ERR_OPEN;
154			}
155
156			Device = CreateFile (VolumeName,
157			GENERIC_READ \| GENERIC_WRITE,
158			FILE_SHARE_READ \| FILE_SHARE_WRITE,
159			NULL,
160			OPEN_EXISTING,
161			FILE_FLAG_NO_BUFFERING,
162			NULL);
163
164			if (Device == INVALID_HANDLE_VALUE) {
165			print_lasterr (&VolumeName[4]);
166			DefineDosDevice (DDD_REMOVE_DEFINITION, &VolumeName[4], NULL);
167			return CDISK_ERR_OPEN;
168			}
169
170			if (!DeviceIoControl (Device,
171			IOCTL_FILE_DISK_OPEN_FILE,
172			ofi,
173			sizeof(OPEN_FILE_INFORMATION) + ofi->FileNameLength - 1,
174			NULL, 0, &BytesReturned, NULL)) {
175			print_lasterr ("Cryptdisk Error");
176			DefineDosDevice (DDD_REMOVE_DEFINITION, &VolumeName[4], NULL);
177			return CDISK_ERR_MOUNT;
178			}
179
180			return 0;
181			}
182
183
184			static int
185			filedisk_unmount2 (char drivelet, int flags, int forced)
186			{
187			char VolumeName[60] = "\\\\.\\ :";
188			HANDLE Device;
189			DWORD BytesReturned;
190
191			if (!flags)
192			VolumeName[4] = drivelet;
193			else if (flags & 1)
194			sprintf(VolumeName,"\\\\.\\FileDisk%d", drivelet);
195			else if (flags & 2)
196			sprintf(VolumeName,"\\\\.\\FileDiskCd%d",drivelet);
197
198			Device = CreateFile (VolumeName,
199			GENERIC_READ \| GENERIC_WRITE,
200			FILE_SHARE_READ \| FILE_SHARE_WRITE,
201			NULL,
202			OPEN_EXISTING,
203			FILE_FLAG_NO_BUFFERING,
204			NULL);
205			if (Device == INVALID_HANDLE_VALUE) {
206			if (forced)
207			print_lasterr(&VolumeName[4]);
208			return CDISK_ERR_OPEN;
209			}
210
211			if (!DeviceIoControl (Device,
212			FSCTL_LOCK_VOLUME,
213			NULL, 0, NULL, 0,
214			&BytesReturned, NULL)) {
215			if (forced) {
216			print_lasterr(&VolumeName[4]);
217			return CDISK_ERR_LOCK;
218			}
219			}
220
221			if (!DeviceIoControl (Device,
222			IOCTL_FILE_DISK_CLOSE_FILE,
223			NULL, 0, NULL, 0,
224			&BytesReturned, NULL )) {
225			if (forced)
226			print_lasterr ("Cryptdisk Error");
227			return CDISK_ERR_UMOUNT;
228			}
229
230			if (!DeviceIoControl (
231			Device, FSCTL_DISMOUNT_VOLUME,
232			NULL, 0, NULL, 0,
233			&BytesReturned, NULL)) {
234			if (forced)
235			print_lasterr (&VolumeName[4]);
236			return CDISK_ERR_UMOUNT;
237			}
238
239			if (!DeviceIoControl (Device,
240			FSCTL_UNLOCK_VOLUME,
241			NULL, 0, NULL, 0,
242			&BytesReturned, NULL)) {
243			if (forced) {
244			print_lasterr (&VolumeName[4]);
245			return CDISK_ERR_LOCK;
246			}
247			}
248
249			CloseHandle (Device);
250
251			if (!DefineDosDevice (
252			DDD_REMOVE_DEFINITION,
253			&VolumeName[4], NULL)) {
254			if (forced)
255			print_lasterr (&VolumeName[4]);
256			return CDISK_ERR_UMOUNT;
257			}
258
259			return 0;
260			}
261
262			int
263			filedisk_unmount (char drivelet, int forced)
264			{
265			char i;
266
267			if (drivelet) {
268			int rc = filedisk_unmount2 (drivelet, 0, forced);
269			if (rc)
270			print_lasterr ("Unmount´");
271			return rc;
272			}
273			for (i=0; i<20;i++) {
274			if (filedisk_unmount2 (i, 1, 0) == CDISK_ERR_OPEN)
275			break;
276			}
277			for (i=0; i<20;i++) {
278			if (filedisk_unmount2 (i, 2, 0) == CDISK_ERR_OPEN)
279			break;
280			}
281			return 0;
282			}
283
284
285			int
286			filedisk_status (char drivelet, LARGE_INTEGER * size, int * rdonly)
287			{
288			char VolumeName[] = "\\\\.\\ :";
289			HANDLE Device;
290			POPEN_FILE_INFORMATION ofi;
291			DWORD BytesReturned;
292
293			VolumeName[4] = drivelet;
294
295			Device = CreateFile (VolumeName,
296			GENERIC_READ,
297			FILE_SHARE_READ \| FILE_SHARE_WRITE,
298			NULL,
299			OPEN_EXISTING,
300			FILE_FLAG_NO_BUFFERING,
301			NULL);
302
303			if (Device == INVALID_HANDLE_VALUE) {
304			print_lasterr(&VolumeName[4]);
305			return CDISK_ERR_OPEN;
306			}
307
308			ofi = malloc (sizeof(OPEN_FILE_INFORMATION) + MAX_PATH);
309
310			if (!DeviceIoControl (Device,
311			IOCTL_FILE_DISK_QUERY_FILE,
312			NULL,
313			0,
314			ofi,
315			sizeof(OPEN_FILE_INFORMATION) + MAX_PATH,
316			&BytesReturned, NULL)) {
317			print_lasterr (&VolumeName[4]);
318			return CDISK_ERR_QUERY;
319			}
320
321			if (BytesReturned < sizeof(OPEN_FILE_INFORMATION)) {
322			SetLastError (ERROR_INSUFFICIENT_BUFFER);
323			print_lasterr (&VolumeName[4]);
324			return CDISK_ERR_QUERY;
325			}
326
327			if (size)
328			*size = ofi->FileSize;
329			if (rdonly)
330			*rdonly = ofi->ReadOnly;
331
332			return 0;
333			}
334
335
336			POPEN_FILE_INFORMATION
337			filedisk_init_info (int devnum, char drivelet, const char * file,
338			int ro, int cd_img, unsigned long size, const char * key,
339			int keyalgo)
340			{
341			POPEN_FILE_INFORMATION pfi;
342
343			pfi = calloc (1, sizeof(OPEN_FILE_INFORMATION) + strlen (file) + 7);
344
345			pfi->version = CCVERSION;
346			if (file[0] == '\\') {
347			if (file[1] == '\\' && file[2] != '.') {
348			/* \\server\share\path\filedisk.img */
349			strcpy(pfi->FileName, "\\??\\UNC");
350			strcat(pfi->FileName, file + 1);
351			}
352			else /* \Device\Harddisk0\Partition1\path\filedisk.img */
353			strcpy(pfi->FileName, file);
354			}
355			else { // c:\path\filedisk.img
356			strcpy (pfi->FileName, "\\??\\");
357			strcat (pfi->FileName, file);
358			}
359
360			pfi->FileNameLength = (USHORT) strlen (pfi->FileName);
361			pfi->ReadOnly = ro? TRUE : FALSE;
362			if (cd_img)
363			pfi->ReadOnly = TRUE;
364			if (size)
365			pfi->FileSize.QuadPart = size * 1024;
366			if (key) {
367			if (keyalgo < 1 \|\| keyalgo > 4)
368			pfi->KeyType = 1;
369			else
370			pfi->KeyType = keyalgo;
371			add_key (pfi, key, strlen (key));
372			}
373
374			return pfi;
375			}
376
377
378			void
379			filedisk_free_info (POPEN_FILE_INFORMATION pfi)
380			{
381			if (!pfi)
382			return;
383			free (pfi);
384			}
385