ReactOS  0.4.14-dev-337-gf981a68
dosfiles.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: GPL - See COPYING in the top level directory
3  * PROJECT: ReactOS Virtual DOS Machine
4  * FILE: subsystems/mvdm/ntvdm/dos/dos32krnl/dosfiles.c
5  * PURPOSE: DOS32 Files Support
6  * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7  * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
8  */
9 
10 /* INCLUDES *******************************************************************/
11 
12 #include "ntvdm.h"
13 
14 #define NDEBUG
15 #include <debug.h>
16 
17 #include "emulator.h"
18 #include "../../memory.h"
19 
20 #include "dos.h"
21 #include "dos/dem.h"
22 #include "dosfiles.h"
23 #include "handle.h"
24 #include "process.h"
25 
26 #include "bios/bios.h"
27 
28 /* PRIVATE FUNCTIONS **********************************************************/
29 
31 {
32  CHAR ShortPath[MAX_PATH];
33  PCHAR Name;
35 
36  /* Try to get the short path */
37  if (!GetShortPathNameA(FilePath, ShortPath, sizeof(ShortPath)))
38  {
39  /* If it failed, just use the uppercase long path */
40  strncpy(ShortPath, FilePath, sizeof(ShortPath) - 1);
41  _strupr(ShortPath);
42  }
43 
44  /* Get the name part */
45  Name = strrchr(ShortPath, '\\');
46  if (Name == NULL) Name = ShortPath;
47 
48  /* Find the extension */
49  Extension = strchr(Name, '.');
50 
51  if (Extension)
52  {
53  /* Terminate the name string, and move the pointer to after the dot */
54  *Extension++ = 0;
55  }
56 
57  /* Copy the name into the SFT descriptor */
58  RtlCopyMemory(Descriptor->FileName, Name, min(strlen(Name), 8));
59 
60  if (Extension)
61  {
62  /* Copy the extension too */
63  RtlCopyMemory(&Descriptor->FileName[8], Extension, min(strlen(Extension), 3));
64  }
65 }
66 
67 /* PUBLIC FUNCTIONS ***********************************************************/
68 
70 {
71  UINT i;
72  BYTE Count = 0;
73  DWORD CurrentSft = SysVars->FirstSft;
74 
75  while (LOWORD(CurrentSft) != 0xFFFF)
76  {
77  PDOS_SFT Sft = (PDOS_SFT)FAR_POINTER(CurrentSft);
78 
79  for (i = 0; i < Sft->NumDescriptors; i++)
80  {
81  if (Sft->FileDescriptors[i].RefCount == 0) return Count;
82  Count++;
83  }
84 
85  /* Go to the next table */
86  CurrentSft = Sft->Link;
87  }
88 
89  /* Invalid ID */
90  return 0xFF;
91 }
92 
94 {
95  UINT i;
96  BYTE Count = 0;
97  DWORD CurrentSft = SysVars->FirstSft;
98 
99  while (LOWORD(CurrentSft) != 0xFFFF)
100  {
101  PDOS_SFT Sft = (PDOS_SFT)FAR_POINTER(CurrentSft);
102 
103  for (i = 0; i < Sft->NumDescriptors; i++)
104  {
105  if ((Sft->FileDescriptors[i].RefCount > 0)
107  && (Sft->FileDescriptors[i].Win32Handle == Win32Handle))
108  {
109  return Count;
110  }
111 
112  Count++;
113  }
114 
115  /* Go to the next table */
116  CurrentSft = Sft->Link;
117  }
118 
119  /* Invalid ID */
120  return 0xFF;
121 }
122 
124 {
125  UINT i;
126  BYTE Count = 0;
127  DWORD CurrentSft = SysVars->FirstSft;
128 
129  while (LOWORD(CurrentSft) != 0xFFFF)
130  {
131  PDOS_SFT Sft = (PDOS_SFT)FAR_POINTER(CurrentSft);
132 
133  for (i = 0; i < Sft->NumDescriptors; i++)
134  {
135  if ((Sft->FileDescriptors[i].RefCount > 0)
137  && (Sft->FileDescriptors[i].DevicePointer == DevicePointer))
138  {
139  return Count;
140  }
141 
142  Count++;
143  }
144 
145  /* Go to the next table */
146  CurrentSft = Sft->Link;
147  }
148 
149  /* Invalid ID */
150  return 0xFF;
151 }
152 
154 {
155  DWORD CurrentSft = SysVars->FirstSft;
156 
157  while (LOWORD(CurrentSft) != 0xFFFF)
158  {
159  PDOS_SFT Sft = (PDOS_SFT)FAR_POINTER(CurrentSft);
160 
161  /* Return it if it's in this table */
162  if (Id <= Sft->NumDescriptors) return &Sft->FileDescriptors[Id];
163 
164  /* Go to the next table */
165  Id -= Sft->NumDescriptors;
166  CurrentSft = Sft->Link;
167  }
168 
169  /* Invalid ID */
170  return NULL;
171 }
172 
174 {
175  BYTE DescriptorId = DosQueryHandle(DosHandle);
176  if (DescriptorId == 0xFF) return NULL;
177 
178  return DosGetFileDescriptor(DescriptorId);
179 }
180 
182  LPWORD CreationStatus,
184  BYTE AccessShareModes,
185  WORD CreateActionFlags,
187 {
188  WORD LastError;
191  WORD DosHandle;
193  DWORD ShareMode = 0;
194  DWORD CreationDisposition = 0;
195  BOOL InheritableFile = FALSE;
196  SECURITY_ATTRIBUTES SecurityAttributes;
197  BYTE DescriptorId;
199 
200  DPRINT1("DosCreateFileEx: FilePath \"%s\", AccessShareModes 0x%04X, CreateActionFlags 0x%04X, Attributes 0x%04X\n",
201  FilePath, AccessShareModes, CreateActionFlags, Attributes);
202 
203  //
204  // The article about OpenFile API: http://msdn.microsoft.com/en-us/library/windows/desktop/aa365430(v=vs.85).aspx
205  // explains what those AccessShareModes are (see the uStyle flag).
206  //
207 
209  if (Node != NULL)
210  {
211  if (Node->OpenRoutine) Node->OpenRoutine(Node);
212  }
213  else
214  {
215  /* Parse the access mode */
216  switch (AccessShareModes & 0x03)
217  {
218  /* Read-only */
219  case 0:
221  break;
222 
223  /* Write only */
224  case 1:
226  break;
227 
228  /* Read and write */
229  case 2:
231  break;
232 
233  /* Invalid */
234  default:
236  }
237 
238  /* Parse the share mode */
239  switch ((AccessShareModes >> 4) & 0x07)
240  {
241  /* Compatibility mode */
242  case 0:
244  break;
245 
246  /* No sharing "DenyAll" */
247  case 1:
248  ShareMode = 0;
249  break;
250 
251  /* No write share "DenyWrite" */
252  case 2:
253  ShareMode = FILE_SHARE_READ;
254  break;
255 
256  /* No read share "DenyRead" */
257  case 3:
258  ShareMode = FILE_SHARE_WRITE;
259  break;
260 
261  /* Full share "DenyNone" */
262  case 4:
263  ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
264  break;
265 
266  /* Invalid */
267  default:
269  }
270 
271  /*
272  * Parse the creation action flags:
273  *
274  * Bitfields for action:
275  * Bit(s) Description
276  *
277  * 7-4 Action if file does not exist.
278  * 0000 Fail
279  * 0001 Create
280  *
281  * 3-0 Action if file exists.
282  * 0000 Fail
283  * 0001 Open
284  * 0010 Replace/open
285  */
286  switch (CreateActionFlags)
287  {
288  /* If the file exists, fail, otherwise, fail also */
289  case 0x00:
290  // A special case is used after the call to CreateFileA if it succeeds,
291  // in order to close the opened handle and return an adequate error.
292  CreationDisposition = OPEN_EXISTING;
293  break;
294 
295  /* If the file exists, open it, otherwise, fail */
296  case 0x01:
297  CreationDisposition = OPEN_EXISTING;
298  break;
299 
300  /* If the file exists, replace it, otherwise, fail */
301  case 0x02:
302  CreationDisposition = TRUNCATE_EXISTING;
303  break;
304 
305  /* If the file exists, fail, otherwise, create it */
306  case 0x10:
307  CreationDisposition = CREATE_NEW;
308  break;
309 
310  /* If the file exists, open it, otherwise, create it */
311  case 0x11:
312  CreationDisposition = OPEN_ALWAYS;
313  break;
314 
315  /* If the file exists, replace it, otherwise, create it */
316  case 0x12:
317  CreationDisposition = CREATE_ALWAYS;
318  break;
319 
320  /* Invalid */
321  default:
323  }
324 
325  /* Check for inheritance */
326  InheritableFile = ((AccessShareModes & 0x80) == 0);
327 
328  /* Assign default security attributes to the file, and set the inheritance flag */
329  SecurityAttributes.nLength = sizeof(SecurityAttributes);
330  SecurityAttributes.lpSecurityDescriptor = NULL;
331  SecurityAttributes.bInheritHandle = InheritableFile;
332 
333  /* Open the file */
335  AccessMode,
336  ShareMode,
337  &SecurityAttributes,
338  CreationDisposition,
339  Attributes,
340  NULL);
341 
342  LastError = (WORD)GetLastError();
343 
345  {
346  /* Return the error code */
347  return LastError;
348  }
349 
350  /*
351  * Special case: CreateActionFlags == 0, we must fail because
352  * the file exists (if it didn't exist we already failed).
353  */
354  if (CreateActionFlags == 0)
355  {
356  /* Close the file and return the error code */
358  return ERROR_FILE_EXISTS;
359  }
360 
361  /* Set the creation status */
362  switch (CreateActionFlags)
363  {
364  case 0x01:
365  *CreationStatus = 0x01; // The file was opened
366  break;
367 
368  case 0x02:
369  *CreationStatus = 0x03; // The file was replaced
370  break;
371 
372  case 0x10:
373  *CreationStatus = 0x02; // The file was created
374  break;
375 
376  case 0x11:
377  {
378  if (LastError == ERROR_ALREADY_EXISTS)
379  *CreationStatus = 0x01; // The file was opened
380  else
381  *CreationStatus = 0x02; // The file was created
382 
383  break;
384  }
385 
386  case 0x12:
387  {
388  if (LastError == ERROR_ALREADY_EXISTS)
389  *CreationStatus = 0x03; // The file was replaced
390  else
391  *CreationStatus = 0x02; // The file was created
392 
393  break;
394  }
395  }
396  }
397 
398  DescriptorId = DosFindFreeDescriptor();
399  if (DescriptorId == 0xFF)
400  {
401  /* Close the file and return the error code */
404  }
405 
406  /* Set up the new descriptor */
407  Descriptor = DosGetFileDescriptor(DescriptorId);
409  RtlFillMemory(Descriptor->FileName, sizeof(Descriptor->FileName), ' ');
410 
411  if (Node != NULL)
412  {
413  Descriptor->DevicePointer = Node->Driver;
414  Descriptor->DeviceInfo = Node->DeviceAttributes | FILE_INFO_DEVICE;
415  RtlCopyMemory(Descriptor->FileName, Node->Name.Buffer, Node->Name.Length);
416  }
417  else
418  {
419  Descriptor->OpenMode = AccessShareModes;
422  Descriptor->Win32Handle = FileHandle;
424  }
425 
426  Descriptor->OwnerPsp = Sda->CurrentPsp;
427 
428  /* Open the DOS handle */
429  DosHandle = DosOpenHandle(DescriptorId);
430  if (DosHandle == INVALID_DOS_HANDLE)
431  {
432  /* Close the file and return the error code */
435  }
436 
437  /* It was successful */
438  *Handle = DosHandle;
439  return ERROR_SUCCESS;
440 }
441 
444  DWORD CreationDisposition,
446 {
449  WORD DosHandle;
450  BYTE DescriptorId;
452 
453  DPRINT("DosCreateFile: FilePath \"%s\", CreationDisposition 0x%04X, Attributes 0x%04X\n",
454  FilePath, CreationDisposition, Attributes);
455 
457  if (Node != NULL)
458  {
459  if (Node->OpenRoutine) Node->OpenRoutine(Node);
460  }
461  else
462  {
463  /* Create the file */
467  NULL,
468  CreationDisposition,
469  Attributes,
470  NULL);
472  {
473  /* Return the error code */
474  return (WORD)GetLastError();
475  }
476  }
477 
478  DescriptorId = DosFindFreeDescriptor();
479  if (DescriptorId == 0xFF)
480  {
481  /* Close the file and return the error code */
484  }
485 
486  /* Set up the new descriptor */
487  Descriptor = DosGetFileDescriptor(DescriptorId);
489  RtlFillMemory(Descriptor->FileName, sizeof(Descriptor->FileName), ' ');
490 
491  if (Node != NULL)
492  {
493  Descriptor->DevicePointer = Node->Driver;
494  Descriptor->DeviceInfo = Node->DeviceAttributes | FILE_INFO_DEVICE;
495  RtlCopyMemory(Descriptor->FileName, Node->Name.Buffer, Node->Name.Length);
496  }
497  else
498  {
501  Descriptor->Win32Handle = FileHandle;
503  }
504 
505  Descriptor->OwnerPsp = Sda->CurrentPsp;
506 
507  /* Open the DOS handle */
508  DosHandle = DosOpenHandle(DescriptorId);
509  if (DosHandle == INVALID_DOS_HANDLE)
510  {
511  /* Close the file and return the error code */
514  }
515 
516  /* It was successful */
517  *Handle = DosHandle;
518  return ERROR_SUCCESS;
519 }
520 
523  BYTE AccessShareModes)
524 {
527  WORD DosHandle;
528  BYTE DescriptorId;
530 
531  DPRINT("DosOpenFile: FilePath \"%s\", AccessShareModes 0x%04X\n",
532  FilePath, AccessShareModes);
533 
534  //
535  // The article about OpenFile API: http://msdn.microsoft.com/en-us/library/windows/desktop/aa365430(v=vs.85).aspx
536  // explains what those AccessShareModes are (see the uStyle flag).
537  //
538 
540  if (Node != NULL)
541  {
542  if (Node->OpenRoutine) Node->OpenRoutine(Node);
543  }
544  else
545  {
547  DWORD ShareMode = 0;
548  BOOL InheritableFile = FALSE;
549  SECURITY_ATTRIBUTES SecurityAttributes;
550 
551  /* Parse the access mode */
552  switch (AccessShareModes & 0x03)
553  {
554  /* Read-only */
555  case 0:
557  break;
558 
559  /* Write only */
560  case 1:
562  break;
563 
564  /* Read and write */
565  case 2:
567  break;
568 
569  /* Invalid */
570  default:
572  }
573 
574  /* Parse the share mode */
575  switch ((AccessShareModes >> 4) & 0x07)
576  {
577  /* Compatibility mode */
578  case 0:
580  break;
581 
582  /* No sharing "DenyAll" */
583  case 1:
584  ShareMode = 0;
585  break;
586 
587  /* No write share "DenyWrite" */
588  case 2:
589  ShareMode = FILE_SHARE_READ;
590  break;
591 
592  /* No read share "DenyRead" */
593  case 3:
594  ShareMode = FILE_SHARE_WRITE;
595  break;
596 
597  /* Full share "DenyNone" */
598  case 4:
599  ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
600  break;
601 
602  /* Invalid */
603  default:
605  }
606 
607  /* Check for inheritance */
608  InheritableFile = ((AccessShareModes & 0x80) == 0);
609 
610  /* Assign default security attributes to the file, and set the inheritance flag */
611  SecurityAttributes.nLength = sizeof(SecurityAttributes);
612  SecurityAttributes.lpSecurityDescriptor = NULL;
613  SecurityAttributes.bInheritHandle = InheritableFile;
614 
615  /* Open the file */
617  AccessMode,
618  ShareMode,
619  &SecurityAttributes,
622  NULL);
624  {
625  /* Return the error code */
626  return (WORD)GetLastError();
627  }
628  }
629 
630  DescriptorId = DosFindFreeDescriptor();
631  if (DescriptorId == 0xFF)
632  {
633  /* Close the file and return the error code */
636  }
637 
638  /* Set up the new descriptor */
639  Descriptor = DosGetFileDescriptor(DescriptorId);
641  RtlFillMemory(Descriptor->FileName, sizeof(Descriptor->FileName), ' ');
642 
643  if (Node != NULL)
644  {
645  Descriptor->DevicePointer = Node->Driver;
646  Descriptor->DeviceInfo = Node->DeviceAttributes | FILE_INFO_DEVICE;
647  RtlCopyMemory(Descriptor->FileName, Node->Name.Buffer, Node->Name.Length);
648  }
649  else
650  {
651  Descriptor->OpenMode = AccessShareModes;
654  Descriptor->Win32Handle = FileHandle;
656  }
657 
658  Descriptor->OwnerPsp = Sda->CurrentPsp;
659 
660  /* Open the DOS handle */
661  DosHandle = DosOpenHandle(DescriptorId);
662  if (DosHandle == INVALID_DOS_HANDLE)
663  {
664  /* Close the file and return the error code */
667  }
668 
669  /* It was successful */
670  *Handle = DosHandle;
671  return ERROR_SUCCESS;
672 }
673 
675 {
678  BYTE LineSize = 0;
679  PCHAR Pointer = FAR_POINTER(Buffer);
680  CHAR Character;
681 
682  do
683  {
684  USHORT Amount = 1;
685 
686  /* Read a character from the device */
687  Node->ReadRoutine(Node,
690  &Amount);
691  if (Amount == 0) break;
692 
693  Character = Sda->ByteBuffer;
694 
695  if (LineSize == MaxSize - 1 && Character != '\r' && Character != '\b')
696  {
697  /* Line buffer full */
698  // TODO: Should we beep?
699  continue;
700  }
701 
702  switch (Character)
703  {
704  /* Extended character */
705  case '\0':
706  {
707  /* Read the scancode and discard it */
708  Amount = 1;
709  Node->ReadRoutine(Node,
712  &Amount);
713  break;
714  }
715 
716  /* Ctrl-C */
717  case 0x03:
718  {
719  DosEchoCharacter(Character);
720 
721  if (DosControlBreak())
722  {
723  /* Set the character to CR to end the loop */
724  Character = '\r';
725  }
726 
727  break;
728  }
729 
730  case '\n':
731  {
732  DosEchoCharacter('\r');
733  DosEchoCharacter('\n');
734  break;
735  }
736 
737  case '\b':
738  {
739  if (LineSize > 0)
740  {
741  LineSize--;
742  DosEchoCharacter(Character);
743 
744  /* Erase the '^' too */
745  if (Pointer[LineSize] > 0x00 && Pointer[LineSize] < 0x20)
746  {
747  DosEchoCharacter(Character);
748  }
749  }
750 
751  break;
752  }
753 
754  default:
755  {
756  /* Store the character in the buffer */
757  Pointer[LineSize++] = Character;
758  DosEchoCharacter(Character);
759  }
760  }
761 
762  /* Stop on a carriage return */
763  } while (Character != '\r');
764 
765  return LineSize - 1;
766 }
767 
769  DWORD Buffer,
770  WORD Count,
772 {
775  BYTE StaticBuffer[8192];
776 
777  DPRINT("DosReadFile: FileHandle 0x%04X, Count 0x%04X\n", FileHandle, Count);
778 
779  if (Descriptor == NULL)
780  {
781  /* Invalid handle */
782  return ERROR_INVALID_HANDLE;
783  }
784 
785  if (Descriptor->DeviceInfo & FILE_INFO_DEVICE)
786  {
788  if (!Node->ReadRoutine) return ERROR_INVALID_FUNCTION;
789 
790  if (Descriptor->DeviceInfo & FILE_INFO_BINARY)
791  {
792  /* Read from the device directly */
793  Node->ReadRoutine(Node, Buffer, &Count);
794  *BytesRead = Count;
795  }
796  else if (Descriptor->DeviceInfo & FILE_INFO_STDIN)
797  {
798  /* Line-buffered CON input */
799  PCHAR ConBuffer = NULL;
800  PCHAR Pointer = FAR_POINTER(Buffer);
801 
802  /* Check if the buffer is empty */
803  if (!SysVars->UnreadConInput)
804  {
805  SysVars->UnreadConInput = FIELD_OFFSET(DOS_DATA, UnreadConInputBuffer);
806 
809  sizeof(DosData->UnreadConInputBuffer));
810  }
811 
812  *BytesRead = 0;
814 
815  while (*BytesRead < Count)
816  {
817  Pointer[(*BytesRead)++] = *ConBuffer;
818 
819  if (*ConBuffer == '\r')
820  {
821  /* A carriage return turns into a line feed */
822  *ConBuffer = '\n';
823  }
824  else if (*ConBuffer == '\n')
825  {
826  /* A line feed marks the true end of the line */
827  SysVars->UnreadConInput = 0;
828 
829  /* Echo the line feed */
830  DosEchoCharacter('\n');
831  break;
832  }
833  else
834  {
835  /* Move to the next character */
837  ConBuffer++;
838  }
839  }
840  }
841  else
842  {
843  /* Translated input from a character device that isn't CON */
844  PCHAR Pointer = FAR_POINTER(Buffer);
845  CHAR Character;
846 
847  *BytesRead = 0;
848 
849  while (*BytesRead < Count)
850  {
851  USHORT Amount = 1;
852 
853  /* Read a character from the device */
854  Node->ReadRoutine(Node,
857  &Amount);
858  if (Amount == 0) break;
859 
860  Character = Sda->ByteBuffer;
861  // TODO: Process it somehow?
862 
863  /* Store the character in the output buffer */
864  Pointer[(*BytesRead)++] = Character;
865 
866  /* Check for EOF */
867  if (Character == 0x1A) break;
868  }
869  }
870  }
871  else
872  {
873  DWORD BytesRead32 = 0;
874  PVOID LocalBuffer;
875 
876  if (Count <= sizeof(StaticBuffer))
877  {
878  LocalBuffer = StaticBuffer;
879  }
880  else
881  {
882  LocalBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count);
883  ASSERT(LocalBuffer != NULL);
884  }
885 
886  /* Read from the file */
887  if (ReadFile(Descriptor->Win32Handle, LocalBuffer, Count, &BytesRead32, NULL))
888  {
889  /* Write to the memory */
892  LocalBuffer,
893  LOWORD(BytesRead32));
894 
895  /* Update the position */
896  Descriptor->Position += BytesRead32; // or LOWORD(BytesRead32); ?
897  }
898  else
899  {
900  /* Store the error code */
901  Result = (WORD)GetLastError();
902  }
903 
904  /* The number of bytes read is always 16-bit */
905  *BytesRead = LOWORD(BytesRead32);
906 
907  if (LocalBuffer != StaticBuffer)
908  RtlFreeHeap(RtlGetProcessHeap(), 0, LocalBuffer);
909  }
910 
911  /* Return the error code */
912  return Result;
913 }
914 
916  DWORD Buffer,
917  WORD Count,
919 {
922  BYTE StaticBuffer[8192];
923 
924  DPRINT("DosWriteFile: FileHandle 0x%04X, Count 0x%04X\n", FileHandle, Count);
925 
926  if (Descriptor == NULL)
927  {
928  /* Invalid handle */
929  return ERROR_INVALID_HANDLE;
930  }
931 
932  if (Descriptor->DeviceInfo & FILE_INFO_DEVICE)
933  {
935  if (!Node->WriteRoutine) return ERROR_INVALID_FUNCTION;
936 
937  /* Read the device */
938  Node->WriteRoutine(Node, Buffer, &Count);
939  *BytesWritten = Count;
940  }
941  else
942  {
943  DWORD BytesWritten32 = 0;
944  PVOID LocalBuffer;
945 
946  /*
947  * Writing zero bytes truncates or extends the file
948  * to the current position of the file pointer.
949  */
950  if (Count == 0)
951  {
952  if (!SetEndOfFile(Descriptor->Win32Handle))
953  {
954  /* Store the error code */
955  Result = (WORD)GetLastError();
956  }
957  *BytesWritten = 0;
958  return Result;
959  }
960 
961  if (Count <= sizeof(StaticBuffer))
962  {
963  LocalBuffer = StaticBuffer;
964  }
965  else
966  {
967  LocalBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count);
968  ASSERT(LocalBuffer != NULL);
969  }
970 
971  /* Read from the memory */
974  LocalBuffer,
975  Count);
976 
977  /* Write to the file */
978  if (WriteFile(Descriptor->Win32Handle, LocalBuffer, Count, &BytesWritten32, NULL))
979  {
980  /* Update the position and size */
981  Descriptor->Position += BytesWritten32; // or LOWORD(BytesWritten32); ?
982  if (Descriptor->Position > Descriptor->Size) Descriptor->Size = Descriptor->Position;
983  }
984  else
985  {
986  /* Store the error code */
987  Result = (WORD)GetLastError();
988  }
989 
990  /* The number of bytes written is always 16-bit */
991  *BytesWritten = LOWORD(BytesWritten32);
992 
993  if (LocalBuffer != StaticBuffer)
994  RtlFreeHeap(RtlGetProcessHeap(), 0, LocalBuffer);
995  }
996 
997  /* Return the error code */
998  return Result;
999 }
1000 
1002  LONG Offset,
1003  BYTE Origin,
1004  LPDWORD NewOffset)
1005 {
1007  DWORD FilePointer;
1009 
1010  DPRINT("DosSeekFile: FileHandle 0x%04X, Offset 0x%08X, Origin 0x%02X\n",
1011  FileHandle, Offset, Origin);
1012 
1013  if (Descriptor == NULL)
1014  {
1015  /* Invalid handle */
1016  return ERROR_INVALID_HANDLE;
1017  }
1018 
1019  if (Descriptor->DeviceInfo & FILE_INFO_DEVICE)
1020  {
1021  /* For character devices, always return success */
1022  return ERROR_SUCCESS;
1023  }
1024 
1025  /* Check if the origin is valid */
1026  if (Origin != FILE_BEGIN && Origin != FILE_CURRENT && Origin != FILE_END)
1027  {
1028  return ERROR_INVALID_FUNCTION;
1029  }
1030 
1031  FilePointer = SetFilePointer(Descriptor->Win32Handle, Offset, NULL, Origin);
1032 
1033  /* Check if there's a possibility the operation failed */
1034  if (FilePointer == INVALID_SET_FILE_POINTER)
1035  {
1036  /* Get the real error code */
1037  Result = (WORD)GetLastError();
1038  }
1039 
1040  if (Result != ERROR_SUCCESS)
1041  {
1042  /* The operation did fail */
1043  return Result;
1044  }
1045 
1046  /* Update the position */
1047  Descriptor->Position = FilePointer;
1048 
1049  /* Return the file pointer, if requested */
1050  if (NewOffset) *NewOffset = FilePointer;
1051 
1052  /* Return success */
1053  return ERROR_SUCCESS;
1054 }
1055 
1057 {
1059 
1060  if (Descriptor == NULL)
1061  {
1062  /* Invalid handle */
1064  return FALSE;
1065  }
1066 
1067  if (Descriptor->DeviceInfo & FILE_INFO_DEVICE)
1068  {
1070 
1071  if (Node->FlushInputRoutine) Node->FlushInputRoutine(Node);
1072  if (Node->FlushOutputRoutine) Node->FlushOutputRoutine(Node);
1073 
1074  return TRUE;
1075  }
1076  else
1077  {
1078  return FlushFileBuffers(Descriptor->Win32Handle);
1079  }
1080 }
1081 
1083 {
1085 
1086  if (Descriptor == NULL)
1087  {
1088  /* Invalid handle */
1090  return FALSE;
1091  }
1092 
1093  /* Always succeed for character devices */
1094  if (Descriptor->DeviceInfo & FILE_INFO_DEVICE) return TRUE;
1095 
1096  if (!LockFile(Descriptor->Win32Handle, Offset, 0, Size, 0))
1097  {
1099  return FALSE;
1100  }
1101 
1102  return TRUE;
1103 }
1104 
1106 {
1108 
1109  if (Descriptor == NULL)
1110  {
1111  /* Invalid handle */
1113  return FALSE;
1114  }
1115 
1116  /* Always succeed for character devices */
1117  if (Descriptor->DeviceInfo & FILE_INFO_DEVICE) return TRUE;
1118 
1119  if (!UnlockFile(Descriptor->Win32Handle, Offset, 0, Size, 0))
1120  {
1122  return FALSE;
1123  }
1124 
1125  return TRUE;
1126 }
1127 
1129 {
1130  CHAR RootPath[] = "?:\\";
1131 
1132  if (DriveNumber == 0x00)
1133  RootPath[0] = 'A' + Sda->CurrentDrive;
1134  else
1135  RootPath[0] = 'A' + DriveNumber - 1;
1136 
1137  switch (ControlCode)
1138  {
1139  case 0x04:
1140  DPRINT1("UNIMPLEMENTED INT 21h, 4404h, Read from block device %s\n", RootPath);
1142  break;
1143  case 0x05:
1144  DPRINT1("UNIMPLEMENTED INT 21h, 4405h, Write block device control string %s\n", RootPath);
1146  break;
1147  case 0x08:
1148  {
1149  DWORD DriveType = GetDriveTypeA(RootPath);
1150 
1151  switch (DriveType)
1152  {
1153  case DRIVE_UNKNOWN:
1154  case DRIVE_NO_ROOT_DIR:
1155  default:
1156  DPRINT1("INT 21h, 4408h, %s -> DriveType = 0x%x\n", RootPath, DriveType);
1157  *Result = 0x000f;
1158  return TRUE;
1159  case DRIVE_REMOVABLE:
1160  case DRIVE_CDROM:
1161  *Result = 0x0000;
1162  return TRUE;
1163  case DRIVE_FIXED:
1164  *Result = 0x0001;
1165  return TRUE;
1166  case DRIVE_REMOTE:
1167  case DRIVE_RAMDISK: // ??
1168  break;
1169  }
1171  return FALSE;
1172  }
1173  case 0x09:
1174  DPRINT1("UNIMPLEMENTED INT 21h, 4409h, Determine if a logical device is local or remote %s\n", RootPath);
1176  return FALSE;
1177  default:
1178  assert(0);
1179  break;
1180  }
1181 
1182  return FALSE;
1183 }
1184 
1186 {
1189 
1190  switch (ControlCode)
1191  {
1192  case 0x04:
1193  case 0x05:
1194  case 0x08:
1195  case 0x09:
1197  }
1198 
1200 
1201  if (!Descriptor)
1202  {
1204  return FALSE;
1205  }
1206 
1207  if (Descriptor->DeviceInfo & FILE_INFO_DEVICE)
1208  {
1209  Node = DosGetDriverNode(Descriptor->DevicePointer);
1210  }
1211 
1212  switch (ControlCode)
1213  {
1214  /* Get Device Information */
1215  case 0x00:
1216  {
1217  /*
1218  * See Ralf Brown: http://www.ctyme.com/intr/rb-2820.htm
1219  * for a list of possible flags.
1220  */
1221  setDX(Descriptor->DeviceInfo);
1222  return TRUE;
1223  }
1224 
1225  /* Set Device Information */
1226  case 0x01:
1227  {
1228  // TODO: NOT IMPLEMENTED
1229  UNIMPLEMENTED;
1230  return FALSE;
1231  }
1232 
1233  /* Read from Device I/O Control Channel */
1234  case 0x02:
1235  {
1236  if (Node == NULL || !(Node->DeviceAttributes & DOS_DEVATTR_IOCTL))
1237  {
1239  return FALSE;
1240  }
1241 
1242  /* Do nothing if there is no IOCTL routine */
1243  if (!Node->IoctlReadRoutine)
1244  {
1245  *Length = 0;
1246  return TRUE;
1247  }
1248 
1249  Node->IoctlReadRoutine(Node, Buffer, Length);
1250  return TRUE;
1251  }
1252 
1253  /* Write to Device I/O Control Channel */
1254  case 0x03:
1255  {
1256  if (Node == NULL || !(Node->DeviceAttributes & DOS_DEVATTR_IOCTL))
1257  {
1259  return FALSE;
1260  }
1261 
1262  /* Do nothing if there is no IOCTL routine */
1263  if (!Node->IoctlWriteRoutine)
1264  {
1265  *Length = 0;
1266  return TRUE;
1267  }
1268 
1269  Node->IoctlWriteRoutine(Node, Buffer, Length);
1270  return TRUE;
1271  }
1272 
1273  /* Get Input Status */
1274  case 0x06:
1275  {
1276  /* Check if this is a file or a device */
1277  if (Node)
1278  {
1279  /* Device*/
1280 
1281  if (!Node->InputStatusRoutine || Node->InputStatusRoutine(Node))
1282  {
1283  /* Set the length to 0xFF to mark that it's ready */
1284  *Length = 0xFF;
1285  }
1286  else
1287  {
1288  /* Not ready */
1289  *Length = 0;
1290  }
1291  }
1292  else
1293  {
1294  /* File */
1295 
1296  if (Descriptor->Position < Descriptor->Size)
1297  {
1298  /* Set the length to 0xFF to mark that it's ready */
1299  *Length = 0xFF;
1300  }
1301  else
1302  {
1303  /* Not ready */
1304  *Length = 0;
1305  }
1306  }
1307 
1308  return TRUE;
1309  }
1310 
1311  /* Get Output Status */
1312  case 0x07:
1313  {
1314  /* Check if this is a file or a device */
1315  if (Node)
1316  {
1317  /* Device*/
1318 
1319  if (!Node->OutputStatusRoutine || Node->OutputStatusRoutine(Node))
1320  {
1321  /* Set the length to 0xFF to mark that it's ready */
1322  *Length = 0xFF;
1323  }
1324  else
1325  {
1326  /* Not ready */
1327  *Length = 0;
1328  }
1329  }
1330  else
1331  {
1332  /* Files are always ready for output */
1333  *Length = 0xFF;
1334  }
1335 
1336  return TRUE;
1337  }
1338 
1339  /* Unsupported control code */
1340  default:
1341  {
1342  DPRINT1("Unsupported IOCTL: 0x%02X\n", ControlCode);
1343 
1345  return FALSE;
1346  }
1347  }
1348 }
1349 
1350 /* EOF */
WORD LastErrorCode
Definition: dos.h:151
Definition: dos.h:242
signed char * PCHAR
Definition: retypes.h:7
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define DOS_DATA_OFFSET(x)
Definition: dos.h:35
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
#define ERROR_FILE_EXISTS
Definition: winerror.h:165
_Must_inspect_result_ _In_ LONGLONG _In_ LONGLONG Amount
Definition: fsrtlfuncs.h:550
_Must_inspect_result_ _In_ PFILE_OBJECT _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ FLT_IO_OPERATION_FLAGS _Out_opt_ PULONG BytesWritten
Definition: fltkernel.h:1293
WORD CurrentPsp
Definition: dos.h:156
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define INVALID_DOS_HANDLE
Definition: dos.h:41
BYTE ByteBuffer
Definition: dos.h:193
#define CloseHandle
Definition: compat.h:406
#define INVALID_SET_FILE_POINTER
Definition: winbase.h:115
WORD DosReadFile(WORD FileHandle, DWORD Buffer, WORD Count, LPWORD BytesRead)
Definition: dosfiles.c:768
BOOL DosFlushFileBuffers(WORD FileHandle)
Definition: dosfiles.c:1056
UINT WINAPI GetDriveTypeA(IN LPCSTR lpRootPathName)
Definition: disk.c:468
#define ERROR_SUCCESS
Definition: deptool.c:10
#define LOBYTE(W)
Definition: jmemdos.c:487
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
PDOS_FILE_DESCRIPTOR DosGetFileDescriptor(BYTE Id)
Definition: dosfiles.c:153
#define FILE_INFO_BINARY
Definition: dosfiles.h:15
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
char CHAR
Definition: xmlstorage.h:175
#define FILE_CURRENT
Definition: winbase.h:113
BOOL WINAPI SetEndOfFile(HANDLE hFile)
Definition: fileinfo.c:1154
#define ERROR_INVALID_HANDLE
Definition: compat.h:88
#define DOS_DEVATTR_IOCTL
Definition: device.h:28
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
#define DRIVE_RAMDISK
Definition: winbase.h:252
BYTE DosFindWin32Descriptor(HANDLE Win32Handle)
Definition: dosfiles.c:93
DOS_FILE_DESCRIPTOR FileDescriptors[ANYSIZE_ARRAY]
Definition: dosfiles.h:68
#define INVALID_HANDLE_VALUE
Definition: compat.h:399
UINT DriveType
#define assert(x)
Definition: debug.h:53
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
VOID FASTCALL EmulatorWriteMemory(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
Definition: memory.c:183
BYTE DosQueryHandle(WORD DosHandle)
Definition: handle.c:238
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
BYTE UnreadConInputBuffer[128]
Definition: dos.h:249
#define SEG_OFF_TO_PTR(seg, off)
Definition: emulator.h:28
#define FILE_SHARE_READ
Definition: compat.h:125
#define DRIVE_REMOVABLE
Definition: winbase.h:248
PDOS_DATA DosData
Definition: dos.c:45
PCWSTR FilePath
DWORD Id
DWORD WINAPI DECLSPEC_HOTPATCH SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
Definition: fileinfo.c:204
HANDLE FileHandle
Definition: stats.c:38
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
BYTE DosFindFreeDescriptor(VOID)
Definition: dosfiles.c:69
BYTE CurrentDrive
Definition: dos.h:159
#define DRIVE_REMOTE
Definition: winbase.h:250
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
BOOL WINAPI UnlockFile(IN HANDLE hFile, IN DWORD dwFileOffsetLow, IN DWORD dwFileOffsetHigh, IN DWORD nNumberOfBytesToUnlockLow, IN DWORD nNumberOfBytesToUnlockHigh)
Definition: lock.c:142
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
union node Node
Definition: types.h:1255
DWORD WINAPI GetFileAttributesA(LPCSTR lpFileName)
Definition: fileinfo.c:786
#define GENERIC_WRITE
Definition: nt_native.h:90
_In_ PEPROCESS _In_ KPROCESSOR_MODE AccessMode
Definition: mmfuncs.h:396
struct NameRec_ * Name
Definition: cdprocs.h:464
#define MAKELONG(a, b)
Definition: typedefs.h:248
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
WORD UnreadConInput
Definition: dos.h:76
void DPRINT(...)
Definition: polytest.cpp:61
_IRQL_requires_same_ typedef _In_ ULONG ControlCode
Definition: wmitypes.h:55
Definition: bufpool.h:45
#define FAR_POINTER(x)
Definition: emulator.h:31
const char * LPCSTR
Definition: xmlstorage.h:183
BOOLEAN DosControlBreak(VOID)
Definition: dos.c:181
#define DRIVE_UNKNOWN
Definition: winbase.h:253
#define OPEN_EXISTING
Definition: compat.h:434
PDOS_FILE_DESCRIPTOR DosGetHandleFileDescriptor(WORD DosHandle)
Definition: dosfiles.c:173
#define PCHAR
Definition: match.c:90
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
WORD * PWORD
Definition: pedump.c:67
#define DOS_DATA_SEGMENT
Definition: dos.h:33
_In_ HANDLE Handle
Definition: extypes.h:390
BOOL WINAPI FlushFileBuffers(IN HANDLE hFile)
Definition: fileinfo.c:175
#define FILE_END
Definition: winbase.h:114
WORD DosSeekFile(WORD FileHandle, LONG Offset, BYTE Origin, LPDWORD NewOffset)
Definition: dosfiles.c:1001
#define FILE_INFO_DEVICE
Definition: dosfiles.h:16
DWORD WINAPI GetShortPathNameA(IN LPCSTR lpszLongPath, OUT LPSTR lpszShortPath, IN DWORD cchBuffer)
Definition: path.c:1751
#define MAX_PATH
Definition: compat.h:26
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:481
#define OPEN_ALWAYS
Definition: disk.h:70
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
VOID WINAPI setDX(USHORT)
Definition: registers.c:293
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define TO_LINEAR(seg, off)
Definition: emulator.h:22
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:126
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
unsigned char BYTE
Definition: mem.h:68
PDOS_SDA Sda
Definition: dos.c:48
#define GENERIC_READ
Definition: compat.h:124
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
BOOL WINAPI LockFile(IN HANDLE hFile, IN DWORD dwFileOffsetLow, IN DWORD dwFileOffsetHigh, IN DWORD nNumberOfBytesToLockLow, IN DWORD nNumberOfBytesToLockHigh)
Definition: lock.c:25
#define DRIVE_NO_ROOT_DIR
Definition: winbase.h:254
#define DRIVE_FIXED
Definition: winbase.h:249
WORD DosOpenFile(LPWORD Handle, LPCSTR FilePath, BYTE AccessShareModes)
Definition: dosfiles.c:521
struct _DOS_SFT * PDOS_SFT
WORD DosCreateFile(LPWORD Handle, LPCSTR FilePath, DWORD CreationDisposition, WORD Attributes)
Definition: dosfiles.c:442
uint16_t * LPWORD
Definition: typedefs.h:54
BOOLEAN DosLockFile(WORD DosHandle, DWORD Offset, DWORD Size)
Definition: dosfiles.c:1082
BOOLEAN DosDeviceIoControl(WORD FileHandle, BYTE ControlCode, DWORD Buffer, PWORD Length)
Definition: dosfiles.c:1185
#define CREATE_ALWAYS
Definition: disk.h:72
#define FILE_BEGIN
Definition: winbase.h:112
WORD DosCreateFileEx(LPWORD Handle, LPWORD CreationStatus, LPCSTR FilePath, BYTE AccessShareModes, WORD CreateActionFlags, WORD Attributes)
Definition: dosfiles.c:181
_Must_inspect_result_ _In_ USHORT _In_ PHIDP_PREPARSED_DATA _Out_writes_to_ LengthAttributes PHIDP_EXTENDED_ATTRIBUTES Attributes
Definition: hidpi.h:348
#define ERROR_TOO_MANY_OPEN_FILES
Definition: winerror.h:107
_CRTIMP char *__cdecl _strupr(_Inout_z_ char *_String)
LPVOID lpSecurityDescriptor
Definition: compat.h:181
PDOS_DEVICE_NODE DosGetDriverNode(DWORD Driver)
Definition: device.c:305
unsigned short USHORT
Definition: pedump.c:61
static VOID StoreNameInSft(LPCSTR FilePath, PDOS_FILE_DESCRIPTOR Descriptor)
Definition: dosfiles.c:30
WORD NumDescriptors
Definition: dosfiles.h:67
PDOS_SYSVARS SysVars
Definition: dos.c:47
PDOS_DEVICE_NODE DosGetDevice(LPCSTR DeviceName)
Definition: device.c:342
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
#define DRIVE_CDROM
Definition: winbase.h:251
BYTE DosReadLineBuffered(WORD FileHandle, DWORD Buffer, BYTE MaxSize)
Definition: dosfiles.c:674
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
DWORD FirstSft
Definition: dos.h:81
BOOLEAN DosDeviceIoControlDrive(WORD DriveNumber, BYTE ControlCode, DWORD Buffer, PWORD Result)
Definition: dosfiles.c:1128
FAST486_STATE EmulatorContext
Definition: cpu.c:39
char * strchr(const char *String, int ch)
Definition: utclib.c:501
#define DPRINT1
Definition: precomp.h:8
WORD DosWriteFile(WORD FileHandle, DWORD Buffer, WORD Count, LPWORD BytesWritten)
Definition: dosfiles.c:915
uint32_t * LPDWORD
Definition: typedefs.h:57
#define HIWORD(l)
Definition: typedefs.h:246
#define UNIMPLEMENTED
Definition: debug.h:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define FILE_INFO_STDIN
Definition: dosfiles.h:13
BYTE DosFindDeviceDescriptor(DWORD DevicePointer)
Definition: dosfiles.c:123
#define CREATE_NEW
Definition: disk.h:69
#define TRUNCATE_EXISTING
Definition: disk.h:71
#define ERROR_ALREADY_EXISTS
Definition: disk.h:80
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:407
BOOL WINAPI ReadFile(IN HANDLE hFile, IN LPVOID lpBuffer, IN DWORD nNumberOfBytesToRead, OUT LPDWORD lpNumberOfBytesRead OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:123
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:593
#define LOWORD(l)
Definition: pedump.c:82
BOOLEAN DosUnlockFile(WORD DosHandle, DWORD Offset, DWORD Size)
Definition: dosfiles.c:1105
_Inout_opt_ PUNICODE_STRING Extension
Definition: fltkernel.h:1092
ULONG ACCESS_MASK
Definition: nt_native.h:40
_Must_inspect_result_ _In_ PFILE_OBJECT _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ FLT_IO_OPERATION_FLAGS _Out_opt_ PULONG BytesRead
Definition: fltkernel.h:1255
WORD DosOpenHandle(BYTE DescriptorId)
Definition: handle.c:200
DWORD Link
Definition: dosfiles.h:66
VOID FASTCALL EmulatorReadMemory(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
Definition: memory.c:139
Definition: dlist.c:348
VOID DosEchoCharacter(CHAR Character)
Definition: bios.c:48
_In_ PSTORAGE_PROPERTY_ID _Outptr_ PSTORAGE_DESCRIPTOR_HEADER * Descriptor
Definition: classpnp.h:966