![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tc9x.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / driver vxd|
Return to tc9x.c CVS log | Up to [truecrypt] / truecrypt / driver vxd |
1.1 root 1: /* Copyright (C) 2004 TrueCrypt Team, truecrypt.org
2: This product uses components written by Paul Le Roux <[email protected]>
3: Majority of this code originally Copyright (C) 1998/9 by Aman. Used with
4: permission. Other parts originally Copyright (C) 1995 by Walter Oney used
5: with implied permission. */
6:
7: #include "TCdefs.h"
8:
9: #pragma VxD_LOCKED_CODE_SEG
10: #pragma VxD_LOCKED_DATA_SEG
11:
12: #include "crypto.h"
13: #include "fat.h"
14: #include "volumes.h"
15: #include "cache.h"
16: #include "apidrvr.h"
17: #include "tc9x.h"
18: #include "queue.h"
19:
20: #include "ifshook.h"
21: #include "ifsmgr.inc"
22:
23:
24: #define NUMSLOTS 8 /* Only up to 8 volumes at a time */
25: #define MAXBLOCK 128 /* 64k was 256.... */
26:
27: #define MAX_MESSAGES 8 /* Max number of queued driver messages */
28:
29: #define DEVICE_TYPE 0 /* We are a fixed disk (even files on
30: removables) */
31:
32: #ifdef DEBUG
33: #define EXTRA_INFO 1
34: #endif
35:
36: int halfseccount=0xc9;
37:
38: char *transferbuffer = NULL; /* IO transfer buffer */
39: char *appaccessbuffer = NULL; /* win32 GUI IO buffer */
40: char *partitiontestbuffer = NULL; /* Buffer for the MBR */
41: int dcbcount = 0; /* DCB hack */
42: PDCB dcblist[128]; /* DCB hack */
43:
44: PDCB dcb_boot; /* Boot device */
45:
46: extern DRP theDRP; /* Device registration packet */
47:
48: int bAllowFastShutdown = 0;
49:
50: cryptvol cv1 =
51: {0, 0, 0, 0, 0, 0, 0, 0};
52:
53: cryptvol cv2 =
54: {0, 0, 0, 0, 0, 0, 0, 0};
55:
56: cryptvol cv3 =
57: {0, 0, 0, 0, 0, 0, 0, 0};
58:
59: cryptvol cv4 =
60: {0, 0, 0, 0, 0, 0, 0, 0};
61:
62: cryptvol cv5 =
63: {0, 0, 0, 0, 0, 0, 0, 0};
64:
65: cryptvol cv6 =
66: {0, 0, 0, 0, 0, 0, 0, 0};
67:
68: cryptvol cv7 =
69: {0, 0, 0, 0, 0, 0, 0, 0};
70:
71: cryptvol cv8 =
72: {0, 0, 0, 0, 0, 0, 0, 0};
73:
74: cryptvol *cryptvols[]=
75: {
76: &cv1,
77: &cv2,
78: &cv3,
79: &cv4,
80: &cv5,
81: &cv6,
82: &cv7,
83: &cv8
84: };
85:
86: typedef struct MessageBox_t
87: {
88: char *MessageHdr;
89: char *MessageBody;
90: int PostPlease;
91: } MessageBox;
92:
93: MessageBox Msgs[MAX_MESSAGES];
94:
95:
96: VOID
97: OnAsyncRequest (PAEP aep)
98: {
99: typedef USHORT (*PEF) (PAEP);
100:
101: static PEF evproc[AEP_MAX_FUNC + 1] =
102: {(PEF) OnInitialize /* 0 AEP_INITIALIZE */
103: ,NULL /* 1 AEP_SYSTEM_CRIT_SHUTDOWN */
104: ,(PEF) OnBootComplete /* 2 AEP_BOOT_COMPLETE */
105: ,(PEF) OnConfigDcb /* 3 AEP_CONFIG_DCB */
106: ,(PEF) OnUnconfigDcb /* 4 AEP_UNCONFIG_DCB */
107: ,NULL /* 5 AEP_IOP_TIMEOUT */
108: ,NULL /* 6 AEP_DEVICE_INQUIRY */
109: ,(PEF) OnHalfSec /* 7 AEP_HALF_SEC */
110: ,NULL /* 8 AEP_1_SEC */
111: ,NULL /* 9 AEP_2_SECS */
112: ,NULL /* 10 AEP_4_SECS */
113: ,NULL /* 11 AEP_DBG_DOT_CMD */
114: ,NULL /* 12 AEP_ASSOCIATE_DCB */
115: ,NULL /* 13 AEP_REAL_MODE_HANDOFF */
116: ,(PEF) OnSystemExit /* 14 AEP_SYSTEM_SHUTDOWN */
117: ,(PEF) OnUninitialize /* 15 AEP_UNINITIALIZE */
118: ,NULL /* 16 AEP_DCB_LOCK */
119: ,NULL /* 17 AEP_MOUNT_VERIFY */
120: ,NULL /* 18 AEP_CREATE_VRP */
121: ,NULL /* 19 AEP_DESTROY_VRP */
122: ,NULL /* 20 AEP_REFRESH_DRIVE */
123: ,NULL /* 21 AEP_PEND_UNCONFIG_DCB */
124: ,NULL /* 22 AEP_1E_VEC_UPDATE */
125: ,NULL /* 23 AEP_CHANGE_RPM */
126: };
127: PEF proc;
128:
129: if (aep->AEP_func < arraysize (evproc) && (proc = evproc[aep->AEP_func]))
130: aep->AEP_result = proc (aep);
131: else
132: aep->AEP_result = (USHORT) AEP_FAILURE;
133: }
134:
135:
136: USHORT
137: OnInitialize (PAEP_bi_init aep)
138: {
139: /* allocate our (smaller) memory buffer..... */
140:
141: static int initalready = 0;
142:
143: if (initalready)
144: return AEP_SUCCESS;
145:
146: initalready++;
147:
148: transferbuffer = (char *) _PageAllocate (50, PG_SYS, 0, 0, 0, MBYTE16, NULL, PAGEZEROINIT | PAGEFIXED | PAGECONTIG | PAGEUSEALIGN);
149: partitiontestbuffer = (char *) transferbuffer + (265 * 512);
150: appaccessbuffer = transferbuffer + (265 * 512);
151:
152:
153: if (transferbuffer)
154: return AEP_SUCCESS;
155:
156: return (USHORT) AEP_FAILURE;
157: }
158:
159: USHORT
160: OnUninitialize (PAEP_bi_uninit aep)
161: {
162: return AEP_SUCCESS;
163: }
164:
165: /* asks us if we want to stay loaded or not. */
166:
167: USHORT
168: OnBootComplete (PAEP_boot_done aep)
169: {
170: installhook ();
171: return AEP_SUCCESS;
172: }
173:
174: USHORT
175: OnConfigDcb (PAEP_dcb_config aep)
176: {
177: PDCB dcb = (PDCB) aep->AEP_d_c_dcb;
178: if (!(dcb->DCB_cmn.DCB_device_flags & DCB_DEV_PHYSICAL))
179: {
180: return AEP_SUCCESS;
181: }
182:
183: /* Sadly for SCSI some port drivers have not set apparent_blk_shift
184: up at this point.. if ((dcb->DCB_cmn.DCB_apparent_blk_shift!=9)
185: && (dcb->DCB_cmn.DCB_device_type!=DCB_type_cdrom) ) return
186: AEP_SUCCESS; */
187:
188: if (dcbcount < 100)
189: {
190: if ((dcb->DCB_cmn.DCB_device_type == 0) || (dcb->DCB_cmn.DCB_device_type == DCB_type_cdrom))
191: {
192: if (cmpvend ((char *) &dcb->DCB_vendor_id, "JETICO", 6) != 0)
193: {
194: if (CheckDcbAlready (dcb))
195: return AEP_SUCCESS;
196: dcblist[dcbcount] = dcb;
197: dcblist[dcbcount + 1] = NULL;
198: dcbcount++;
199: }
200: }
201: }
202:
203:
204: if (dcb->DCB_cmn.DCB_device_type == 0)
205: ((IspInsertCalldown (dcb, OnRequest, (PDDB) aep->AEP_d_c_hdr.AEP_ddb, 0,
206: dcb->DCB_cmn.DCB_dmd_flags, aep->AEP_d_c_hdr.AEP_lgn)));
207:
208: return AEP_SUCCESS;
209: }
210:
211: /* AEP_UNCONFIG_DCB informs us that the physical device represented by a DCB
212: is going away */
213:
214: USHORT
215: OnUnconfigDcb (PAEP_dcb_unconfig aep)
216: {
217: return AEP_SUCCESS;
218: }
219:
220: VOID
221: OnRequest (PIOP iop)
222: {
223: DoCallDown (iop); /* do normal unencryped disk stuff... */
224: }
225:
226: int
227: cmpvend (char *a, char *b, int len)
228: {
229: int n;
230: for (n = 0; n < len; n++)
231: if (a[n] != b[n])
232: return 1;
233: return 0;
234: }
235:
236:
237: int
238: CheckDcbAlready (PDCB dcb)
239: {
240: int n;
241: /* sometimes the same dcb is passed more than once, on some drivers!! */
242: if (!dcbcount)
243: return 0;
244:
245: for (n = 0; n < dcbcount; n++)
246: if (dcblist[n] == dcb)
247: return 1;
248:
249: return 0;
250: }
251:
252: /* DoCallDown passes a request to the next lower layer. Note that the
253: documentation about how to do this is totally wrong: you don't just add
254: sizeof(DCB_cd_entry) to the calldown pointer, you follow a linked list
255: from one calldown entry to the next. */
256:
257: void
258: DoCallDown (PIOP iop)
259: {
260: _asm
261: { /* call down to next layer */
262: pushfd
263: pushad
264: mov ecx,[iop]
265: mov eax,[ecx] IOP.IOP_calldown_ptr
266: mov eax,[eax] DCB_cd_entry.DCB_cd_next
267: mov[ecx] IOP.IOP_calldown_ptr, eax
268: push ecx
269: call[eax] DCB_cd_entry.DCB_cd_io_address
270: add esp, 4
271: popad
272: popfd
273: }
274: }
275:
276: BOOL
277: OnSysDynamicDeviceInit ()
278: {
279: cv1.cryptsectorfirst = 0x7fffffff;
280: cv1.cryptsectorlast = 0;
281:
282: cv2.cryptsectorfirst = 0x7fffffff;
283: cv2.cryptsectorlast = 0;
284:
285: cv3.cryptsectorfirst = 0x7fffffff;
286: cv3.cryptsectorlast = 0;
287:
288: cv4.cryptsectorfirst = 0x7fffffff;
289: cv4.cryptsectorlast = 0;
290:
291: cv5.cryptsectorfirst = 0x7fffffff;
292: cv5.cryptsectorlast = 0;
293:
294: cv6.cryptsectorfirst = 0x7fffffff;
295: cv6.cryptsectorlast = 0;
296:
297: cv7.cryptsectorfirst = 0x7fffffff;
298: cv7.cryptsectorlast = 0;
299:
300: cv8.cryptsectorfirst = 0x7fffffff;
301: cv8.cryptsectorlast = 0;
302:
303: IOS_Register (&theDRP);
304: return TRUE; /* stay resident no matter what IOS says */
305: }
306:
307: BOOL
308: OnSysDynamicDeviceExit ()
309: {
310: return TRUE;
311: }
312:
313: DWORD
314: OnDeviceIoControl (PDIOCPARAMETERS p)
315: {
316: installhook (); /* make sure hook is installed */
317: InstallTCThread ();
318:
319: /* select on IOCTL code */
320: switch (p->dwIoControlCode)
321: {
322:
323: case 0: /* VWIN32 pinging us during CreateFile */
324: case -1: /* CloseHandle */
325: break;
326:
327: case ALLOW_FAST_SHUTDOWN:
328: {
329: bAllowFastShutdown = 1;
330: break;
331: }
332:
333: case DRIVER_VERSION:
334: {
335: LONG *tmp = (LONG *) p->lpvInBuffer;
336: LONG tmp2 = VERSION_NUM;
337:
338: if (tmp == NULL)
339: return ERROR_GEN_FAILURE;
340:
341: memcpy (tmp, &tmp2, 4);
342: break;
343: }
344:
345: case WIPE_CACHE:
346: WipeCache ();
347: break;
348:
349: case CACHE_STATUS:
350: return cacheEmpty ? ERROR_GEN_FAILURE : 0;
351:
352: case DISKIO: /* Call to read and write sectors from
353: application */
354: {
355: DISKIO_STRUCT *dio = (DISKIO_STRUCT *) p->lpvInBuffer;
356: int s;
357:
358: if (dio == NULL)
359: return ERROR_GEN_FAILURE;
360:
361: s = AppAccessBlockDevice (dio->devicenum, dio->sectorstart, dio->sectorlen, dio->bufferad, dio->mode);
362: dio->nReturnCode = s;
363:
364: break;
365: }
366:
367: case OPEN_TEST:
368: {
369: OPEN_TEST_STRUCT *item = (OPEN_TEST_STRUCT *) p->lpvInBuffer;
370: unsigned long *tmp = (void *) partitiontestbuffer;
371: MOUNT_STRUCT mount;
372:
373: if (item == NULL)
374: return ERROR_GEN_FAILURE;
375:
376: strcpy ((char *) mount.wszVolume, (char *) item->wszFileName);
377:
378: item->nReturnCode = ERR_BAD_DRIVE_LETTER;
379:
380: readallpartitions (&mount, TRUE);
381:
382: item->nReturnCode = mount.nReturnCode;
383:
384: item->secstart = tmp[0];
385: item->seclast = tmp[1];
386: item->device = tmp[2];
387:
388: break;
389: }
390:
391: case MOUNT_LIST_N:
392: {
393: MOUNT_LIST_N_STRUCT *item = (MOUNT_LIST_N_STRUCT *) p->lpvInBuffer;
394: cryptvol *cv;
395: int c;
396:
397: if (item == NULL)
398: return ERROR_GEN_FAILURE;
399:
400: item->nReturnCode = ERR_BAD_DRIVE_LETTER;
401:
402: for (c = 0; c < NUMSLOTS; c++)
403: {
404: cv = cryptvols[c];
405:
406: if ((cv->booted == 0) && (cv->physdevDCB == 0))
407: continue;
408:
409: if (item->nDosDriveNo == cv->drive)
410: {
411: /* 16/9/99 This is safe as
412: item->wszVolume is >
413: cv->mounted_file_name */
414: strcpy ((char *) item->wszVolume, cv->mounted_file_name);
415: item->nReturnCode = 0;
416: break;
417: }
418: }
419:
420: break;
421: }
422:
423: case RELEASE_TIME_SLICE:
424: ReleaseTimeSlice ();
425: break;
426:
427: case MOUNT:
428: {
429: MOUNT_STRUCT *mount = (MOUNT_STRUCT *) p->lpvInBuffer;
430: char tmp[9];
431:
432: if (mount == NULL)
433: return ERROR_GEN_FAILURE;
434:
435: #if EXTRA_INFO
436: _Debug_Printf_Service ("MOUNT\n");
437: #endif
438:
439: memcpy (tmp, (char *) mount->wszVolume, 8);
440: tmp[8] = 0;
441:
442: if (strcmp (tmp, "\\Device\\") == 0)
443: readallpartitions (mount, FALSE);
444: else
445: mountdiskfileR0 (mount);
446:
447: if (mount->nReturnCode == 0 && bAllowFastShutdown == 1)
448: {
449: IFSMgr_PNPEvent (DBT_DEVICEARRIVAL, mount->nDosDriveNo, PNPT_VOLUME | DBTF_MEDIA );
450: }
451:
452:
453: #if EXTRA_INFO
454: _Debug_Printf_Service ("MOUNT end\n");
455: #endif
456:
457: break;
458: }
459:
460: case UNMOUNT:
461: case UNMOUNT_PENDING:
462: {
463: UNMOUNT_STRUCT *unmount = (UNMOUNT_STRUCT *) p->lpvInBuffer;
464: cryptvol *cv;
465: int c;
466:
467: if (unmount == NULL)
468: return ERROR_GEN_FAILURE;
469:
470: unmount->nReturnCode = ERR_BAD_DRIVE_LETTER;
471:
472: for (c = 0; c < NUMSLOTS; c++)
473: {
474: cv = cryptvols[c];
475:
476: if ((cv->booted == 0) && (cv->physdevDCB == 0))
477: continue;
478:
479: if (unmount->nDosDriveNo == cv->drive)
480: {
481: if (p->dwIoControlCode == UNMOUNT_PENDING)
482: {
483: if (closeCrDevice (cv, 0) != 0)
484: unmount->nReturnCode = ERR_FILES_OPEN;
485: else
486: unmount->nReturnCode = 0;
487: }
488: else
489: {
490: if (closeCrDevice (cv, 1) != 0)
491: unmount->nReturnCode = ERR_FILES_OPEN;
492: else
493: unmount->nReturnCode = 0;
494: }
495:
496: break;
497: }
498: }
499:
500: break;
501: }
502:
503: case MOUNT_LIST:
504: {
505: MOUNT_LIST_STRUCT *list = (MOUNT_LIST_STRUCT *) p->lpvInBuffer;
506: cryptvol *cv;
507: int c;
508:
509: if (list == NULL)
510: return ERROR_GEN_FAILURE;
511:
512: list->ulMountedDrives = 0;
513:
514: for (c = 0; c < NUMSLOTS; c++)
515: {
516: int nDosDriveNo;
517:
518: cv = cryptvols[c];
519:
520: if ((cv->booted == 0) && (cv->physdevDCB == 0))
521: continue;
522:
523: nDosDriveNo = cv->drive;
524:
525: list->ulMountedDrives |= 1 << nDosDriveNo;
526:
527: if (strlen (cv->mounted_file_name) < 64)
528: {
529: strcpy ((char *) list->wszVolume[nDosDriveNo], cv->mounted_file_name);
530: }
531: else
532: {
533: memcpy ((char *) list->wszVolume[nDosDriveNo], cv->mounted_file_name, 60);
534: ((char *) list->wszVolume[nDosDriveNo])[60] = '.';
535: ((char *) list->wszVolume[nDosDriveNo])[61] = '.';
536: ((char *) list->wszVolume[nDosDriveNo])[62] = '.';
537: ((char *) list->wszVolume[nDosDriveNo])[63] = 0;
538: }
539:
540: list->cipher[nDosDriveNo] = cv->cryptoInfo->cipher;
541:
542: if(!cv->mountfilehandle)
543: list->diskLength[nDosDriveNo] = (cv->cryptsectorlast - cv->cryptsectorfirst) * 512I64;
544: else
545: list->diskLength[nDosDriveNo] = 0;
546:
547: list->cipher[nDosDriveNo] = cv->cryptoInfo->cipher;
548:
549: }
550:
551: break;
552: }
553:
554: case VOLUME_PROPERTIES:
555: {
556: VOLUME_PROPERTIES_STRUCT *prop = (VOLUME_PROPERTIES_STRUCT *) p->lpvInBuffer;
557: cryptvol *cv;
558: int c;
559:
560: if (prop == NULL)
561: return ERROR_GEN_FAILURE;
562:
563: for (c = 0; c < NUMSLOTS; c++)
564: {
565: int nDosDriveNo;
566:
567: cv = cryptvols[c];
568:
569: if ((cv->booted == 0) && (cv->physdevDCB == 0))
570: continue;
571:
572: nDosDriveNo = cv->drive;
573:
574: if (nDosDriveNo != prop->driveNo)
575: continue;
576:
577: if (strlen (cv->mounted_file_name) < 64)
578: {
579: strcpy ((char *) prop->wszVolume, cv->mounted_file_name);
580: }
581: else
582: {
583: memcpy ((char *) prop->wszVolume, cv->mounted_file_name, 60);
584: ((char *) prop->wszVolume)[60] = '.';
585: ((char *) prop->wszVolume)[61] = '.';
586: ((char *) prop->wszVolume)[62] = '.';
587: ((char *) prop->wszVolume)[63] = 0;
588: }
589:
590: prop->cipher = cv->cryptoInfo->cipher;
591:
592: if(!cv->mountfilehandle)
593: prop->diskLength = (cv->cryptsectorlast - cv->cryptsectorfirst) * 512I64;
594: else
595: prop->diskLength = 0;
596:
597: prop->cipher = cv->cryptoInfo->cipher;
598: prop->pkcs5 = cv->cryptoInfo->pkcs5;
599: prop->pkcs5Iterations = cv->cryptoInfo->noIterations;
600: prop->volumeCreationTime = cv->cryptoInfo->volume_creation_time;
601: prop->headerCreationTime = cv->cryptoInfo->header_creation_time;
602:
603: return 0;
604: }
605:
606: return ERROR_GEN_FAILURE;
607: }
608:
609:
610: default:
611: return ERROR_INVALID_FUNCTION;
612:
613: }
614:
615: return 0;
616: }
617:
618: BOOL
619: Kill_Drive (cryptvol * cv)
620: {
621: BOOL result = FALSE;
622:
623: if (cv->booted != 0 || cv->physdevDCB != 0)
624: {
625: if ((cv->drive >= 0) && (cv->drive < 26))
626: {
627: result = IspDisassociateDcb (cv->drive);
628: if (cv->mountfilehandle)
629: R0_CloseFile (cv->mountfilehandle);
630:
631: if (result == TRUE)
632: {
633: PDCB dcb;
634:
635: if (!cv->mountfilehandle)
636: unlockdrive (cv); /* files to be handled
637: by win32 app. */
638:
639: crypto_close (cv->cryptoInfo);
640:
641: dcb = cv->ldcb;
642: dcb->DCB_Port_Specific = 0;
643: memset (cv, 0, sizeof (cryptvol));
644: cv->cryptsectorfirst = 0x7fffffff;
645: }
646: }
647: }
648:
649: return result;
650: }
651:
652: int
653: closeCrDevice (cryptvol * cv, int mode)
654: {
655: if (mode == 0) /* pre flush volume call..... */
656: {
657: if (cv->drive != 0)
658: {
659: if (cv->booted <= 2)
660: {
661: _VolFlush (cv->drive, 0); /* flush stuff out
662: before the
663: dismount... */
664: //%% NotifyVolumeRemoval (cv->drive);
665: }
666: return 0;
667: }
668: else
669: return 1;
670: }
671: else
672: {
673: if (Kill_Drive (cv) == TRUE)
674: return 0;
675: else
676: return 0x42424242;
677: }
678: }
679:
680: int
681: installthread (void *t)
682: {
683: int id;
684: _asm
685: {
686: mov ecx, 4096
687: mov edi, 0
688: mov ebx,[t];
689: xor esi, esi
690: }
691:
692: VxDCall (_VWIN32_CreateRing0Thread)
693: _asm mov[id], eax
694: return id;
695: }
696:
697: void
698: sectorcopy (char *dest, char *source, int num)
699: {
700: _asm
701: {
702: pushad
703: mov edi,[dest]
704: mov esi,[source]
705: mov ecx,[num]
706: shl ecx, 9 /* *512 */
707: sar ecx, 4 /* 16 in pass... */
708: cpylp:
709: mov eax,[esi]
710: mov ebx,[esi + 4]
711: mov[edi], eax
712: mov[edi + 4], ebx
713: mov eax,[esi + 8]
714: mov ebx,[esi + 12]
715: mov[edi + 8], eax
716: mov[edi + 12], ebx
717: add edi, 16
718: add esi, 16
719: dec ecx
720: jnz cpylp
721: popad
722: }
723: }
724:
725: void
726: cryptproc (PIOP iop, cryptvol * cv)
727: {
728: PDCB dcbx;
729: unsigned int buffernum, totalsectors;
730: unsigned int sectorstart, sectorcount;
731: char *outbuffer, *bufadr, *buffercopy;
732: _BlockDev_Scatter_Gather *sgd;
733:
734: dcbx = (PDCB) iop->IOP_physical_dcb;
735: ior.IOR_status = 0;
736: if (ior.IOR_func == IOR_WRITEV)
737: {
738: ior.IOR_status = IORS_INVALID_COMMAND;
739: return;
740: }
741:
742: sectorcount = ior.IOR_xfer_count;
743:
744: if (!sectorcount)
745: {
746: ior.IOR_status = 0;
747: return;
748: }
749:
750: if ((ior.IOR_func == IOR_READ) || (ior.IOR_func == IOR_WRITE))
751: {
752: if (iop->IOP_ior.IOR_flags & IORF_CHAR_COMMAND)
753: {
754: ior.IOR_status = IORS_INVALID_COMMAND;
755: return; /* Char command NOT supported or needed.... */
756: }
757: }
758: else
759: {
760: ior.IOR_status = 0;
761: if (!cv->mountfilehandle)
762: DoCallDown (iop);
763: return;
764: }
765:
766: if (ior.IOR_func == IOR_READ)
767: {
768: sectorstart = ior.IOR_start_addr[0];
769: sectorcount = ior.IOR_xfer_count;
770: outbuffer = (char *) ior.IOR_buffer_ptr; /* may be scatter gather
771: pointer... */
772: if (ior.IOR_flags & IORF_SCATTER_GATHER)
773: {
774: sgd = (_BlockDev_Scatter_Gather *) outbuffer;
775: while ((sectorcount = sgd->BD_SG_Count))
776: {
777: outbuffer = (char *) sgd->BD_SG_Buffer_Ptr;
778: inblock (iop, outbuffer, sectorstart, sectorcount, cv);
779:
780: if (sectorstart == 0)
781: {
782: (unsigned char) outbuffer[0] = 0xeb;
783: outbuffer[1] = 0x3c;
784: (unsigned char) outbuffer[2] = 0x90;
785:
786: outbuffer[510] = 0x55; /* boot sector
787: bodge...... */
788: (unsigned char) outbuffer[511] = 0xAA;
789: }
790:
791: sectorstart += sectorcount;
792: ++sgd;
793: }
794: }
795: else
796: /* linear buffer */
797: {
798: inblock (iop, outbuffer, sectorstart, sectorcount, cv);
799:
800: /* The following code LIES to win98, who won't
801: otherwise mount disks created by earlier versions,
802: because the boot sector had stuff missing. (fixed
803: now...) */
804: if (sectorstart == 0)
805: {
806: (unsigned char) outbuffer[0] = 0xeb;
807: outbuffer[1] = 0x3c;
808: (unsigned char) outbuffer[2] = 0x90;
809: outbuffer[510] = 0x55;
810: (unsigned char) outbuffer[511] = 0xAA;
811: }
812: }
813: } /* end read op */
814: else if (ior.IOR_func == IOR_WRITE)
815: {
816: if (cv->booted == 0)
817: {
818: ior.IOR_status = 0;
819: return;
820: }
821:
822: buffernum = 0;
823:
824: bufadr = transferbuffer;
825: bufadr += (buffernum * (MAXBLOCK * 512));
826: sectorstart = ior.IOR_start_addr[0];
827: sectorcount = ior.IOR_xfer_count;
828: outbuffer = (char *) ior.IOR_buffer_ptr; /* may be scatter gather
829: pointer...; */
830: totalsectors = 0;
831: buffercopy = bufadr;
832:
833: if (ior.IOR_flags & IORF_SCATTER_GATHER)
834: {
835: sgd = (_BlockDev_Scatter_Gather *) outbuffer;
836: while ((sectorcount = sgd->BD_SG_Count))
837: {
838: outbuffer = (char *) sgd->BD_SG_Buffer_Ptr;
839: if ((totalsectors + sectorcount) <= MAXBLOCK)
840: {
841: sectorcopy (buffercopy, outbuffer, sectorcount);
842: totalsectors += sectorcount;
843: buffercopy += sectorcount * 512;
844: }
845: else
846: /* write any previous buffer..... */
847: {
848: if (totalsectors) /* was it too big to
849: start with ? */
850: {
851: outblock (iop, bufadr, sectorstart, totalsectors, cv, NULL);
852:
853: buffernum = 0;
854:
855: bufadr = transferbuffer;
856: bufadr += (buffernum * (MAXBLOCK * 512));
857: sectorstart += totalsectors;
858: totalsectors = 0;
859: buffercopy = bufadr;
860: --sgd; /* back to previous for
861: next pass..... */
862: }
863: else
864: { /* initial buffer was too
865: big, to start with! */
866: outblock (iop, outbuffer, sectorstart, sectorcount, cv, bufadr);
867:
868: buffernum = 0;
869:
870: bufadr = transferbuffer;
871: bufadr += (buffernum * (MAXBLOCK * 512));
872: sectorstart += sectorcount;
873: buffercopy = bufadr;
874: }
875:
876: }
877: ++sgd;
878: } /* end while */
879:
880: if (totalsectors)
881: outblock (iop, bufadr, sectorstart, totalsectors, cv, NULL); /* last one ? */
882: } /* end if scatter gather */
883: else
884: /* not scatter gather but is linear buffer */
885: {
886:
887: outblock (iop, outbuffer, sectorstart, sectorcount, cv, bufadr); /* get it to copy and do
888: large bit... */
889: }
890: } /* end write op */
891:
892: }
893:
894: /* DoCallBack handles completion of an I/O request by calling the previous
895: level's callback routine. */
896:
897: void
898: DoCallBack (PIOP iop)
899: {
900: _asm
901: { /* call back to previous layer */
902: pushfd
903: pushad
904: mov ecx,[iop]
905: sub[ecx] IOP.IOP_callback_ptr, size IOP_callback_entry
906: mov eax,[ecx] IOP.IOP_callback_ptr
907: push ecx
908: call[eax] IOP_callback_entry.IOP_CB_address
909: add esp, 4
910: popad
911: popfd
912:
913: }
914: }
915:
916: VOID
917: partfilerequest (PIOP iop)
918: {
919: PDCB dcb;
920: cryptvol *cv;
921:
922: dcb = (PDCB) iop->IOP_physical_dcb;
923: cv = (cryptvol *) dcb->DCB_Port_Specific;
924:
925:
926: if ((cv != &cv1) && (cv != &cv2) && (cv != &cv3) && (cv != &cv4) && (cv != &cv5) && (cv != &cv6) && (cv != &cv7) && (cv != &cv8))
927: {
928: DoCallDown (iop);
929: return;
930: }
931:
932: if (cv->booted > 2)
933: {
934: ior.IOR_status = IORS_NOT_READY; /* HW_FAILURE; */
935: DoCallBack (iop);
936: return;
937: }
938:
939: if (ior.IOR_func == IOR_COMPUTE_GEOM)
940: {
941: dcb->DCB_actual_sector_cnt[0] = cv->cryptsectorlast - cv->cryptsectorfirst;
942: dcb->DCB_actual_sector_cnt[0]++;
943: dcb->DCB_actual_sector_cnt[1] = 0;
944: dcb->DCB_actual_blk_size = 512;
945: dcb->DCB_actual_head_cnt = 1; /* number of heads */
946: dcb->DCB_actual_cyl_cnt = 1; /* number of cylinders */
947: dcb->DCB_cmn.DCB_apparent_blk_shift = 9;
948: dcb->DCB_cmn.DCB_TSD_Flags |= DCB_TSD_ACTUAL_PRE_SET;
949: ior.IOR_status = IORS_SUCCESS;
950: DoCallBack (iop);
951: return;
952: }
953:
954: if (ior.IOR_func == IOR_GEN_IOCTL)
955: {
956: iop->IOP_ior.IOR_ioctl_return = 01;
957: ior.IOR_status = IORS_INVALID_PARM; /* All the time now.... */
958: DoCallBack (iop);
959: return;
960: }
961:
962: if ((ior.IOR_func == IOR_READ) || (ior.IOR_func == IOR_WRITE))
963: {
964: dcb = (PDCB) iop->IOP_physical_dcb;
965: ior.IOR_status = IORS_CMD_IN_PROGRESS; /* 0 */
966:
967: dcb->DCB_cmn.DCB_device_flags |= DCB_DEV_IO_ACTIVE;
968: QueueMyIop (iop);
969: return;
970: }
971:
972: if ((ior.IOR_func == IOR_MEDIA_CHECK) || (ior.IOR_func == IOR_MEDIA_CHECK_RESET))
973: {
974: dcb = (PDCB) iop->IOP_original_dcb;
975:
976: ior.IOR_status = IORS_UNCERTAIN_MEDIA; /* IORS_SUCCESS; */
977: DoCallBack (iop);
978: return;
979: }
980:
981: ior.IOR_status = IORS_INVALID_COMMAND;
982: DoCallBack (iop);
983: return;
984: }
985:
986: int
987: Add_Drive (PDCB dcb, cryptvol * cv, int prefdrive)
988: {
989: int md = 0;
990: PDCB ldcb;
991: unsigned int flags;
992: unsigned int dmdbits;
993: ldcb = &cv->logicaldcb;
994: cv->ldcb = ldcb;
995:
996: #if EXTRA_INFO
997: _Debug_Printf_Service ("Add_Drive\n");
998: #endif
999:
1000: if (1)
1001: {
1002: ldcb = &cv->logicaldcb;
1003: flags = ldcb->DCB_cmn.DCB_device_flags;
1004:
1005: if (dcb)
1006: memcpy ((char *) ldcb, (char *) dcb, sizeof (DCB));
1007:
1008: ldcb->DCB_cmn.DCB_device_flags = flags;
1009: flags = dcb->DCB_cmn.DCB_device_flags;
1010: dmdbits = dcb->DCB_cmn.DCB_dmd_flags;
1011: dmdbits &= ~DCB_dmd_phys_sgd;
1012: cv->ldcb = ldcb;
1013: if (!cv->mountfilehandle)
1014: IspInsertCalldown (ldcb, partfilerequest, (PDDB) & cv->addb,
1015: (USHORT) dcb->DCB_cmn.DCB_expansion_length,
1016: dmdbits, (UCHAR) DRP_VSD_3);
1017: else
1018: IspInsertCalldown (ldcb, partfilerequest, (PDDB) & cv->addb, 0,
1019: 0, (UCHAR) DRP_VSD_3);
1020:
1021: ldcb->DCB_Port_Specific = (ULONG) cv;
1022: ldcb->DCB_cmn.DCB_physical_dcb = (ULONG) ldcb;
1023: ldcb->DCB_max_xfer_len = MAXBLOCK * 512; /* 256*512 */
1024:
1025: if ((dcb->DCB_max_xfer_len < MAXBLOCK * 512) && (cv->mountfilehandle == 0))
1026: ldcb->DCB_max_xfer_len = dcb->DCB_max_xfer_len;
1027:
1028: if (!cv->mountfilehandle)
1029: {
1030: ldcb->DCB_max_sg_elements = dcb->DCB_max_sg_elements; /* 1; */
1031: ldcb->DCB_cmn.DCB_expansion_length = dcb->DCB_cmn.DCB_expansion_length;
1032: ldcb->DCB_cmn.DCB_dmd_flags = dmdbits;
1033: }
1034: else
1035: ldcb->DCB_max_sg_elements = 17;
1036:
1037: ldcb->DCB_cmn.DCB_device_flags |= DCB_DEV_PHYSICAL;
1038: ldcb->DCB_cmn.DCB_device_flags2 = 0;
1039: ldcb->DCB_cmn.DCB_device_flags &= ~DCB_DEV_REMOVABLE; /* support removable as
1040: fixed... */
1041: ldcb->DCB_cmn.DCB_device_type = DEVICE_TYPE;
1042: ldcb->DCB_cmn.DCB_user_drvlet = (USHORT) md;
1043: ldcb->DCB_cmn.DCB_partition_type = 0;
1044: ldcb->DCB_cmn.DCB_Sstor_Host = 0;
1045: ldcb->DCB_actual_sector_cnt[0] = 0;
1046: ldcb->DCB_actual_sector_cnt[0]++;
1047: ldcb->DCB_actual_sector_cnt[1] = 0;
1048: ldcb->DCB_actual_blk_size = 512;
1049: ldcb->DCB_actual_head_cnt = 1; /* number of heads */
1050: ldcb->DCB_actual_cyl_cnt = 1; /* number of cylinders */
1051: ldcb->DCB_cmn.DCB_apparent_blk_shift = 9;
1052: ldcb->DCB_actual_spt = ldcb->DCB_actual_sector_cnt[0];
1053: ldcb->DCB_bdd.DCB_apparent_sector_cnt[0] = ldcb->DCB_actual_sector_cnt[0];
1054: ldcb->DCB_bdd.DCB_apparent_sector_cnt[1] = 0;
1055: ldcb->DCB_bdd.DCB_apparent_head_cnt = 1;
1056: ldcb->DCB_bdd.DCB_apparent_blk_size = 512;
1057: ldcb->DCB_bdd.DCB_apparent_cyl_cnt = 1;
1058: ldcb->DCB_bdd.DCB_apparent_spt = ldcb->DCB_actual_sector_cnt[0];
1059: }
1060:
1061: ldcb->DCB_cmn.DCB_drive_lttr_equiv = 0;
1062: ldcb->DCB_cmn.DCB_user_drvlet = 0;
1063: ldcb->DCB_cmn.DCB_device_type = DEVICE_TYPE;
1064:
1065: if (prefdrive != -1)
1066: md = IspDriveLetterPickPref (ldcb, (UCHAR) ISP_PDL_FL_USE_RANGE, (UCHAR) prefdrive);
1067: else
1068: md = (unsigned char) 255;
1069:
1070:
1071: if (md == 255)
1072: md = IspDriveLetterPick (ldcb, 0);
1073:
1074: ldcb->DCB_cmn.DCB_unit_number = (UCHAR) md;
1075: ldcb->DCB_cmn.DCB_vrp_ptr = 0; /* clear the copied VRP pointer...... */
1076: ldcb->DCB_cmn.DCB_device_flags |= DCB_DEV_WRITEABLE;
1077:
1078: if (!(flags & DCB_DEV_WRITEABLE))
1079: ldcb->DCB_cmn.DCB_device_flags &= ~DCB_DEV_WRITEABLE;
1080:
1081: ldcb->DCB_cmn.DCB_drive_lttr_equiv = md;
1082: ldcb->DCB_cmn.DCB_user_drvlet = (UCHAR) md;
1083: ldcb->DCB_cmn.DCB_unit_number = (UCHAR) md; /* 0; */
1084:
1085: cv->drive = (ULONG) md;
1086: ldcb->DCB_cmn.DCB_TSD_Flags = DCB_TSD_APPARENT_PRE_SET | DCB_TSD_MBPB_PBR;
1087: ldcb->DCB_cmn.DCB_partition_type = 0;
1088: ldcb->DCB_cmn.DCB_device_flags &= ~DCB_DEV_TSD_PROCESSED;
1089: ldcb->DCB_cmn.DCB_Partition_Start = 0;
1090: ldcb->DCB_cmn.DCB_device_flags |= DCB_DEV_LOGICAL | DCB_DEV_MEDIA_CHANGED | DCB_DEV_UNCERTAIN_MEDIA;
1091:
1092: ldcb->DCB_cmn.DCB_cAssoc = 1;
1093:
1094: ldcb->DCB_cmn.DCB_user_drvlet = 0xFF;
1095:
1096: #if EXTRA_INFO
1097: _Debug_Printf_Service ("Add_Drive end\n");
1098: #endif
1099:
1100: if ((md <= 26) && (md > 1))
1101: {
1102: IspAssociateDcb (ldcb, (char) md, ISP_D_A_FL_NOSHELLMSG);
1103:
1104: cv->notifytime = 2; /* 2 second to notify arrival of disk */
1105:
1106: return 0;
1107: }
1108:
1109: return 1;
1110: }
1111:
1112: #define FIRST_READ_SIZE SECTOR_SIZE
1113:
1114: int
1115: trymountfile (PDCB dcb, cryptvol * cv, MOUNT_STRUCT * mf)
1116: {
1117: USHORT offset;
1118: USHORT size;
1119: PIOP myiop;
1120: PIOR myior;
1121: int mounted = 0;
1122: char *readBuffer = NULL;
1123:
1124: if (dcb->DCB_cmn.DCB_device_type == DCB_type_disk)
1125: {
1126: int status;
1127:
1128: offset = (USHORT) (dcb->DCB_cmn.DCB_expansion_length + FIELDOFFSET (IOP, IOP_ior));
1129: size = offset + sizeof (IOR) + dcb->DCB_max_sg_elements * sizeof (SGD);
1130: myiop = IspCreateIop (size, offset, ISP_M_FL_MUST_SUCCEED | ISP_M_FL_SMART_ALLOC | ISP_M_FL_INTERRUPT_TIME | ISP_M_FL_PERSISTENT_IOP);
1131: myior = &myiop->IOP_ior;
1132: myior->IOR_private_client = offset;
1133:
1134: readBuffer = TCalloc (FIRST_READ_SIZE);
1135: if (readBuffer == NULL)
1136: goto error;
1137:
1138: dophysblock (myiop, cv->cryptsectorfirst, FIRST_READ_SIZE / 512, readBuffer, cv, IOR_READ);
1139:
1140: status = VolumeReadHeaderCache (mf->bCache, readBuffer, mf->szPassword,
1141: mf->nPasswordLen, &cv->cryptoInfo);
1142:
1143: if (status != 0)
1144: {
1145: memset (cv, 0, sizeof (cryptvol));
1146: cv->cryptsectorfirst = 0x7fffffff;
1147: mounted = 0;
1148: goto error;
1149: }
1150: else
1151: cv->booted = 1;
1152:
1153: if (Add_Drive (dcb, cv, mf->nDosDriveNo) == 0)
1154: {
1155: mounted = 1;
1156: }
1157: else
1158: {
1159: /* No Drive letter available */
1160: memset (cv, 0, sizeof (cryptvol));
1161: cv->cryptsectorfirst = 0x7fffffff;
1162: mounted = -1;
1163: }
1164:
1165: error:
1166: if (readBuffer != NULL)
1167: TCfree (readBuffer);
1168:
1169: IspDeallocMem ((PVOID) ((DWORD) myior - myior->IOR_private_client));
1170: return mounted;
1171: }
1172:
1173: return mounted;
1174: }
1175:
1176: void
1177: readnullfilesize (int hand)
1178: {
1179: int bytes;
1180: char buffer[512];
1181: R0_ReadFile (FALSE, hand, 0, 0, buffer, &bytes);
1182: }
1183:
1184: void
1185: mountdiskfileR0 (MOUNT_STRUCT * mf)
1186: {
1187: DWORD hfile;
1188: DWORD action;
1189: int tmf;
1190: int code;
1191: cryptvol *cv;
1192: int c;
1193: int writeable = 1;
1194: PDCB dcb;
1195: int flag = 0;
1196: unsigned char openflag = 0x81;
1197:
1198: char *fname = (char *) mf->wszVolume;
1199:
1200:
1201: installhook (); /* only installs if not done already... */
1202:
1203: for (c = 0; c < NUMSLOTS; c++)
1204: {
1205: cv = cryptvols[c];
1206: if (strcmp (fname, (char *) &cv->mounted_file_name) == 0)
1207: {
1208: flag = 3 + 128; /* already present */
1209: goto done;
1210: }
1211: }
1212:
1213: if (writeable)
1214: {
1215: code = R0_OpenCreateFile (FALSE, ACCESS_READWRITE | SHARE_DENYREADWRITE,
1216: 0, ACTION_OPENEXISTING, 0x81, fname, &hfile, &action); /* R0_NO_CACHE(UBYTE)
1217: ((R0_NO_CACHE)>>8) */
1218:
1219: if (code != 0)
1220: {
1221: writeable = 0;
1222: code = R0_OpenCreateFile (FALSE, ACCESS_READONLY | SHARE_DENYREAD,
1223: 0, ACTION_OPENEXISTING, 0x81, fname, &hfile, &action); /* R0_NO_CACHE(UBYTE)
1224: ((R0_NO_CACHE)>>8) */
1225: }
1226:
1227: if (code == 0)
1228: readnullfilesize (hfile);
1229: }
1230: else
1231: {
1232: code = R0_OpenCreateFile (FALSE, ACCESS_READONLY | SHARE_DENYREAD,
1233: 0, ACTION_OPENEXISTING, 0x81, fname, &hfile, &action); /* R0_NO_CACHE(UBYTE)
1234: ((R0_NO_CACHE)>>8) */
1235:
1236: if (code == 0)
1237: readnullfilesize (hfile);
1238: }
1239:
1240: if (code != 0)
1241: {
1242: flag = 1;
1243: goto done;
1244: }
1245:
1246: for (c = 0; c < NUMSLOTS; c++)
1247: {
1248: cv = cryptvols[c];
1249:
1250: if ((cv->booted == 0) && (cv->physdevDCB == 0))
1251: {
1252: cv->filehostdcb = 0;
1253: cv->mountfilehandle = hfile;
1254: cv->physdevDCB = &cv->logicaldcb;
1255: cv->cryptsectorfirst = 0x00000000;
1256: cv->cryptsectorlast = 0x7ffffff0;
1257: dcb = (PDCB) cv->physdevDCB;
1258: flag = 2;
1259:
1260: if (writeable != 0)
1261: dcb->DCB_cmn.DCB_device_flags = DCB_DEV_WRITEABLE;
1262:
1263: /* clears cv set above if failed.... */
1264: tmf = trymountfile (dcb, cv, mf);
1265:
1266: if (tmf)
1267: {
1268: _asm cli
1269: flag = 3;
1270:
1271: mf->nReturnCode = flag;
1272:
1273: if (tmf > 0) /* if tmg is -ve then no
1274: drive letter (already had
1275: blue screen..) */
1276: {
1277: mf->nReturnCode = flag;
1278:
1279: cv->booted = 2;
1280: strcpy ((char *) &cv->mounted_file_name, fname);
1281:
1282: goto done;
1283: }
1284: } /* trymountfile */
1285:
1286: } /* if cv->.... */
1287:
1288: if (flag)
1289: break; /* out of for loop */
1290: }
1291:
1292:
1293: R0_CloseFile (hfile);
1294:
1295: done:
1296:
1297: switch (flag)
1298: {
1299: case 3 + 128:
1300: mf->nReturnCode = ERR_VOL_ALREADY_MOUNTED;
1301: break;
1302: case 1:
1303: mf->nReturnCode = ERR_FILE_OPEN_FAILED;
1304: break;
1305: case 2:
1306: mf->nReturnCode = ERR_VOL_MOUNT_FAILED;
1307: break;
1308: case 3:
1309: if (tmf > 0)
1310: {
1311: mf->nReturnCode = 0;
1312: mf->nDosDriveNo = cv->drive;
1313: }
1314: else
1315: mf->nReturnCode = ERR_NO_FREE_DRIVES;
1316: break;
1317: case 0:
1318: mf->nReturnCode = ERR_NO_FREE_SLOTS;
1319: break;
1320: }
1321: }
1322:
1323:
1324: void
1325: outblock (PIOP iop, char *outbuffer, int sectorstart, int sectorcount, cryptvol * cv, char *workbuff)
1326: {
1327: int logsec = sectorstart + 1; /* get logical volume sector. */
1328:
1329: char *sendbuffer;
1330:
1331: if (!sectorcount)
1332: return;
1333:
1334: do
1335: {
1336: if (sectorcount <= MAXBLOCK)
1337: {
1338: sendbuffer = outbuffer;
1339:
1340: /* if copyflag 0, then buffer already set by caller. */
1341: ior.IOR_status = 0;
1342: if (workbuff)
1343: {
1344: sectorcopy (workbuff, outbuffer, sectorcount);
1345: sendbuffer = workbuff;
1346: }
1347:
1348: writelogical (iop, logsec, sectorcount, sendbuffer, cv);
1349:
1350: sectorcount = 0;
1351: return;
1352: }
1353: else
1354: {
1355: sendbuffer = outbuffer;
1356: if (workbuff)
1357: {
1358: sectorcopy (workbuff, outbuffer, MAXBLOCK);
1359: sendbuffer = workbuff;
1360: }
1361:
1362: writelogical (iop, logsec, MAXBLOCK, sendbuffer, cv);
1363: logsec += MAXBLOCK;
1364: sectorcount -= MAXBLOCK;
1365: outbuffer += (MAXBLOCK * 512);
1366: }
1367: }
1368: while ((sectorcount > 0) && (ior.IOR_status < 16));
1369: }
1370:
1371: void
1372: inblock (PIOP iop, char *outbuffer, int sectorstart, int sectorcount, cryptvol * cv)
1373: {
1374: int logsec = sectorstart + 1; /* get logical volume sector. */
1375:
1376: do
1377: {
1378: ior.IOR_status = 0;
1379: if (sectorcount < MAXBLOCK)
1380: {
1381: readlogical (iop, logsec, sectorcount, (char *) transferbuffer, cv);
1382: memcpy (outbuffer, transferbuffer, sectorcount * 512);
1383: sectorcount = 0;
1384: return;
1385: }
1386: else
1387: {
1388: readlogical (iop, logsec, MAXBLOCK, (char *) transferbuffer, cv);
1389: memcpy (outbuffer, transferbuffer, MAXBLOCK * 512);
1390: logsec += MAXBLOCK;
1391: sectorcount -= MAXBLOCK;
1392: outbuffer += (MAXBLOCK * 512);
1393: }
1394: }
1395: while ((sectorcount > 0) && (ior.IOR_status < 16));
1396: }
1397:
1398: int
1399: doR0fileio (int sector, int numsectors, char *buffer, cryptvol * cv, int iorop)
1400: {
1401: CLIENT_STRUCT sregs; /* static */
1402: PVRP v;
1403:
1404: int res;
1405: int bytes; /* static */
1406:
1407:
1408: if (iorop == IOR_READ)
1409: {
1410: if (numsectors)
1411: {
1412: SaveClientState ((CLIENT_STRUCT *) & sregs);
1413:
1414: res = R0_ReadFile (FALSE, cv->mountfilehandle, numsectors << 9, sector << 9, buffer, &bytes);
1415:
1416: RestoreClientState ((CLIENT_STRUCT *) & sregs);
1417: }
1418:
1419: return res;
1420: } /* IOR read */
1421:
1422: res = 0;
1423: if (iorop == IOR_WRITE)
1424: {
1425: if (numsectors)
1426: {
1427: SaveClientState ((CLIENT_STRUCT *) & sregs);
1428:
1429: res = R0_WriteFile (FALSE, cv->mountfilehandle, numsectors * 512, sector * 512, buffer, &bytes);
1430:
1431: RestoreClientState ((CLIENT_STRUCT *) & sregs);
1432: }
1433:
1434: if (res)
1435: {
1436: if (res == 5)
1437: res = 0x13; /* WHY ARE WE GETTING ACCESS
1438: DENIED 005 ON CD RATHER
1439: THAN WP ? */
1440:
1441: if (res == 0x13)
1442: {
1443: if (cv->booted >= 2)
1444: {
1445: v = (PVRP) cv->ldcb->DCB_cmn.DCB_vrp_ptr;
1446: if (v)
1447: {
1448: if ((v->VRP_event_flags & VRP_ef_write_protected) == 0)
1449: {
1450: v->VRP_event_flags |= VRP_ef_write_protected | VRP_ef_media_uncertain;
1451: }
1452: }
1453: } /* cv->booted */
1454: } /* res=13 */
1455: } /* res= something */
1456:
1457: return res;
1458: } /* IOR write */
1459:
1460: return 0;
1461: }
1462:
1463: int
1464: MapDosError (int error)
1465: {
1466: int e;
1467:
1468: if (error == 0x13)
1469: return (IORS_WRITE_PROTECT);
1470:
1471: e = IORS_NOT_READY; /* IORS_HW_FAILURE; */
1472: return e;
1473: }
1474:
1475: char fileerrorstr[]=
1476: {
1477: "TC has encountered an error reading a host file which\n"
1478: "it is using for a currently open scrambled disk volume.\n\n"
1479: "You should immediately dismount the file using the TC mount\n"
1480: "application, correct the error, and re mount the disk image file.\n\n\n"
1481: "The related disk will be unavailable, until you do, and you should\n"
1482: "save your work elsewhere."
1483: };
1484:
1485: int
1486: dophysblock2 (PIOP iop, int sector, int numsectors, char *buffr, cryptvol * cv, USHORT iorop)
1487: {
1488: int rstatus = 0; /* status return value.... */
1489: PIOP myiop;
1490: PIOR myior;
1491:
1492: _BlockDev_Scatter_Gather *sgd;
1493:
1494: PDCB mydcb = cv->physdevDCB; /* (PDCB) iop->IOP_physical_dcb; */
1495: USHORT offset;
1496: USHORT size;
1497:
1498: if (cv->mountfilehandle)
1499: {
1500: if (cv->booted <= 2)
1501: rstatus = doR0fileio (sector, numsectors, buffr, cv, iorop);
1502: else
1503: rstatus = 23;
1504:
1505: if ((rstatus) && (rstatus != 0x13))
1506: {
1507: iop->IOP_timer = iop->IOP_timer_orig = 32000;
1508: rstatus = MapDosError (rstatus);
1509:
1510: if (cv->booted <= 2 && (cv->booted))
1511: {
1512: Post_message (fileerrorstr, "TC: Mounted file error");
1513: cv->booted = 256;
1514: }
1515: }
1516:
1517: iop->IOP_ior.IOR_status = rstatus;
1518: return rstatus;
1519: }
1520:
1521: /* End up here, if we are handling a disk partition rather than
1522: container file */
1523: offset = (USHORT) (mydcb->DCB_cmn.DCB_expansion_length + FIELDOFFSET (IOP, IOP_ior));
1524: size = offset + sizeof (IOR) + (8 * sizeof (SGD));
1525: iop->IOP_timer = iop->IOP_timer_orig = 160;
1526:
1527: myiop = IspCreateIop (size, offset, ISP_M_FL_SMART_ALLOC);
1528:
1529: if (myiop == NULL)
1530: {
1531:
1532: iop->IOP_ior.IOR_status = IORS_MEMORY_ERROR;
1533: return IORS_MEMORY_ERROR;
1534: }
1535:
1536: myior = &myiop->IOP_ior;
1537:
1538: /* Be aware that Criteria routine reads it's dmd bits from THIS dcb! */
1539:
1540: myiop->IOP_original_dcb = (ULONG) mydcb; /* iop->IOP_original_dcb;
1541: (ULONG) mydcb; */
1542: myiop->IOP_physical_dcb = (ULONG) mydcb->DCB_cmn.DCB_physical_dcb;
1543: if (cv->booted == 1)
1544: cv->booted = 2; /* Irrelevant here..... */
1545: myior->IOR_next = 0;
1546: myior->IOR_start_addr[1] = 0;
1547: myior->IOR_flags = IORF_VERSION_002;
1548: myior->IOR_private_client = offset;
1549: myior->IOR_req_vol_handle = mydcb->DCB_cmn.DCB_vrp_ptr;
1550: myior->IOR_sgd_lin_phys = (ULONG) (myior + 1);
1551: myior->IOR_num_sgds = 0;
1552: myior->IOR_vol_designtr = mydcb->DCB_cmn.DCB_unit_number;
1553: myior->IOR_func = iorop;
1554: myior->IOR_flags |= IORF_BYPASS_VOLTRK | IORF_HIGH_PRIORITY | IORF_SCATTER_GATHER | IORF_SYNC_COMMAND | IORF_DONT_CACHE;
1555: if (iorop == IOR_READ)
1556: myior->IOR_flags |= IORF_DATA_IN;
1557: if (iorop == IOR_WRITE)
1558: myior->IOR_flags |= IORF_DATA_OUT;
1559: myior->IOR_start_addr[0] = sector;
1560: myior->IOR_xfer_count = numsectors;
1561: sgd = (_BlockDev_Scatter_Gather *) myior->IOR_sgd_lin_phys; /* scatter gather
1562: array... */
1563: sgd->BD_SG_Buffer_Ptr = (ULONG) buffr; /* Buffer in LOCKED ram,
1564: below 16mbyte, 4K
1565: boundary.. */
1566: sgd->BD_SG_Count = numsectors;
1567: myior->IOR_buffer_ptr = (ULONG) sgd; /* Implement as Scatter
1568: gather, with One block */
1569: sgd++;
1570: sgd->BD_SG_Buffer_Ptr = 0;
1571: sgd->BD_SG_Count = 0;
1572: sgd++;
1573: myior->IOR_sgd_lin_phys = (ULONG) sgd;
1574: rstatus = myior->IOR_status;
1575: sgd->BD_SG_Buffer_Ptr = 0;
1576: sgd->BD_SG_Count = 0;
1577: sgd++;
1578: sgd->BD_SG_Buffer_Ptr = 0;
1579: sgd->BD_SG_Count = 0;
1580: sgd++;
1581: sgd->BD_SG_Buffer_Ptr = 0;
1582: sgd->BD_SG_Count = 0;
1583: myiop->IOP_timer = 40;
1584: myiop->IOP_timer_orig = 40;
1585: /* Call criteria, to set phys SGDs physical addresses if needed..... */
1586: if (IlbIntIoCriteria (myiop))
1587: myior->IOR_flags |= IORF_DOUBLE_BUFFER; /* Double buffer, will
1588: also make no
1589: difference */
1590: IlbInternalRequest (myiop, mydcb, OnRequest);
1591: rstatus = myior->IOR_status;
1592: iop->IOP_ior.IOR_status = rstatus; /* myior->IOR_status; */
1593: IspDeallocMem ((PVOID) ((DWORD) myior - myior->IOR_private_client));
1594: return rstatus;
1595: }
1596:
1597: int
1598: dophysblock (PIOP iop, int sector, int numsectors, char *buffr, cryptvol * cv, USHORT iorop)
1599: {
1600: int s, c;
1601:
1602: for (c = 0; c < 3; c++)
1603: {
1604: s = dophysblock2 (iop, sector, numsectors, buffr, cv, iorop);
1605: if (s == IORS_SUCCESS_WITH_RETRY)
1606: return 0;
1607: if (!s)
1608: return 0;
1609: }
1610:
1611: return s;
1612: }
1613:
1614: void
1615: readlogical (PIOP iop, int temp_block, int num_sectors, char *buffer, cryptvol * cv)
1616: {
1617: int secNum;
1618:
1619: secNum = temp_block;
1620:
1621: #if EXTRA_INFO
1622: _Debug_Printf_Service ("secNum=%d,num_sectors=%d\n", secNum, num_sectors);
1623: #endif
1624:
1625: dophysblock (iop, secNum + cv->cryptsectorfirst, num_sectors, buffer, cv, IOR_READ);
1626:
1627: #if EXTRA_INFO
1628: _Debug_Printf_Service ("0x%08x\n", *((int *) buffer));
1629: #endif
1630:
1631: cv->cryptoInfo->decrypt_sector ((unsigned long *) buffer,
1632: (unsigned __int64) secNum, num_sectors,
1633: &cv->cryptoInfo->ks[0],
1634: cv->cryptoInfo->iv,
1635: cv->cryptoInfo->cipher);
1636:
1637: #if EXTRA_INFO
1638: _Debug_Printf_Service ("0x%08x\n", *((int *) buffer));
1639: #endif
1640:
1641: }
1642:
1643: void
1644: writelogical (PIOP iop, int temp_block, int num_sectors, char *buffer, cryptvol * cv)
1645: {
1646: int secNum;
1647:
1648: secNum = temp_block;
1649:
1650: #if EXTRA_INFO
1651: _Debug_Printf_Service ("0x%08x\n", *((int *) buffer));
1652: #endif
1653:
1654: cv->cryptoInfo->encrypt_sector ((unsigned long *) buffer,
1655: (unsigned __int64) secNum, num_sectors,
1656: &cv->cryptoInfo->ks[0],
1657: cv->cryptoInfo->iv,
1658: cv->cryptoInfo->cipher);
1659:
1660: #if EXTRA_INFO
1661: _Debug_Printf_Service ("0x%08x\n", *((int *) buffer));
1662: #endif
1663:
1664: dophysblock (iop, secNum + cv->cryptsectorfirst, num_sectors, buffer, cv, IOR_WRITE);
1665: }
1666:
1667:
1668: BOOL
1669: OnSystemExit (void)
1670: {
1671: /* Called when Win32 is about to die. We must close down the files,
1672: for any files mounted as encrypted disks. this call seems to be
1673: the only chance we get. the system pukes amd hangsif we don't.
1674: Corrupt screen etc. nd refuses to shut down..... */
1675:
1676: cryptvol *cv;
1677: int c;
1678:
1679: for (c = 0; c < NUMSLOTS; c++)
1680: {
1681: cv = cryptvols[c];
1682: unlockdrive (cv);
1683: if (cv->mountfilehandle)
1684: R0_CloseFile (cv->mountfilehandle);
1685: }
1686:
1687: killthread ();
1688: return AEP_SUCCESS;
1689: }
1690:
1691: void
1692: Post_message (char *msg, char *header)
1693: {
1694: MessageBox *m;
1695: int n;
1696:
1697: for (n = 0; n < MAX_MESSAGES - 1; n++)
1698: {
1699: m = &Msgs[n];
1700: if (m->PostPlease == 0)
1701: break;
1702:
1703: }
1704:
1705: m->PostPlease = 1;
1706: m->MessageHdr = header;
1707: m->MessageBody = msg;
1708: }
1709:
1710: void
1711: ProcessWinMessagesBlueScreen (void)
1712: {
1713: MessageBox *m;
1714: int n;
1715:
1716: for (n = 0; n < MAX_MESSAGES; n++)
1717: {
1718: m = &Msgs[n];
1719: if (m->PostPlease)
1720: {
1721: ShellMessageNCB (0, m->MessageBody, m->MessageHdr);
1722: m->PostPlease = 0;
1723: }
1724: }
1725: }
1726:
1727: /* The code below gets called by the IOS *every* 0.5 seconds... */
1728: USHORT
1729: OnHalfSec (PAEP_boot_done aep) /* dummy param */
1730: {
1731: #if 0
1732: cryptvol *cv;
1733: int c;
1734: int notified = 0;
1735: #endif
1736:
1737: halfseccount++;
1738:
1739: ProcessWinMessagesBlueScreen ();
1740:
1741: #if 0
1742: for (c = 0; c < 8; c++)
1743: {
1744: cv = cryptvols[c];
1745:
1746: if (cv->notifytime)
1747: {
1748: cv->notifytime--;
1749: if (cv->notifytime == 0)
1750: {
1751: cv->notifytime = 0x8000ffff;
1752: if (!notified) /* prevent multiple notifications */
1753: {
1754: notified++;
1755: SHELL_CallAtAppyTime ((APPY_CALLBACK) & drivearrived, 0, 0);
1756: }
1757: }
1758:
1759: }
1760: }
1761: #endif
1762:
1763: return AEP_SUCCESS;
1764: }
1765:
1766:
1767: /* ------------------------------------partition support
1768: ------------------------------------------- */
1769:
1770: /* go round every drive reading all the partitions.... */
1771: void
1772: readallpartitions (MOUNT_STRUCT * mf, BOOL bVerifyOnly)
1773: {
1774: int c = 0;
1775: PDCB dcb;
1776: USHORT offset;
1777: USHORT size;
1778: PIOP myiop;
1779: PIOR myior;
1780: int x, disks, z;
1781: char *vol = (char *) mf->wszVolume;
1782:
1783: mf->nReturnCode = ERR_INVALID_DEVICE; /* Assume failure */
1784:
1785: if (strlen ((char *) mf->wszVolume) < 28)
1786: return;
1787:
1788: x = vol[16] - '0'; /* Disk number starting from 0 */
1789: z = vol[27] - '0'; /* Partition number start from 1 */
1790: disks = 0; /* Count of disks */
1791:
1792: if (x < 0 || z < 1)
1793: return;
1794:
1795: #if EXTRA_INFO
1796: _Debug_Printf_Service ("readallpartitions\n");
1797: #endif
1798:
1799: while (dcb = dcblist[++c])
1800: {
1801: if ((dcb->DCB_cmn.DCB_device_type == 0) && (dcb->DCB_cmn.DCB_apparent_blk_shift == 9))
1802: {
1803: if (x != disks++)
1804: continue;
1805:
1806: offset = (USHORT) (dcb->DCB_cmn.DCB_expansion_length + FIELDOFFSET (IOP, IOP_ior));
1807: size = offset + sizeof (IOR) + dcb->DCB_max_sg_elements * sizeof (SGD);
1808: myiop = IspCreateIop (size, offset, ISP_M_FL_MUST_SUCCEED | ISP_M_FL_SMART_ALLOC | ISP_M_FL_INTERRUPT_TIME | ISP_M_FL_PERSISTENT_IOP);
1809: myior = &myiop->IOP_ior;
1810: myior->IOR_private_client = offset;
1811:
1812: DiskRead (dcb, myiop, 0, 1, partitiontestbuffer, IOR_READ); /* ;single read in case
1813: of media change... */
1814: memset (partitiontestbuffer, 0, 512);
1815:
1816: if (!DiskRead (dcb, myiop, 0, 1, partitiontestbuffer, IOR_READ)) /* +32768 */
1817: {
1818: UsePartitionInfo (dcb, myiop, partitiontestbuffer, 0, 0, &z, mf, bVerifyOnly); /* +32768 */
1819: }
1820:
1821: IspDeallocMem ((PVOID) ((DWORD) myior - myior->IOR_private_client));
1822:
1823: }
1824: }
1825:
1826: #if EXTRA_INFO
1827: _Debug_Printf_Service ("readallpartitions end\n");
1828: #endif
1829:
1830: }
1831:
1832:
1833: int
1834: DiskRead (PDCB mydcb, PIOP myiop, unsigned int sector, unsigned int numsectors, char *buffr, USHORT iorop)
1835: {
1836: int rstatus = 0; /* status return value.... */
1837: unsigned long *errnl = (unsigned long *) buffr; /* no load test... */
1838: PIOR myior;
1839: _BlockDev_Scatter_Gather *sgd;
1840:
1841: myior = &myiop->IOP_ior;
1842: myiop->IOP_original_dcb = (ULONG) mydcb;
1843: myiop->IOP_physical_dcb = (ULONG) mydcb->DCB_cmn.DCB_physical_dcb;
1844: myior->IOR_next = 0;
1845: myior->IOR_start_addr[1] = 0;
1846: myior->IOR_flags = IORF_VERSION_002;
1847: myior->IOR_req_vol_handle = mydcb->DCB_cmn.DCB_vrp_ptr;
1848: myior->IOR_sgd_lin_phys = (ULONG) (myior + 1);
1849: myior->IOR_num_sgds = 0;
1850: myior->IOR_vol_designtr = mydcb->DCB_cmn.DCB_unit_number;
1851: myior->IOR_func = iorop;
1852: myior->IOR_flags |= IORF_BYPASS_VOLTRK | IORF_HIGH_PRIORITY | IORF_SCATTER_GATHER | IORF_SYNC_COMMAND;
1853: if (iorop == IOR_READ)
1854: {
1855: myior->IOR_flags |= IORF_DATA_IN;
1856: memset (buffr, 0, numsectors * 512);
1857: errnl[0] = 0xACE01DE4;
1858: errnl[1] = 0xEDB0CD01;
1859: errnl[2] = 0x4caf3321;
1860: errnl[3] = 0xa35a32c4;
1861: }
1862:
1863: if (iorop == IOR_WRITE)
1864: myior->IOR_flags |= IORF_DATA_OUT;
1865: myior->IOR_start_addr[0] = sector;
1866: myior->IOR_xfer_count = numsectors;
1867: myior->IOR_buffer_ptr = (ULONG) buffr;
1868:
1869: sgd = (_BlockDev_Scatter_Gather *) myior->IOR_sgd_lin_phys; /* scatter gather
1870: array... */
1871: sgd->BD_SG_Buffer_Ptr = (ULONG) buffr; /* Buffer in LOCKED ram,
1872: below 16mbyte, 4K
1873: boundary.. */
1874: sgd->BD_SG_Count = numsectors;
1875: myior->IOR_buffer_ptr = (ULONG) sgd; /* Implement as Scatter
1876: gather, with One block */
1877: sgd++;
1878: sgd->BD_SG_Buffer_Ptr = 0;
1879: sgd->BD_SG_Count = 0;
1880:
1881: sgd++;
1882: myior->IOR_sgd_lin_phys = (ULONG) sgd;
1883: rstatus = myior->IOR_status;
1884:
1885: myiop->IOP_timer = 40;
1886: myiop->IOP_timer_orig = 40;
1887:
1888: if (mydcb->DCB_cmn.DCB_Sstor_Host == FALSE)
1889: {
1890: if (IlbIntIoCriteria (myiop))
1891: myior->IOR_flags |= IORF_DOUBLE_BUFFER;
1892: IlbInternalRequest (myiop, mydcb, 0);
1893: rstatus = myior->IOR_status;
1894:
1895: if (iorop == IOR_READ)
1896: {
1897: /* checks for partion reads of simulated drives that
1898: dont return either data or error.... */
1899: if ((errnl[0] == 0xACE01DE4) &&
1900: (errnl[1] == 0xEDB0CD01) &&
1901: (errnl[2] == 0x4caf3321) &&
1902: (errnl[3] == 0xa35a32c4))
1903:
1904: rstatus = 16;
1905:
1906: }
1907:
1908: return rstatus;
1909: }
1910:
1911: return 16;
1912:
1913:
1914: }
1915:
1916: /* This routine finds partitions */
1917:
1918: void
1919: UsePartitionInfo (PDCB dcb, PIOP myiop, char *diskbuffer, unsigned int relative, int recursed, int *partnum,
1920: MOUNT_STRUCT * mf, BOOL bVerifyOnly)
1921: {
1922: /* Note that this is recursive..... */
1923: partitionrec *pr;
1924: char *c;
1925: char *ndb;
1926: int flag = 0;
1927: cryptvol *cv = NULL;
1928:
1929: unsigned int ComputedStartSector;
1930: unsigned int ComputedEndSector;
1931: unsigned int cyl;
1932: unsigned int cylsize;
1933: unsigned int headsize;
1934:
1935: #if EXTRA_INFO
1936: _Debug_Printf_Service ("UsePartitionInfo\n");
1937: #endif
1938:
1939: c = diskbuffer;
1940: ndb = c + 512; /* next disk buffer */
1941: c += 0x1be;
1942:
1943: headsize = dcb->DCB_bdd.DCB_apparent_spt;
1944: cylsize = dcb->DCB_bdd.DCB_apparent_head_cnt;
1945: cylsize = cylsize * headsize;
1946:
1947: c = diskbuffer;
1948: c += 0x1be;
1949: pr = (partitionrec *) c;
1950:
1951:
1952: cyl = (pr->ss) & (128 + 64);
1953: cyl = cyl << 2;
1954: cyl += pr->sc;
1955: cyl *= cylsize; /* 16065; */
1956:
1957: ComputedStartSector = pr->sh * headsize; /* 63; */
1958: ComputedStartSector += (((pr->ss) & 63) - 1);
1959: ComputedStartSector += cyl;
1960:
1961:
1962: cyl = (pr->es) & (128 + 64);
1963: cyl = cyl << 2;
1964: cyl += pr->ec;
1965: cyl *= cylsize; /* 16065; */
1966:
1967: ComputedEndSector = pr->eh * headsize; /* 63 */
1968: ComputedEndSector += (((pr->es) & 63) - 1);
1969: ComputedEndSector += cyl;
1970: ComputedEndSector = ComputedEndSector - ComputedStartSector;
1971: ComputedEndSector += 1; /* allow for inclusive sectors... */
1972:
1973:
1974: pr = (partitionrec *) c;
1975:
1976: if (pr->boot == 0x80)
1977: dcb_boot = dcb;
1978:
1979: if ((pr->system == 5) || (pr->system == 0xF))
1980: {
1981: if (!recursed)
1982: relative = pr->StartSector;
1983: else
1984: pr->StartSector += relative;
1985:
1986:
1987: memset (ndb, 0, 512);
1988: DiskRead (dcb, myiop, pr->StartSector, 1, ndb, IOR_READ);
1989: UsePartitionInfo (dcb, myiop, ndb, relative, pr->StartSector, partnum, mf, bVerifyOnly); /* recursed, and also
1990: offset */
1991: }
1992: else
1993: {
1994: if (recursed)
1995: pr->StartSector += recursed;
1996:
1997: if (--(*partnum) == 0)
1998: {
1999: if (bVerifyOnly == TRUE)
2000: flag = 1;
2001: else
2002: flag = tryvol (dcb, myiop, pr, mf, &cv); /* partition 1 */
2003: goto error;
2004: }
2005: }
2006:
2007: pr++;
2008:
2009: if (pr->boot == 0x80)
2010: dcb_boot = dcb;
2011:
2012: if ((pr->system == 5) || (pr->system == 0xF))
2013: {
2014: if (!recursed)
2015: relative = pr->StartSector;
2016: else
2017: pr->StartSector += relative;
2018:
2019: memset (ndb, 0, 512);
2020: DiskRead (dcb, myiop, pr->StartSector, 1, ndb, IOR_READ);
2021: UsePartitionInfo (dcb, myiop, ndb, relative, pr->StartSector, partnum, mf, bVerifyOnly); /* recursed, and also
2022: offset */
2023: }
2024: else if (!recursed)
2025: {
2026: if (--(*partnum) == 0)
2027: {
2028: if (bVerifyOnly == TRUE)
2029: flag = 1;
2030: else
2031: flag = tryvol (dcb, myiop, pr, mf, &cv); /* partition 2 */
2032: goto error;
2033: }
2034: }
2035:
2036: if (recursed)
2037: goto error;
2038:
2039: pr++;
2040:
2041: if (pr->boot == 0x80)
2042: dcb_boot = dcb;
2043:
2044: if ((pr->system == 5) || (pr->system == 0xF))
2045: {
2046: if (!recursed)
2047: relative = pr->StartSector;
2048: else
2049: pr->StartSector += relative;
2050:
2051: memset (ndb, 0, 512);
2052: DiskRead (dcb, myiop, pr->StartSector, 1, ndb, IOR_READ);
2053: UsePartitionInfo (dcb, myiop, ndb, relative, pr->StartSector, partnum, mf, bVerifyOnly); /* recursed, and also
2054: offset */
2055: }
2056: else if (!recursed)
2057: {
2058: if (--(*partnum) == 0)
2059: {
2060: if (bVerifyOnly == TRUE)
2061: flag = 1;
2062: else
2063: flag = tryvol (dcb, myiop, pr, mf, &cv); /* partition 3 */
2064: goto error;
2065: }
2066: }
2067:
2068: pr++;
2069:
2070: if (pr->boot == 0x80)
2071: dcb_boot = dcb;
2072:
2073: if ((pr->system == 5) || (pr->system == 0xF))
2074: {
2075: if (!recursed)
2076: relative = pr->StartSector;
2077: else
2078: pr->StartSector += relative;
2079:
2080: memset (ndb, 0, 512);
2081: DiskRead (dcb, myiop, pr->StartSector, 1, ndb, IOR_READ);
2082: UsePartitionInfo (dcb, myiop, ndb, relative, pr->StartSector, partnum, mf, bVerifyOnly); /* recursed, and also
2083: offset */
2084: }
2085: else if (!recursed)
2086: {
2087: if (--(*partnum) == 0)
2088: {
2089: if (bVerifyOnly == TRUE)
2090: flag = 1;
2091: else
2092: flag = tryvol (dcb, myiop, pr, mf, &cv); /* partition 4 */
2093: goto error;
2094: }
2095: }
2096:
2097: error:
2098:
2099: #if EXTRA_INFO
2100: _Debug_Printf_Service ("UsePartitionInfo end\n");
2101: #endif
2102:
2103: if (bVerifyOnly == TRUE)
2104: {
2105: if (flag == 1)
2106: {
2107: /* Return partition info in the 'diskbuffer' buffer */
2108:
2109: char *peek = (char *) &pr->system;
2110: unsigned long *tmp = (void *) partitiontestbuffer;
2111: unsigned long secstart, seclast;
2112:
2113: mf->nReturnCode = 0;
2114:
2115: peek -= 4;
2116: peek += 8; /* point at starting sector... */
2117: secstart = *(unsigned long *) peek;
2118: peek += 4;
2119:
2120: seclast = (secstart + *(unsigned long *) peek);
2121:
2122: if (pr->boot == 0x80)
2123: {
2124: /* For safety reasons we return 0 length for
2125: the boot device */
2126: seclast = secstart;
2127: }
2128:
2129: tmp[0] = secstart;
2130: tmp[1] = seclast;
2131: tmp[2] = (unsigned long) dcb; /* device */
2132:
2133: }
2134: }
2135: else if (cv != NULL)
2136: {
2137: /* cv is only set by tryvol, flag is set only when cv is set */
2138: switch (flag)
2139: {
2140: case 0:
2141: mf->nReturnCode = ERR_VOL_MOUNT_FAILED;
2142: break;
2143: case 1:
2144: mf->nReturnCode = 0;
2145: mf->nDosDriveNo = cv->drive;
2146: strcpy (cv->mounted_file_name, (char *) mf->wszVolume);
2147: break;
2148: case -1:
2149: mf->nReturnCode = ERR_NO_FREE_DRIVES;
2150: break;
2151: }
2152: }
2153: }
2154:
2155: int
2156: tryvol (PDCB dcb, PIOP myiop, partitionrec * pr, MOUNT_STRUCT * mf, cryptvol ** pcv)
2157: {
2158: cryptvol *cv;
2159: char *readBuffer;
2160: int mounted = 0;
2161:
2162: readBuffer = TCalloc (FIRST_READ_SIZE);
2163: if (readBuffer == NULL)
2164: goto error;
2165:
2166: if (cv = checkpartition (myiop, pr))
2167: {
2168: if (cv->booted == 0)
2169: {
2170: int status;
2171:
2172: dophysblock (myiop, cv->cryptsectorfirst, FIRST_READ_SIZE / 512, readBuffer, cv, IOR_READ);
2173:
2174: status = VolumeReadHeaderCache (mf->bCache, readBuffer, mf->szPassword,
2175: mf->nPasswordLen, &cv->cryptoInfo);
2176:
2177: if (status != 0)
2178: {
2179: memset (cv, 0, sizeof (cryptvol));
2180: cv->cryptsectorfirst = 0x7fffffff;
2181: mounted = 0;
2182: goto error;
2183: }
2184: else
2185: cv->booted = 1;
2186:
2187: if (Add_Drive (dcb, cv, mf->nDosDriveNo) == 0)
2188: {
2189: cv->filehostdcb = dcb;
2190: lockdrive (cv->filehostdcb, myiop, 1);
2191: mounted = 1;
2192: }
2193: else
2194: {
2195: /* No Drive letter available */
2196: memset (cv, 0, sizeof (cryptvol));
2197: cv->cryptsectorfirst = 0x7fffffff;
2198: mounted = -1;
2199: }
2200: }
2201: }
2202: else
2203: {
2204: /* If the checkpartition fails it could be because the
2205: partitions is already mounted or because there are no free
2206: slots */
2207: mounted = 0;
2208: }
2209:
2210: error:
2211: if (readBuffer != NULL)
2212: TCfree (readBuffer);
2213:
2214: *pcv = cv;
2215:
2216: return mounted;
2217:
2218: }
2219:
2220: struct cryptvol *
2221: checkpartition (PIOP iop, partitionrec * pr)
2222: {
2223:
2224: cryptvol *flag = 0;
2225: cryptvol *cv;
2226: PDCB dcb = (PDCB) iop->IOP_physical_dcb;
2227:
2228: char *peek = (char *) &pr->system;
2229:
2230: pr->system = 0x74;
2231:
2232: if (pr->system == 0x74)
2233: {
2234: if (cv = addcryptedpartition (iop, peek))
2235: {
2236: flag = cv;
2237: }
2238: }
2239:
2240: return flag;
2241:
2242: }
2243:
2244: int
2245: cmppart (PDCB dcb, unsigned int secstart, cryptvol * cv)
2246: {
2247: if (cv->physdevDCB != dcb)
2248: return 0;
2249: if (cv->cryptsectorfirst != secstart)
2250: return 0;
2251: return 1;
2252: }
2253:
2254: struct cryptvol *
2255: addcryptedpartition (PIOP iop, char *peek)
2256: {
2257:
2258: unsigned int secstart;
2259: unsigned int seclast;
2260: PDCB device;
2261: int d;
2262: peek -= 4;
2263: peek += 8; /* point at starting sector... */
2264: secstart = *(unsigned long *) peek;
2265: peek += 4;
2266:
2267: seclast = (secstart + *(unsigned long *) peek);
2268: device = (PDCB) iop->IOP_physical_dcb;
2269:
2270: /* have we got it already ? */
2271: if (cmppart (device, secstart, (cryptvol *) & cv1))
2272: return NULL;
2273: if (cmppart (device, secstart, (cryptvol *) & cv2))
2274: return NULL;
2275: if (cmppart (device, secstart, (cryptvol *) & cv3))
2276: return NULL;
2277: if (cmppart (device, secstart, (cryptvol *) & cv4))
2278: return NULL;
2279: if (cmppart (device, secstart, (cryptvol *) & cv5))
2280: return NULL;
2281: if (cmppart (device, secstart, (cryptvol *) & cv6))
2282: return NULL;
2283: if (cmppart (device, secstart, (cryptvol *) & cv7))
2284: return NULL;
2285: if (cmppart (device, secstart, (cryptvol *) & cv8))
2286: return NULL;
2287:
2288: d = tryaddpart ((cryptvol *) & cv1, secstart, seclast, device);
2289: if (d == 1)
2290: return &cv1;
2291: if (d == 2)
2292: return 0;
2293:
2294: d = tryaddpart ((cryptvol *) & cv2, secstart, seclast, device);
2295: if (d == 1)
2296: return &cv2;
2297: if (d == 2)
2298: return 0;
2299:
2300: d = tryaddpart ((cryptvol *) & cv3, secstart, seclast, device);
2301: if (d == 1)
2302: return &cv3;
2303: if (d == 2)
2304: return 0;
2305:
2306: d = tryaddpart ((cryptvol *) & cv4, secstart, seclast, device);
2307: if (d == 1)
2308: return &cv4;
2309: if (d == 2)
2310: return 0;
2311:
2312: d = tryaddpart ((cryptvol *) & cv5, secstart, seclast, device);
2313: if (d == 1)
2314: return &cv5;
2315: if (d == 2)
2316: return 0;
2317:
2318: d = tryaddpart ((cryptvol *) & cv6, secstart, seclast, device);
2319: if (d == 1)
2320: return &cv6;
2321: if (d == 2)
2322: return 0;
2323:
2324: d = tryaddpart ((cryptvol *) & cv7, secstart, seclast, device);
2325: if (d == 1)
2326: return &cv7;
2327: if (d == 2)
2328: return 0;
2329:
2330: d = tryaddpart ((cryptvol *) & cv8, secstart, seclast, device);
2331: if (d == 1)
2332: return &cv8;
2333: if (d == 2)
2334: return 0;
2335:
2336: return NULL;
2337: }
2338:
2339: int
2340: tryaddpart (cryptvol * cv, unsigned int secstart, unsigned int seclast, PDCB device)
2341: {
2342: /* THIS if CAN NEVER BE TRUE because cmppart does this job before
2343: this func is called */
2344: if ((cv->physdevDCB == device) && (cv->cryptsectorfirst == secstart))
2345: return (2);
2346:
2347: if (cv->physdevDCB == 0)
2348: {
2349: cv->physdevDCB = device;
2350: cv->cryptsectorfirst = secstart;
2351: cv->cryptsectorlast = seclast;
2352:
2353: return (1);
2354: }
2355:
2356: return (0);
2357: }
2358:
2359: int
2360: unlockdrive (cryptvol * cv)
2361: {
2362: PDCB dcb = cv->filehostdcb; /* physdevDCB; */
2363: PIOP myiop;
2364: PIOR myior;
2365: USHORT offset;
2366: USHORT size;
2367:
2368: if (!dcb)
2369: return -1;
2370:
2371: offset = (USHORT) (dcb->DCB_cmn.DCB_expansion_length + FIELDOFFSET (IOP, IOP_ior));
2372: size = offset + sizeof (IOR) + dcb->DCB_max_sg_elements * sizeof (SGD);
2373: myiop = IspCreateIop (size, offset, ISP_M_FL_MUST_SUCCEED | ISP_M_FL_SMART_ALLOC | ISP_M_FL_INTERRUPT_TIME | ISP_M_FL_PERSISTENT_IOP);
2374: myior = &myiop->IOP_ior;
2375: myior->IOR_private_client = offset;
2376: lockdrive (dcb, myiop, 0); /* unlock it! */
2377: IspDeallocMem ((PVOID) ((DWORD) myior - myior->IOR_private_client));
2378: return 1;
2379: }
2380:
2381: int
2382: lockdrive (PDCB mydcb, PIOP myiop, int lockmode)
2383: {
2384: PIOR myior;
2385: int rstatus;
2386: int iorop;
2387:
2388: if (!mydcb)
2389: return -1;
2390:
2391: if (lockmode)
2392: iorop = IOR_LOCK_MEDIA;
2393: else
2394: iorop = IOR_UNLOCK_MEDIA;
2395:
2396: if ((mydcb->DCB_cmn.DCB_device_flags & DCB_DEV_REMOVABLE) == 0)
2397: return -1;
2398:
2399: myior = &myiop->IOP_ior;
2400: myiop->IOP_original_dcb = (ULONG) mydcb;
2401: myiop->IOP_physical_dcb = (ULONG) mydcb->DCB_cmn.DCB_physical_dcb;
2402: myior->IOR_next = 0;
2403: myior->IOR_start_addr[1] = 0;
2404: myior->IOR_flags = IORF_VERSION_002;
2405: myior->IOR_req_vol_handle = 0;
2406: myior->IOR_vol_designtr = 0xff;
2407: myior->IOR_func = iorop;
2408: myior->IOR_flags |= IORF_BYPASS_VOLTRK | IORF_HIGH_PRIORITY | IORF_SYNC_COMMAND;
2409: myior->IOR_start_addr[0] = 0;
2410: myior->IOR_xfer_count = 0;
2411: myior->IOR_buffer_ptr = 0;
2412:
2413: myiop->IOP_timer = 40;
2414: myiop->IOP_timer_orig = 40;
2415:
2416: IlbInternalRequest (myiop, mydcb, 0);
2417: rstatus = myior->IOR_status;
2418: return rstatus;
2419: }
2420:
2421:
2422: /* the ring 0 code to allow win32 gui to access disk sectors */
2423:
2424: int
2425: AppAccessBlockDevice (unsigned int devicenum, unsigned int sectorstart, unsigned int sectorlen, char *buffer, int mode)
2426: {
2427: PDCB dcb;
2428: USHORT offset;
2429: USHORT size;
2430: PIOP myiop;
2431: PIOR myior;
2432: int status;
2433: USHORT diskop;
2434:
2435: if (mode == 0)
2436: diskop = IOR_READ;
2437: else
2438: diskop = IOR_WRITE;
2439:
2440: if (devicenum < 128)
2441: dcb = dcblist[devicenum + 1];
2442: else
2443: dcb = (PDCB) devicenum;
2444:
2445: if (diskop == IOR_WRITE && dcb == dcb_boot)
2446: {
2447: if (sectorstart == 0)
2448: {
2449: return ERR_ACCESS_DENIED;
2450: }
2451: }
2452:
2453: offset = (USHORT) (dcb->DCB_cmn.DCB_expansion_length + FIELDOFFSET (IOP, IOP_ior));
2454: size = offset + sizeof (IOR) + dcb->DCB_max_sg_elements * sizeof (SGD);
2455: myiop = IspCreateIop (size, offset, ISP_M_FL_MUST_SUCCEED | ISP_M_FL_SMART_ALLOC | ISP_M_FL_INTERRUPT_TIME | ISP_M_FL_PERSISTENT_IOP);
2456: myior = &myiop->IOP_ior;
2457: myior->IOR_private_client = offset;
2458:
2459: if (diskop == IOR_WRITE)
2460: memcpy (appaccessbuffer, buffer, sectorlen * 512);
2461:
2462: status = DiskRead (dcb, myiop, sectorstart, sectorlen, appaccessbuffer, diskop); /* mode later...... */
2463:
2464: if (diskop == IOR_READ)
2465: memcpy (buffer, appaccessbuffer, sectorlen * 512);
2466:
2467: IspDeallocMem ((PVOID) ((DWORD) myior - myior->IOR_private_client));
2468:
2469: if (status != 0)
2470: {
2471: if (mode == 0)
2472: status = ERR_VOL_READING;
2473: else
2474: status = ERR_VOL_WRITING;
2475: }
2476:
2477: return status;
2478: }
2479:
2480: /* This code informs Windows of a drives arrival, this code
2481: crashes windows 95 for some cd's; so it's currently never called */
2482:
2483: void
2484: drivearrived (void)
2485: {
2486: cryptvol *cv;
2487: int c;
2488:
2489: for (c = 0; c < 8; c++)
2490: {
2491: cv = cryptvols[c];
2492:
2493: if (cv->notifytime & 0x80000000)
2494: {
2495: cv->notifytime = 0;
2496:
2497: IFSMgr_PNPEvent (DBT_DEVICEARRIVAL, cv->drive, PNPT_VOLUME | DBTF_MEDIA );
2498: }
2499: }
2500: }
2501:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.