source: trunk/src/kernel32/oslibdos.cpp@ 21453

Last change on this file since 21453 was 21437, checked in by ydario, 15 years ago

Restored old thread affinity mask, flash10 ticket:18.
File size: 109.0 KB
Line 
1/* $Id: oslibdos.cpp,v 1.120 2003/06/02 16:25:19 sandervl Exp $ */
2/*
3 * Wrappers for OS/2 Dos* API
4 *
5 * Copyright 1998-2000 Sander van Leeuwen (sandervl@xs4all.nl)
6 * Copyright 1999-2000 Edgar Buerkle (Edgar.Buerkle@gmx.net)
7 * Copyright 2000 Przemyslaw Dobrowolski (dobrawka@asua.org.pl)
8 * Copyright 2000 Christoph Bratschi (cbratschi@datacomm.ch)
9 * Copyright 2000 knut st. osmundsen (knut.stange.osmundsen@mynd.no)
10 *
11 * Project Odin Software License can be found in LICENSE.TXT
12 *
13 */
14
15
16
17/*******************************************************************************
18* Header Files *
19*******************************************************************************/
20#define INCL_BASE
21#define INCL_DOSEXCEPTIONS
22#define INCL_DOSMEMMGR
23#define INCL_DOSPROCESS
24#define INCL_DOSFILEMGR
25#define INCL_DOSERRORS
26#define INCL_DOSDEVIOCTL
27#define INCL_DOSDEVICES
28#define INCL_NPIPES
29#include <os2wrap.h> //Odin32 OS/2 api wrappers
30#include <stdlib.h>
31#include <stdio.h>
32#include <string.h>
33#include <ctype.h>
34#include <win32api.h>
35#include <winconst.h>
36#include <win\winioctl.h>
37#include <misc.h>
38#include <odincrt.h>
39#include "initterm.h"
40#include "oslibdos.h"
41#include "dosqss.h"
42#include "win32k.h"
43
44#define DBG_LOCALLOG DBG_oslibdos
45#include "dbglocal.h"
46
47
48/*******************************************************************************
49* Structures and Typedefs *
50*******************************************************************************/
51#ifndef DEVTYPE_OPTICAL
52#define DEVTYPE_OPTICAL 0x0008
53#endif
54
55#define IOC_CDROM_2 0x82 /* from cdioctl.h (ddk, os2cdrom.dmd sample) */
56#define IOCD_RETURN_DRIVE_LETTER 0x60
57
58
59// used for input to logical disk Get device parms Ioctl
60#pragma pack(1)
61typedef struct
62{
63 UCHAR Infotype;
64 UCHAR DriveUnit;
65} DSKREQ;
66
67/*------------------------------------------------*
68 * Cat 0x82, Func 0x60: Return Drive Letter Info *
69 *------------------------------------------------*/
70typedef struct DriveLetter_Data
71{
72 USHORT drive_count;
73 USHORT first_drive_number;
74} CDDRVLTR;
75#pragma pack()
76
77
78/*******************************************************************************
79* Global Variables *
80*******************************************************************************/
81static PROC_DosSetFileSizeL DosSetFileSizeLProc = 0;
82static PROC_DosSetFilePtrL DosSetFilePtrLProc = 0;
83static PROC_DosSetFileLocksL DosSetFileLocksLProc = 0;
84static PROC_DosOpenL DosOpenLProc = 0;
85static BOOL f64BitIO = FALSE;
86
87/* first user queries the data */
88static CDDRVLTR cdDrvLtr = {0xffff, 0xffff};
89
90
91/*******************************************************************************
92* Functions Prototypes. *
93*******************************************************************************/
94BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d );
95BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d );
96
97
98char* ODINHelperStripUNC(char* strUNC)
99{
100 char *retStr = strUNC;
101
102 if (!strUNC) return NULL;
103
104 /* first possible case */
105 if (strUNC[0] == '\\' &&
106 (strUNC[1] == '?' || (strUNC[1] >= 'A' && strUNC[1] <= 'Z' )) &&
107 strUNC[2] == '\\')
108 {
109
110 retStr = &strUNC[3];
111 }
112 /* second possible case */
113 if (strUNC[0] == '\\' && strUNC[1] == '\\' &&
114 (strUNC[2] == '?' || (strUNC[2] >= 'A' && strUNC[2] <= 'Z' )) &&
115 strUNC[3] == '\\')
116 {
117
118 retStr = &strUNC[4];
119 }
120 return retStr;
121}
122
123//******************************************************************************
124//******************************************************************************
125void OSLibInitWSeBFileIO()
126{
127 HMODULE hDoscalls;
128
129 if(DosQueryModuleHandleStrict("DOSCALLS", &hDoscalls) != NO_ERROR) {
130 return;
131 }
132 if(DosQueryProcAddr(hDoscalls, 989, NULL, (PFN *)&DosSetFileSizeLProc) != NO_ERROR) {
133 return;
134 }
135 if(DosQueryProcAddr(hDoscalls, 988, NULL, (PFN *)&DosSetFilePtrLProc) != NO_ERROR) {
136 return;
137 }
138 if(DosQueryProcAddr(hDoscalls, 986, NULL, (PFN *)&DosSetFileLocksLProc) != NO_ERROR) {
139 return;
140 }
141 if(DosQueryProcAddr(hDoscalls, 981, NULL, (PFN *)&DosOpenLProc) != NO_ERROR) {
142 return;
143 }
144 f64BitIO = TRUE;
145}
146//******************************************************************************
147//******************************************************************************
148APIRET OdinDosSetFileSizeL(HFILE hFile, LONGLONG cbSize)
149{
150 APIRET yyrc;
151 USHORT sel = RestoreOS2FS();
152
153 yyrc = DosSetFileSizeLProc(hFile, cbSize);
154 SetFS(sel);
155
156 return yyrc;
157}
158//******************************************************************************
159//******************************************************************************
160APIRET OdinDosSetFilePtrL(HFILE hFile, LONGLONG ib, ULONG method, PLONGLONG ibActual)
161{
162 APIRET yyrc;
163 USHORT sel = RestoreOS2FS();
164
165 yyrc = DosSetFilePtrLProc(hFile, ib, method, ibActual);
166 SetFS(sel);
167
168 return yyrc;
169}
170//******************************************************************************
171//******************************************************************************
172APIRET OdinDosSetFileLocksL(HFILE hFile, PFILELOCKL pflUnlock, PFILELOCKL pflLock,
173 ULONG timeout, ULONG flags)
174{
175 APIRET yyrc;
176 USHORT sel = RestoreOS2FS();
177
178 yyrc = DosSetFileLocksLProc(hFile, pflUnlock, pflLock, timeout, flags);
179 SetFS(sel);
180
181 return yyrc;
182}
183//******************************************************************************
184//******************************************************************************
185APIRET APIENTRY OdinDosOpenL(PCSZ pszFileName,
186 PHFILE phf,
187 PULONG pulAction,
188 LONGLONG cbFile,
189 ULONG ulAttribute,
190 ULONG fsOpenFlags,
191 ULONG fsOpenMode,
192 PEAOP2 peaop2)
193{
194 APIRET yyrc;
195 USHORT sel = RestoreOS2FS();
196 char OemFileName[260];
197 CharToOemA(ODINHelperStripUNC((char*)pszFileName), OemFileName);
198
199 if(DosOpenLProc) {
200 yyrc = DosOpenLProc(OemFileName, phf, pulAction, cbFile, ulAttribute, fsOpenFlags,
201 fsOpenMode, peaop2);
202 }
203 else yyrc = DosOpen(OemFileName, phf, pulAction, cbFile.ulLo, ulAttribute, fsOpenFlags,
204 fsOpenMode, peaop2);
205 SetFS(sel);
206
207 return yyrc;
208}
209//******************************************************************************
210// translate OS/2 error codes to Windows codes
211// NOTE: add all codes you need, list is not complete!
212//******************************************************************************
213DWORD error2WinError(APIRET rc,DWORD defaultCode)
214{
215 switch (rc)
216 {
217 case NO_ERROR: //0
218 return ERROR_SUCCESS_W;
219
220 case ERROR_INVALID_FUNCTION: //1
221 return ERROR_INVALID_FUNCTION_W;
222
223 case ERROR_FILE_NOT_FOUND: //2
224 return ERROR_FILE_NOT_FOUND_W;
225
226 case ERROR_PATH_NOT_FOUND: //3
227 return ERROR_PATH_NOT_FOUND_W;
228
229 case ERROR_TOO_MANY_OPEN_FILES: //4
230 return ERROR_TOO_MANY_OPEN_FILES_W;
231
232 case ERROR_ACCESS_DENIED: //5
233 return ERROR_ACCESS_DENIED_W;
234
235 case ERROR_INVALID_HANDLE: //6
236 return ERROR_INVALID_HANDLE_W;
237
238 case ERROR_NOT_ENOUGH_MEMORY: //8
239 return ERROR_NOT_ENOUGH_MEMORY_W;
240
241 case ERROR_BAD_FORMAT: //11
242 return ERROR_BAD_FORMAT_W;
243
244 case ERROR_INVALID_ACCESS: //12
245 return ERROR_INVALID_ACCESS_W;
246
247 case ERROR_INVALID_DATA: //13
248 return ERROR_INVALID_DATA_W;
249
250 case ERROR_INVALID_DRIVE: //15
251 return ERROR_INVALID_DRIVE_W;
252
253 case ERROR_CURRENT_DIRECTORY: // 16
254 return ERROR_CURRENT_DIRECTORY_W;
255
256 case ERROR_NO_MORE_FILES: //18
257 return ERROR_NO_MORE_FILES_W;
258
259 case ERROR_WRITE_PROTECT: //19
260 return ERROR_WRITE_PROTECT_W;
261
262 case ERROR_BAD_UNIT: //20
263 return ERROR_BAD_UNIT_W;
264
265 case ERROR_NOT_READY: //21
266 return ERROR_NOT_READY_W;
267
268 case ERROR_CRC: //23
269 return ERROR_CRC_W;
270
271 case ERROR_SEEK:
272 return ERROR_SEEK_W;
273
274 case ERROR_NOT_DOS_DISK: //26
275 return ERROR_NOT_DOS_DISK_W;
276
277 case ERROR_WRITE_FAULT: //29
278 return ERROR_WRITE_FAULT_W;
279
280 case ERROR_GEN_FAILURE: //31
281 return ERROR_GEN_FAILURE_W;
282
283 case ERROR_SHARING_VIOLATION: //32
284 return ERROR_SHARING_VIOLATION_W;
285
286 case ERROR_LOCK_VIOLATION: //32
287 return ERROR_LOCK_VIOLATION_W;
288
289 case ERROR_WRONG_DISK: //34
290 return ERROR_WRONG_DISK_W;
291
292 case ERROR_SHARING_BUFFER_EXCEEDED: //36
293 return ERROR_SHARING_BUFFER_EXCEEDED_W;
294
295 case ERROR_BAD_NETPATH: //53
296 return ERROR_BAD_NETPATH_W;
297
298 case ERROR_CANNOT_MAKE: //82
299 return ERROR_CANNOT_MAKE_W;
300
301 case ERROR_OUT_OF_STRUCTURES: //84
302 return ERROR_OUT_OF_STRUCTURES_W;
303
304 case ERROR_INVALID_PARAMETER: //87
305 return ERROR_INVALID_PARAMETER_W;
306
307 case ERROR_INTERRUPT: //95
308 return ERROR_INVALID_AT_INTERRUPT_TIME_W; //CB: right???
309
310 case ERROR_DEVICE_IN_USE: //99
311 return ERROR_DEVICE_IN_USE_W;
312
313 case ERROR_TOO_MANY_SEMAPHORES: //100
314 return ERROR_TOO_MANY_SEMAPHORES_W;
315
316 case ERROR_DISK_CHANGE: // 107
317 return ERROR_DISK_CHANGE_W;
318
319 case ERROR_DRIVE_LOCKED: //108
320 return ERROR_DRIVE_LOCKED_W;
321
322 case ERROR_BROKEN_PIPE: //109
323 return ERROR_BROKEN_PIPE_W;
324
325 case ERROR_OPEN_FAILED: //110
326 return ERROR_OPEN_FAILED_W;
327
328 case ERROR_BUFFER_OVERFLOW: //111
329 return ERROR_BUFFER_OVERFLOW_W;
330
331 case ERROR_DISK_FULL: //112
332 return ERROR_DISK_FULL_W;
333
334 case ERROR_NO_MORE_SEARCH_HANDLES: //113
335 return ERROR_NO_MORE_SEARCH_HANDLES_W;
336
337 case ERROR_SEM_TIMEOUT: //121
338 return ERROR_SEM_TIMEOUT_W;
339
340 case ERROR_INVALID_NAME:
341 return ERROR_INVALID_NAME_W;
342
343 case ERROR_DIRECT_ACCESS_HANDLE: //130
344 return ERROR_DIRECT_ACCESS_HANDLE_W;
345
346 case ERROR_NEGATIVE_SEEK: //131
347 return ERROR_NEGATIVE_SEEK;
348
349 case ERROR_SEEK_ON_DEVICE: //132
350 return ERROR_SEEK_ON_DEVICE_W;
351
352 case ERROR_DISCARDED: //157
353 return ERROR_DISCARDED_W;
354
355 case ERROR_INVALID_EXE_SIGNATURE: // 191
356 return ERROR_INVALID_EXE_SIGNATURE_W;
357
358 case ERROR_EXE_MARKED_INVALID: // 192
359 return ERROR_EXE_MARKED_INVALID_W;
360
361 case ERROR_BAD_EXE_FORMAT: // 193
362 return ERROR_BAD_EXE_FORMAT_W;
363
364 case ERROR_FILENAME_EXCED_RANGE: //206
365 return ERROR_FILENAME_EXCED_RANGE_W;
366
367 case ERROR_META_EXPANSION_TOO_LONG: //208
368 return ERROR_META_EXPANSION_TOO_LONG_W;
369
370 case ERROR_BAD_PIPE: //230
371 return ERROR_BAD_PIPE_W;
372
373 case ERROR_PIPE_BUSY: //231
374 return ERROR_PIPE_BUSY_W;
375
376 case ERROR_NO_DATA: //232
377 return ERROR_NO_DATA_W;
378
379 case ERROR_PIPE_NOT_CONNECTED: //233
380 return ERROR_PIPE_NOT_CONNECTED_W;
381
382 case ERROR_MORE_DATA: //234
383 return ERROR_MORE_DATA_W;
384
385 case ERROR_INVALID_PATH: //253
386 return ERROR_INVALID_NAME_W;
387
388 case ERROR_INVALID_EA_NAME: //254
389 return ERROR_INVALID_EA_NAME_W;
390
391 case ERROR_EA_LIST_INCONSISTENT: //255
392 return ERROR_EA_LIST_INCONSISTENT_W;
393
394 case ERROR_EAS_DIDNT_FIT: //275
395 return ERROR_EAS_DIDNT_FIT;
396
397 case ERROR_INIT_ROUTINE_FAILED: //295
398 return ERROR_DLL_INIT_FAILED_W;
399
400 // device driver specific error codes (I24)
401 case ERROR_USER_DEFINED_BASE + ERROR_I24_WRITE_PROTECT:
402 return ERROR_WRITE_PROTECT_W;
403
404 case ERROR_USER_DEFINED_BASE + ERROR_I24_BAD_UNIT:
405 return ERROR_BAD_UNIT_W;
406
407 case ERROR_USER_DEFINED_BASE + ERROR_I24_NOT_READY:
408 return ERROR_NOT_READY_W;
409
410 case ERROR_USER_DEFINED_BASE + ERROR_I24_BAD_COMMAND:
411 return ERROR_BAD_COMMAND_W;
412
413 case ERROR_USER_DEFINED_BASE + ERROR_I24_CRC:
414 return ERROR_CRC_W;
415
416 case ERROR_USER_DEFINED_BASE + ERROR_I24_BAD_LENGTH:
417 return ERROR_BAD_LENGTH_W;
418
419 case ERROR_USER_DEFINED_BASE + ERROR_I24_SEEK:
420 return ERROR_SEEK_W;
421
422 case ERROR_USER_DEFINED_BASE + ERROR_I24_NOT_DOS_DISK:
423 return ERROR_NOT_DOS_DISK_W;
424
425 case ERROR_USER_DEFINED_BASE + ERROR_I24_SECTOR_NOT_FOUND:
426 return ERROR_SECTOR_NOT_FOUND_W;
427
428// @@@PH this error code is not defined in winconst.h
429// case ERROR_USER_DEFINED_BASE + ERROR_I24_OUT_OF_PAPER:
430// return 28;
431
432 case ERROR_USER_DEFINED_BASE + ERROR_I24_WRITE_FAULT:
433 return ERROR_WRITE_FAULT_W;
434
435 case ERROR_USER_DEFINED_BASE + ERROR_I24_READ_FAULT:
436 return ERROR_READ_FAULT_W;
437
438 case ERROR_USER_DEFINED_BASE + ERROR_I24_GEN_FAILURE:
439 return ERROR_GEN_FAILURE_W;
440
441 case ERROR_USER_DEFINED_BASE + ERROR_I24_DISK_CHANGE:
442 return ERROR_DISK_CHANGE_W;
443
444 case ERROR_USER_DEFINED_BASE + ERROR_I24_WRONG_DISK:
445 return ERROR_WRONG_DISK_W;
446
447 case ERROR_USER_DEFINED_BASE + ERROR_I24_INVALID_PARAMETER:
448 return ERROR_INVALID_PARAMETER_W;
449
450 case ERROR_USER_DEFINED_BASE + ERROR_I24_DEVICE_IN_USE:
451 return ERROR_DEVICE_IN_USE_W;
452
453 default:
454 dprintf(("WARNING: error2WinError: error %d not included!!!!", rc));
455 return defaultCode;
456 }
457}
458//******************************************************************************
459//******************************************************************************
460DWORD OSLibDosOpen(char *lpszFileName, DWORD flags)
461{
462 APIRET rc;
463 HFILE hFile;
464 ULONG ulAction;
465 DWORD os2flags = OPEN_FLAGS_NOINHERIT; //default is not inherited by child processes
466 char lOemFileName[260];
467
468 CharToOemA(ODINHelperStripUNC(lpszFileName), lOemFileName);
469
470 if(flags & OSLIB_ACCESS_READONLY)
471 os2flags |= OPEN_ACCESS_READONLY;
472 else
473 if(flags & OSLIB_ACCESS_READWRITE)
474 os2flags |= OPEN_ACCESS_READWRITE;
475
476 if(flags & OSLIB_ACCESS_SHAREDENYNONE)
477 os2flags |= OPEN_SHARE_DENYNONE;
478 else
479 if(flags & OSLIB_ACCESS_SHAREDENYREAD)
480 os2flags |= OPEN_SHARE_DENYREAD;
481 else
482 if(flags & OSLIB_ACCESS_SHAREDENYWRITE)
483 os2flags |= OPEN_SHARE_DENYWRITE;
484
485tryopen:
486 rc = DosOpen(lOemFileName, /* File path name */
487 &hFile, /* File handle */
488 &ulAction, /* Action taken */
489 0L, /* File primary allocation */
490 0L, /* File attribute */
491 OPEN_ACTION_FAIL_IF_NEW |
492 OPEN_ACTION_OPEN_IF_EXISTS, /* Open function type */
493 os2flags,
494 0L); /* No extended attribute */
495 if(rc)
496 {
497 if(rc == ERROR_TOO_MANY_OPEN_FILES)
498 {
499 ULONG CurMaxFH;
500 LONG ReqCount = 32;
501
502 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
503 if(rc)
504 {
505 dprintf(("DosSetRelMaxFH returned %d", rc));
506 return 0;
507 }
508 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
509 goto tryopen;
510 }
511
512 SetLastError(error2WinError(rc));
513 return 0;
514 }
515
516 // OK, file was opened
517 SetLastError(ERROR_SUCCESS_W);
518 return hFile;
519}
520//******************************************************************************
521//******************************************************************************
522BOOL OSLibDosClose(DWORD hFile)
523{
524 APIRET rc;
525
526 rc = DosClose(hFile);
527 SetLastError(error2WinError(rc));
528 return (rc == NO_ERROR);
529}
530//******************************************************************************
531//******************************************************************************
532BOOL OSLibDosCopyFile(LPCSTR lpszOldFile, LPCSTR lpszNewFile, BOOL fFailIfExist)
533{
534 APIRET rc;
535 char lOemOldFile[260], lOemNewFile[260];
536
537 CharToOemA(ODINHelperStripUNC((char*)lpszOldFile), lOemOldFile);
538 CharToOemA(ODINHelperStripUNC((char*)lpszNewFile), lOemNewFile);
539
540 rc = DosCopy((PSZ)lOemOldFile, (PSZ)lOemNewFile, fFailIfExist ? 0: DCPY_EXISTING);
541 SetLastError(error2WinError(rc));
542 return (rc == NO_ERROR);
543}
544//******************************************************************************
545//******************************************************************************
546BOOL OSLibDosMoveFile(LPCSTR lpszOldFile, LPCSTR lpszNewFile)
547{
548 APIRET rc;
549 char lOemOldFile[260], lOemNewFile[260];
550
551 CharToOemA(ODINHelperStripUNC((char*)lpszOldFile), lOemOldFile);
552 CharToOemA(ODINHelperStripUNC((char*)lpszNewFile), lOemNewFile);
553
554 // we need to know the current drive for relative paths
555 ULONG diskNum, logicalBitmap;
556 DosQueryCurrentDisk(&diskNum, &logicalBitmap);
557 char currentDrive = 'A' + diskNum - 1;
558
559 // first determine whether source and target paths are absolute
560 // (i.e. contain a drive letter)
561 BOOL sourcePathAbsolute = FALSE;
562 char sourceDrive = currentDrive;
563 if ((strlen(lOemOldFile) > 2) && (lOemOldFile[1] == ':'))
564 {
565 sourcePathAbsolute = TRUE;
566 sourceDrive = toupper(lOemOldFile[0]);
567 }
568 BOOL targetPathAbsolute = FALSE;
569 char targetDrive = currentDrive;
570 if ((strlen(lOemNewFile) > 2) && (lOemNewFile[1] == ':'))
571 {
572 targetPathAbsolute = TRUE;
573 targetDrive = toupper(lOemNewFile[0]);
574 }
575
576 // if the source and target drives are different, we have to do take
577 // the copy and delete path
578 if (sourceDrive != targetDrive)
579 {
580 dprintf(("OSLibDosMoveFile - different drives, doing the copy/delete approach (WARNING: non atomic file system operation!)"));
581 // @@@AH TODO: this is not atomic. Maybe it is on Windows - we have to check this
582 rc = DosCopy((PSZ)lOemOldFile, (PSZ)lOemNewFile, 0);
583 if (rc == NO_ERROR)
584 {
585 rc = DosDelete(lOemOldFile);
586 }
587 SetLastError(error2WinError(rc));
588 } else
589 {
590 // atomic DosMove will do fine
591 rc = DosMove((PSZ)lOemOldFile, (PSZ)lOemNewFile);
592 SetLastError(error2WinError(rc));
593 }
594 return (rc == NO_ERROR);
595}
596//******************************************************************************
597//******************************************************************************
598BOOL OSLibDosRemoveDir(LPCSTR lpszDir)
599{
600 APIRET rc;
601 char lOemDir[260];
602
603 CharToOemA(ODINHelperStripUNC((char*)lpszDir), lOemDir);
604
605 rc = DosDeleteDir((PSZ)lOemDir);
606 SetLastError(error2WinError(rc));
607 return (rc == NO_ERROR);
608}
609//******************************************************************************
610//******************************************************************************
611BOOL OSLibDosCreateDirectory(LPCSTR lpszDir)
612{
613 APIRET rc;
614 char lOemDir[260];
615
616 CharToOemA(ODINHelperStripUNC((char*)lpszDir), lOemDir);
617
618 rc = DosCreateDir((PSZ)lOemDir, NULL);
619 SetLastError(error2WinError(rc));
620 return (rc == NO_ERROR);
621}
622//******************************************************************************
623//******************************************************************************
624DWORD OSLibDosChangeMaxFileHandles()
625{
626 ULONG CurMaxFH;
627 LONG ReqCount = 0;
628 APIRET rc;
629
630 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
631 if(rc) {
632 dprintf(("DosSetRelMaxFH returned %d", rc));
633 return rc;
634 }
635 if(ReqCount + ODIN_INCREMENT_MAX_FILEHANDLES > CurMaxFH) {
636 ReqCount = CurMaxFH + ODIN_INCREMENT_MAX_FILEHANDLES;
637 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
638 if(rc) {
639 dprintf(("DosSetRelMaxFH returned %d", rc));
640 return rc;
641 }
642 }
643 return 0;
644}
645//******************************************************************************
646//******************************************************************************
647DWORD OSLibDosSetInitialMaxFileHandles(DWORD maxhandles)
648{
649 ULONG CurMaxFH;
650 LONG ReqCount = 0;
651 APIRET rc;
652
653 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
654 if(rc) {
655 dprintf(("DosSetRelMaxFH returned %d", rc));
656 return rc;
657 }
658 if(CurMaxFH < maxhandles) {
659 rc = DosSetMaxFH(maxhandles);
660 if(rc) {
661 dprintf(("DosSetMaxFH returned %d", rc));
662 return rc;
663 }
664 }
665 return 0;
666}
667//******************************************************************************
668//******************************************************************************
669BOOL OSLibDosRead(DWORD hFile, LPVOID lpBuffer, DWORD size, DWORD *nrBytesRead)
670{
671 APIRET rc;
672
673 rc = DosRead(hFile, lpBuffer, size, nrBytesRead);
674 SetLastError(error2WinError(rc));
675 return (rc == NO_ERROR);
676}
677//******************************************************************************
678//******************************************************************************
679BOOL OSLibDosWrite(DWORD hFile, LPVOID lpBuffer, DWORD size, DWORD *nrBytesWritten)
680{
681 APIRET rc;
682
683 rc = DosWrite(hFile, lpBuffer, size, nrBytesWritten);
684 SetLastError(error2WinError(rc));
685 return (rc == NO_ERROR);
686}
687//******************************************************************************
688//******************************************************************************
689DWORD OSLibDosSetFilePtr(DWORD hFile, DWORD offset, DWORD method)
690{
691 DWORD os2method;
692 DWORD newoffset;
693 APIRET rc;
694
695 switch(method)
696 {
697 case OSLIB_SETPTR_FILE_CURRENT:
698 os2method = FILE_CURRENT;
699 break;
700 case OSLIB_SETPTR_FILE_BEGIN:
701 os2method = FILE_BEGIN ;
702 break;
703 case OSLIB_SETPTR_FILE_END:
704 os2method = FILE_END;
705 break;
706 default:
707 return OSLIB_ERROR_INVALID_PARAMETER;
708 }
709
710 rc = DosSetFilePtr(hFile, offset, os2method, &newoffset);
711 if(rc)
712 {
713 SetLastError(error2WinError(rc));
714 return -1;
715 }
716 SetLastError(ERROR_SUCCESS_W);
717 return newoffset;
718}
719//******************************************************************************
720//******************************************************************************
721BOOL OSLibDosDelete(char *lpszFileName)
722{
723 APIRET rc;
724 char lOemFileName[260];
725
726 CharToOemA(ODINHelperStripUNC(lpszFileName), lOemFileName);
727
728 rc = DosDelete(lOemFileName);
729 if(rc) {
730 SetLastError(error2WinError(rc));
731 return FALSE;
732 }
733 return TRUE;
734}
735//******************************************************************************
736//******************************************************************************
737BOOL pmDateTimeToFileTime(FDATE *pDate,FTIME *pTime,FILETIME *pFT)
738{
739 USHORT dosTime, dosDate;
740 BOOL ret;
741 FILETIME dummy;
742
743 dosTime = *(USHORT*)pTime;
744 dosDate = *(USHORT*)pDate;
745
746 //time we get from OS2 is local time; win32 expects file time (UTC)
747 ret = DosDateTimeToFileTime(dosDate, dosTime, &dummy);
748 if(ret) ret = LocalFileTimeToFileTime(&dummy, pFT);
749 return ret;
750}
751//******************************************************************************
752//******************************************************************************
753BOOL pmFileTimeToDateTime(FILETIME *pFT, FDATE *pDate, FTIME *pTime)
754{
755 BOOL ret;
756 FILETIME dummy;
757 //time we get from win32 is file time (UTC); OS2 expects local time
758 ret = FileTimeToLocalFileTime(pFT, &dummy);
759 if (ret) ret = FileTimeToDosDateTime(&dummy, (WORD*)pDate, (WORD*)pTime);
760 return ret;
761}
762//******************************************************************************
763//******************************************************************************
764#define NOT_NORMAL (FILE_ATTRIBUTE_READONLY_W | \
765 FILE_ATTRIBUTE_HIDDEN_W | \
766 FILE_ATTRIBUTE_SYSTEM_W | \
767 FILE_ATTRIBUTE_ARCHIVE_W)
768
769inline DWORD pm2WinFileAttributes(DWORD attrFile)
770{
771 DWORD res = 0;
772
773 if (!(attrFile & NOT_NORMAL))
774 res |= FILE_ATTRIBUTE_NORMAL_W;
775 if (attrFile & FILE_READONLY)
776 res |= FILE_ATTRIBUTE_READONLY_W;
777 if (attrFile & FILE_HIDDEN)
778 res |= FILE_ATTRIBUTE_HIDDEN_W;
779 if (attrFile & FILE_SYSTEM)
780 res |= FILE_ATTRIBUTE_SYSTEM_W;
781 if (attrFile & FILE_DIRECTORY)
782 res |= FILE_ATTRIBUTE_DIRECTORY_W;
783 if (attrFile & FILE_ARCHIVED)
784 res |= FILE_ATTRIBUTE_ARCHIVE_W;
785
786 //CB: not used: FILE_ATTRIBUTE_COMPRESSED_W
787 //PH: NT server will serve appropriate sizes for compressed files
788 // over network. So if realSize < allocatedSize, the file must
789 // be compressed.
790
791 return res;
792}
793//******************************************************************************
794//******************************************************************************
795BOOL OSLibDosGetFileAttributesEx(PSZ pszName,
796 ULONG ulDummy,
797 PVOID pBuffer)
798{
799 APIRET rc; /* API return code */
800 FILESTATUS3 fs3; /* file information structure */
801 LPWIN32_FILE_ATTRIBUTE_DATA lpFad = (LPWIN32_FILE_ATTRIBUTE_DATA) pBuffer;
802
803 // Note: we only handle standard "GetFileExInfoStandard" requests
804 rc = DosQueryPathInfo(ODINHelperStripUNC(pszName), /* query the file information */
805 FIL_STANDARD,
806 &fs3,
807 sizeof(fs3));
808 if (rc != NO_ERROR) /* check for errors */
809 return FALSE; /* raise error condition */
810
811 // convert structure
812 lpFad->dwFileAttributes = pm2WinFileAttributes(fs3.attrFile);
813 pmDateTimeToFileTime(&fs3.fdateCreation, &fs3.ftimeCreation, &lpFad->ftCreationTime);
814 pmDateTimeToFileTime(&fs3.fdateLastAccess, &fs3.ftimeLastAccess, &lpFad->ftLastAccessTime);
815 pmDateTimeToFileTime(&fs3.fdateLastWrite, &fs3.ftimeLastWrite, &lpFad->ftLastWriteTime);
816
817 /* @@@PH we might add Aurora support ...
818 lpFad->nFileSizeHigh = info.nFileSizeHigh;
819 */
820 lpFad->nFileSizeHigh = 0;
821 lpFad->nFileSizeLow = fs3.cbFile;
822
823 return TRUE;
824}
825//******************************************************************************
826DWORD WIN32API GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD );
827//******************************************************************************
828DWORD OSLibDosSearchPath(DWORD cmd, char *path, char *name, char *full_name,
829 DWORD length_fullname)
830{
831 switch(cmd) {
832 case OSLIB_SEARCHDIR:
833 if(DosSearchPath(SEARCH_IGNORENETERRS, ODINHelperStripUNC(path),
834 name, full_name, length_fullname) != 0) {
835 return 0;
836 }
837 return strlen(full_name);
838
839
840 case OSLIB_SEARCHCURDIR:
841 if(DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_CUR_DIRECTORY, ODINHelperStripUNC(path),
842 name, full_name, length_fullname) != 0) {
843 return 0;
844 }
845 return strlen(full_name);
846
847 case OSLIB_SEARCHFILE:
848 {
849 FILESTATUS3 fileinfo;
850
851 if(DosQueryPathInfo(ODINHelperStripUNC(name), FIL_STANDARD, &fileinfo, sizeof(fileinfo)) != 0) {
852 return 0;
853 }
854 strncpy(full_name, name, length_fullname);
855 full_name[length_fullname-1] = 0;
856 return strlen(full_name);
857 }
858
859 case OSLIB_SEARCHENV:
860 {
861 LPSTR envstring;
862 int envsize;
863 CHAR szResult[CCHMAXPATH];
864
865 envsize = GetEnvironmentVariableA(path, NULL, 0);
866 envstring = (LPSTR)malloc(envsize+1);
867 GetEnvironmentVariableA(path, envstring, envsize);
868 if(DosSearchPath(SEARCH_IGNORENETERRS, envstring,
869 name, szResult, sizeof(szResult)) != 0) {
870 free(envstring);
871 return 0;
872 }
873 free(envstring);
874 strcpy(full_name, szResult);
875 return strlen(full_name);
876 }
877 }
878 return 0;
879}
880//******************************************************************************
881//******************************************************************************
882DWORD OSLibDosQueryPathInfo(CHAR *pszPathName,
883 ULONG ulInfoLevel,
884 PVOID pInfoBuf,
885 ULONG cbInfoBuf)
886{
887 APIRET rc = DosQueryPathInfo( ODINHelperStripUNC(pszPathName), ulInfoLevel,
888 pInfoBuf, cbInfoBuf );
889
890 if(rc == ERROR_TOO_MANY_OPEN_FILES)
891 {
892 LONG reqCount = 2;
893 ULONG maxFiles;
894
895 if(DosSetRelMaxFH(&reqCount, &maxFiles) == NO_ERROR)
896 rc = DosQueryPathInfo(pszPathName, ulInfoLevel,
897 pInfoBuf, cbInfoBuf );
898 }
899 return rc;
900}
901//******************************************************************************
902//******************************************************************************
903DWORD OSLibDosCreateFile(CHAR *lpszFile,
904 DWORD fuAccess,
905 DWORD fuShare,
906 LPSECURITY_ATTRIBUTES lpSecurityAttributes,
907 DWORD fuCreate,
908 DWORD fuAttrFlags,
909 HANDLE hTemplateFile)
910{
911 HFILE hFile;
912 ULONG actionTaken = 0;
913 LONGLONG fileSize = {0};
914 ULONG fileAttr = FILE_NORMAL;
915 ULONG openFlag = 0;
916 ULONG openMode = OPEN_FLAGS_NOINHERIT; //default is not inherited by child processes
917 APIRET rc = ERROR_NOT_ENOUGH_MEMORY;
918
919 CHAR* lpszFileLoc = ODINHelperStripUNC(lpszFile);
920
921 //TODO: lpSecurityAttributes (inheritance)
922
923 if(fuAttrFlags & FILE_ATTRIBUTE_ARCHIVE_W)
924 fileAttr |= FILE_ARCHIVED;
925 if(fuAttrFlags & FILE_ATTRIBUTE_HIDDEN_W)
926 fileAttr |= FILE_HIDDEN;
927 if(fuAttrFlags & FILE_ATTRIBUTE_SYSTEM_W)
928 fileAttr |= FILE_SYSTEM;
929 if(fuAttrFlags & FILE_ATTRIBUTE_READONLY_W)
930 fileAttr |= FILE_READONLY;
931 // TODO: FILE_ATTRIBUTE_TEMPORARY_W
932
933 switch(fuCreate)
934 {
935 case CREATE_NEW_W:
936 openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS;
937 break;
938 case CREATE_ALWAYS_W:
939 /* kso 2000-11-26: Not sure if OPEN_ACTION_REPLACE_IF_EXISTS is correct here! It is correct according to
940 * MSDN, but not according to "The Win32 API SuperBible". Anyway I haven't got time to check it out in
941 * NT now.
942 * The problem is that OPEN_ACTION_REPLACE_IF_EXISTS requires write access. It failes with
943 * rc = ERROR_ACCESS_DENIED (5). Quick fix, use OPEN_IF_EXIST if readonly access.
944 */
945 if (fuAccess & GENERIC_WRITE_W)
946 openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS;
947 else
948 openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
949 break;
950 case OPEN_EXISTING_W:
951 openFlag |= OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
952 break;
953 case OPEN_ALWAYS_W:
954 openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
955 break;
956 case TRUNCATE_EXISTING_W:
957 openFlag |= OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS;
958 break;
959 }
960
961 if(fuAttrFlags & FILE_FLAG_WRITE_THROUGH_W) openMode |= OPEN_FLAGS_WRITE_THROUGH;
962 if(fuAttrFlags & FILE_FLAG_NO_BUFFERING_W) openMode |= OPEN_FLAGS_NO_CACHE;
963 if(fuAttrFlags & FILE_FLAG_RANDOM_ACCESS_W) openMode |= OPEN_FLAGS_RANDOM;
964 if(fuAttrFlags & FILE_FLAG_SEQUENTIAL_SCAN_W) openMode |= OPEN_FLAGS_SEQUENTIAL;
965 // TODO: FILE_FLAG_BACKUP_SEMANTICS_W
966 // FILE_FLAG_POSIX_SEMANTICS_W are not supported
967
968 //TODO: FILE_SHARE_DELETE
969 if((fuShare & (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W)) == 0 )
970 openMode |= OPEN_SHARE_DENYREADWRITE;
971 else
972 if((fuShare & (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W)) == (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W))
973 openMode |= OPEN_SHARE_DENYNONE;
974 else
975 if(fuShare & FILE_SHARE_READ_W)
976 openMode |= OPEN_SHARE_DENYWRITE;
977 else
978 if(fuShare & FILE_SHARE_WRITE_W)
979 openMode |= OPEN_SHARE_DENYREAD;
980
981 if(fuAccess == (GENERIC_READ_W | GENERIC_WRITE_W))
982 openMode |= OPEN_ACCESS_READWRITE;
983 else
984 if(fuAccess & GENERIC_READ_W)
985 openMode |= OPEN_ACCESS_READONLY;
986 else
987 //mgp: There seems to be a problem where OPEN_ACCESS_WRITEONLY gives an
988 // Access Error (0x05) if the file is opened with
989 // OPEN_ACTION_OPEN_IF_EXISTS. So, in that case, change it to
990 // OPEN_ACCESS_READWRITE
991 if(fuAccess & GENERIC_WRITE_W)
992 if (openFlag & OPEN_ACTION_OPEN_IF_EXISTS)
993 openMode |= OPEN_ACCESS_READWRITE;
994 else
995 openMode |= OPEN_ACCESS_WRITEONLY;
996
997#if 0
998 //SvL: Not true; verified in NT! (also messed up access of files on
999 // readonly volumes)
1000 // CreateFile with OPEN_ALWAYS & GENERIC_READ on non-existing file
1001 // -> creates 0 size file, WriteFile is not allowed
1002 // Same in OS/2.
1003 /* if creating a file, access cannot be readonly! */
1004 if (openFlag & OPEN_ACTION_CREATE_IF_NEW &&
1005 (!(openMode & OPEN_ACCESS_READWRITE) &&
1006 !(openMode & OPEN_ACCESS_WRITEONLY))) {
1007 openMode |= OPEN_ACCESS_READWRITE;
1008 }
1009#endif
1010
1011 if(strlen(lpszFileLoc) == 2 && lpszFileLoc[1] == ':') {
1012 //app tries to open logical volume/partition
1013 openMode |= OPEN_FLAGS_DASD;
1014 }
1015
1016 int retry = 0;
1017 while (retry < 3)
1018 {
1019 dprintf(("DosOpen %s openFlag=%x openMode=%x", lpszFileLoc, openFlag, openMode));
1020 rc = OdinDosOpenL((PSZ)lpszFileLoc,
1021 &hFile,
1022 &actionTaken,
1023 fileSize,
1024 fileAttr,
1025 openFlag,
1026 openMode,
1027 NULL);
1028 if (rc == ERROR_TOO_MANY_OPEN_FILES)
1029 {
1030 ULONG CurMaxFH;
1031 LONG ReqCount = 32;
1032
1033 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
1034 if(rc) {
1035 dprintf(("DosSetRelMaxFH returned %d", rc));
1036 SetLastError(ERROR_TOO_MANY_OPEN_FILES_W);
1037 return INVALID_HANDLE_VALUE_W;
1038 }
1039 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
1040 }
1041 #if 0
1042 else if (rc == ERROR_ACCESS_DENIED && (openFlag & OPEN_ACTION_REPLACE_IF_EXISTS))
1043 { /* kso: I have great problems with the REPLACE not working
1044 * So, I guess this emulation may help...
1045 * This problem exist on WS4eB SMP FP1 and Warp4 FP14/Kernel 14059 at least.
1046 */
1047 rc = DosOpen((PSZ)lOemFile,
1048 &hFile,
1049 &actionTaken,
1050 fileSize,
1051 fileAttr,
1052 (openFlag & ~OPEN_ACTION_REPLACE_IF_EXISTS) | OPEN_ACTION_OPEN_IF_EXISTS,
1053 openMode,
1054 NULL);
1055 if (rc == NO_ERROR)
1056 {
1057 rc = DosSetFileSize(hFile, 0);
1058 if (!rc && fileSize > 0)
1059 rc = DosSetFileSize(hFile, fileSize);
1060 if (rc)
1061 {
1062 DosClose(hFile);
1063 hFile = NULLHANDLE;
1064
1065 if (rc != ERROR_TOO_MANY_OPEN_FILES)
1066 break;
1067 }
1068 else break;
1069 }
1070 }
1071 #endif
1072 else break;
1073 retry++;
1074 }
1075
1076 if(rc)
1077 {
1078 // @@@AH 2001-06-02 Win2k SP2 returns error 2 in this case
1079 int winError = error2WinError(rc);
1080 if (winError == ERROR_OPEN_FAILED_W || winError == ERROR_PATH_NOT_FOUND_W)
1081 {
1082 //Windows returns ERROR_FILE_EXISTS if create new & file exists
1083 if(fuCreate == CREATE_NEW_W) {
1084 winError = ERROR_FILE_EXISTS_W;
1085 }
1086 else winError = ERROR_FILE_NOT_FOUND_W;
1087 }
1088 SetLastError(winError);
1089 return INVALID_HANDLE_VALUE_W;
1090 }
1091 SetLastError(ERROR_SUCCESS_W);
1092 return hFile;
1093}
1094//******************************************************************************
1095//******************************************************************************
1096DWORD OSLibDosOpenFile(CHAR *lpszFile, UINT fuMode)
1097{
1098 ULONG actionTaken = 0;
1099 LONGLONG fileSize = {0};
1100 ULONG fileAttr = FILE_NORMAL;
1101 ULONG openFlag = 0;
1102 ULONG openMode = OPEN_FLAGS_NOINHERIT; //default is not inherited by child processes
1103 APIRET rc = ERROR_NOT_ENOUGH_MEMORY;
1104 HFILE hFile;
1105
1106 if(!(fuMode & (OF_CREATE_W | OF_READWRITE_W | OF_WRITE_W)))
1107 {
1108 openMode |= OPEN_ACCESS_READONLY;
1109 openFlag |= OPEN_ACTION_OPEN_IF_EXISTS;
1110 }
1111 else
1112 {
1113 if(fuMode & OF_CREATE_W) {
1114 openFlag |= OPEN_ACTION_CREATE_IF_NEW |
1115 OPEN_ACTION_REPLACE_IF_EXISTS;
1116 }
1117 else openFlag |= OPEN_ACTION_OPEN_IF_EXISTS;
1118
1119 if(fuMode & OF_READWRITE_W)
1120 openMode |= OPEN_ACCESS_READWRITE;
1121 else
1122 if(fuMode & OF_WRITE_W)
1123 openMode |= OPEN_ACCESS_WRITEONLY;
1124 else
1125 if(fuMode & OF_CREATE_W)
1126 openMode |= OPEN_ACCESS_READWRITE;
1127 }
1128
1129 if((fuMode & OF_SHARE_DENY_WRITE_W) ||
1130 !(fuMode & (OF_SHARE_DENY_READ_W | OF_SHARE_DENY_NONE_W | OF_SHARE_EXCLUSIVE_W)))
1131 openMode |= OPEN_SHARE_DENYWRITE;
1132 else
1133 if (fuMode & OF_SHARE_DENY_NONE_W)
1134 openMode |= OPEN_SHARE_DENYNONE;
1135 else
1136 if (fuMode & OF_SHARE_DENY_READ_W)
1137 openMode |= OPEN_SHARE_DENYREAD;
1138 else
1139 if (fuMode & OF_SHARE_EXCLUSIVE_W)
1140 openMode |= OPEN_SHARE_DENYREADWRITE;
1141
1142 rc = OdinDosOpenL((PSZ)lpszFile,
1143 &hFile,
1144 &actionTaken,
1145 fileSize,
1146 fileAttr,
1147 openFlag,
1148 openMode,
1149 NULL);
1150
1151 if(rc != NO_ERROR)
1152 {
1153 if(fuMode & OF_EXIST_W)
1154 {
1155 if(rc == ERROR_OPEN_FAILED || rc == ERROR_FILE_NOT_FOUND)
1156 {
1157 SetLastError(ERROR_FILE_NOT_FOUND_W);
1158 return HFILE_ERROR_W;
1159 }
1160 }
1161 if((rc == ERROR_OPEN_FAILED) && (openFlag & OPEN_ACTION_OPEN_IF_EXISTS))
1162 {
1163 SetLastError(ERROR_FILE_NOT_FOUND_W);
1164 }
1165 else SetLastError(error2WinError(rc));
1166
1167 return HFILE_ERROR_W;
1168 }
1169 SetLastError(ERROR_SUCCESS_W);
1170 return hFile;
1171}
1172//******************************************************************************
1173//******************************************************************************
1174BOOL OSLibDosLockFile(DWORD hFile, DWORD dwFlags,
1175 DWORD OffsetLow, DWORD OffsetHigh,
1176 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
1177 LPOVERLAPPED lpOverlapped)
1178{
1179 APIRET rc;
1180
1181 // Set 5 secs timeout for locking file and no other can access this
1182 // file region
1183
1184 if(lpOverlapped) {//TODO:
1185 dprintf(("OSLibDosLockFile: overlapped lock not yet implemented!!"));
1186 }
1187 //TODO: Locking region crossing end of file is permitted. Works in OS/2??
1188 if(f64BitIO)
1189 {
1190 FILELOCKL lockRangeL;
1191
1192 lockRangeL.lOffset.ulLo = OffsetLow;
1193 lockRangeL.lOffset.ulHi = OffsetHigh;
1194 lockRangeL.lRange.ulLo = nNumberOfBytesToLockLow;
1195 lockRangeL.lRange.ulHi = nNumberOfBytesToLockHigh;
1196
1197 rc = OdinDosSetFileLocksL(hFile, NULL, &lockRangeL,
1198 (dwFlags & LOCKFILE_FAIL_IMMEDIATELY_W) ? 0 : 5000, 0);
1199 //SvL: 64 bits values are only supported by JFS
1200 // Try the 32 bits DosSetFileLocks if it fails
1201 // (TODO: should check the partition type instead)
1202 if(rc == ERROR_INVALID_PARAMETER && (OffsetHigh || nNumberOfBytesToLockHigh)) {
1203 goto oldlock;
1204 }
1205 }
1206 else
1207 {
1208oldlock:
1209 FILELOCK lockRange = { OffsetLow, nNumberOfBytesToLockLow };
1210
1211 rc = DosSetFileLocks(hFile, NULL, &lockRange,
1212 (dwFlags & LOCKFILE_FAIL_IMMEDIATELY_W) ? 0 : 5000, 0);
1213 }
1214 if(rc) {
1215 SetLastError(error2WinError(rc));
1216 return FALSE;
1217 }
1218 SetLastError(ERROR_SUCCESS_W);
1219 return TRUE;
1220}
1221//******************************************************************************
1222//******************************************************************************
1223BOOL OSLibDosUnlockFile(DWORD hFile, DWORD OffsetLow, DWORD OffsetHigh,
1224 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
1225 LPOVERLAPPED lpOverlapped)
1226{
1227 APIRET rc;
1228
1229 // Set 5 secs timeout for unlocking file and no other can access this
1230 // file region
1231
1232 if(lpOverlapped) {//TODO:
1233 dprintf(("OSLibDosUnlockFile: overlapped unlock not yet implemented!!"));
1234 }
1235 if(f64BitIO)
1236 {
1237 FILELOCKL unlockRangeL;
1238
1239 unlockRangeL.lOffset.ulLo = OffsetLow;
1240 unlockRangeL.lOffset.ulHi = OffsetHigh;
1241 unlockRangeL.lRange.ulLo = nNumberOfBytesToLockLow;
1242 unlockRangeL.lRange.ulHi = nNumberOfBytesToLockHigh;
1243
1244 rc = OdinDosSetFileLocksL(hFile, &unlockRangeL, NULL, 5000, 0);
1245 //SvL: 64 bits values are only supported by JFS
1246 // Try the 32 bits DosSetFileLocks if it fails
1247 // (TODO: should check the partition type instead)
1248 if(rc == ERROR_INVALID_PARAMETER && (OffsetHigh || nNumberOfBytesToLockHigh)) {
1249 goto oldlock;
1250 }
1251 }
1252 else
1253 {
1254oldlock:
1255 FILELOCK unlockRange = { OffsetLow, nNumberOfBytesToLockLow };
1256
1257 rc = DosSetFileLocks(hFile, &unlockRange, NULL, 5000, 0);
1258 }
1259 if(rc) {
1260 SetLastError(error2WinError(rc));
1261 return FALSE;
1262 }
1263 SetLastError(ERROR_SUCCESS_W);
1264 return TRUE;
1265}
1266//******************************************************************************
1267//******************************************************************************
1268BOOL OSLibDosFlushFileBuffers(DWORD hFile)
1269{
1270 APIRET rc;
1271
1272 rc = DosResetBuffer(hFile);
1273 SetLastError(error2WinError(rc));
1274 return (rc == NO_ERROR);
1275}
1276//******************************************************************************
1277//******************************************************************************
1278DWORD OSLibDosGetFileSize(DWORD hFile, LPDWORD lpdwFileSizeHigh)
1279{
1280 APIRET rc;
1281 ULONG sizeLow;
1282
1283 if(f64BitIO)
1284 {
1285 FILESTATUS3L fsts3ConfigInfoL = {{0}};
1286 ULONG ulBufSize = sizeof(FILESTATUS3L);
1287
1288 rc = DosQueryFileInfo(hFile, FIL_STANDARDL, &fsts3ConfigInfoL, ulBufSize);
1289 if(lpdwFileSizeHigh) {
1290 *lpdwFileSizeHigh = fsts3ConfigInfoL.cbFile.ulHi;
1291 }
1292 sizeLow = fsts3ConfigInfoL.cbFile.ulLo;
1293 }
1294 else
1295 {
1296 FILESTATUS3 fsts3ConfigInfo = {{0}};
1297 ULONG ulBufSize = sizeof(FILESTATUS3);
1298
1299 if(lpdwFileSizeHigh) {
1300 *lpdwFileSizeHigh = 0;
1301 }
1302 rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
1303 sizeLow = fsts3ConfigInfo.cbFile;
1304 }
1305 if(rc) {
1306 SetLastError(error2WinError(rc));
1307 return -1;
1308 }
1309 SetLastError(ERROR_SUCCESS_W);
1310 return sizeLow;
1311}
1312//******************************************************************************
1313//******************************************************************************
1314DWORD OSLibDosSetFilePointer(DWORD hFile, DWORD OffsetLow, DWORD *OffsetHigh, DWORD method)
1315{
1316 LONGLONG offsetL;
1317 LONGLONG newoffsetL;
1318 APIRET rc;
1319 DWORD newoffset;
1320
1321 switch(method)
1322 {
1323 case FILE_BEGIN_W:
1324 method = FILE_BEGIN;
1325 break;
1326
1327 case FILE_CURRENT_W:
1328 method = FILE_CURRENT;
1329 break;
1330
1331 case FILE_END_W:
1332 method = FILE_END;
1333 break;
1334 }
1335
1336 // PH Note: for a negative 32-bit seek, the OS/2 64-bit version
1337 // needs to be skipped.
1338#if 0 /* doesnt works at all with flash 10 */
1339 if( (f64BitIO) && (OffsetHigh) && ((DWORD)OffsetHigh != 0xAAAAAAAA) &&
1340 (*OffsetHigh != 0xAAAAAAAA) &&
1341 (*OffsetHigh != 0)) //workaround for flash10 video
1342 {
1343 offsetL.ulLo = OffsetLow;
1344 offsetL.ulHi = (OffsetHigh) ? *OffsetHigh : 0;
1345 rc = OdinDosSetFilePtrL(hFile, offsetL, method, &newoffsetL);
1346 if(OffsetHigh) {
1347 *OffsetHigh = newoffsetL.ulHi;
1348 }
1349 newoffset = newoffsetL.ulLo;
1350 }
1351 else
1352#endif
1353 rc = DosSetFilePtr(hFile, OffsetLow, method, &newoffset);
1354
1355 dprintf(("OSLibDosSetFilePointer. method: %08x wanted: %08x moved to %08x",
1356 method, OffsetLow, newoffset));
1357 if(rc)
1358 {
1359 SetLastError(error2WinError(rc));
1360 return -1;
1361 }
1362 SetLastError(ERROR_SUCCESS_W);
1363 return newoffset;
1364}
1365//******************************************************************************
1366//******************************************************************************
1367BOOL OSLibDosSetEndOfFile(DWORD hFile)
1368{
1369 ULONG newFilePos;
1370 LONGLONG FilePosL = {0,0};
1371 LONGLONG newFilePosL;
1372 APIRET rc;
1373
1374 if(f64BitIO) {
1375 rc = OdinDosSetFilePtrL(hFile, FilePosL, FILE_CURRENT, &newFilePosL);
1376 if(rc == 0) {
1377 rc = OdinDosSetFileSizeL(hFile, newFilePosL);
1378 }
1379 }
1380 else {
1381 rc = DosSetFilePtr(hFile, 0, FILE_CURRENT, &newFilePos);
1382 if(rc == 0) {
1383 rc = DosSetFileSize(hFile, newFilePos);
1384 }
1385 }
1386 if(rc) {
1387 SetLastError(error2WinError(rc));
1388 return FALSE;
1389 }
1390 SetLastError(ERROR_SUCCESS_W);
1391 return TRUE;
1392}
1393//******************************************************************************
1394//******************************************************************************
1395BOOL OSLibDosGetFileInformationByHandle(DWORD hFile, BY_HANDLE_FILE_INFORMATION* pInfo)
1396{
1397 APIRET rc;
1398
1399 if(f64BitIO)
1400 {
1401 FILESTATUS4L statusL = { 0 };
1402
1403 rc = DosQueryFileInfo(hFile, FIL_QUERYEASIZEL,
1404 &statusL, sizeof(statusL));
1405 if(rc == NO_ERROR)
1406 {
1407 pInfo->dwFileAttributes = 0;
1408 if(!(statusL.attrFile & NOT_NORMAL))
1409 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_NORMAL_W;
1410 if(statusL.attrFile & FILE_READONLY)
1411 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_READONLY_W;
1412 if(statusL.attrFile & FILE_HIDDEN)
1413 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN_W;
1414 if(statusL.attrFile & FILE_SYSTEM)
1415 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM_W;
1416 if(statusL.attrFile & FILE_DIRECTORY)
1417 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY_W;
1418 if(statusL.attrFile & FILE_ARCHIVED)
1419 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE_W;
1420
1421 pmDateTimeToFileTime(&statusL.fdateCreation,
1422 &statusL.ftimeCreation,
1423 &pInfo->ftCreationTime);
1424 pmDateTimeToFileTime(&statusL.fdateLastAccess,
1425 &statusL.ftimeLastAccess,
1426 &pInfo->ftLastAccessTime);
1427 pmDateTimeToFileTime(&statusL.fdateLastWrite,
1428 &statusL.ftimeLastWrite,
1429 &pInfo->ftLastWriteTime);
1430
1431 pInfo->nFileSizeHigh = statusL.cbFile.ulHi;
1432 pInfo->nFileSizeLow = statusL.cbFile.ulLo;
1433 pInfo->dwVolumeSerialNumber = 0; //todo
1434 pInfo->nNumberOfLinks = 1;
1435 pInfo->nFileIndexHigh = 0;
1436 pInfo->nFileIndexLow = 0;
1437 }
1438 }
1439 else
1440 {
1441 FILESTATUS4 status = { 0 };
1442
1443 rc = DosQueryFileInfo(hFile, FIL_QUERYEASIZE, &status,
1444 sizeof(status));
1445 if(rc == NO_ERROR)
1446 {
1447 pInfo->dwFileAttributes = 0;
1448 if(!(status.attrFile & NOT_NORMAL))
1449 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_NORMAL_W;
1450 if(status.attrFile & FILE_READONLY)
1451 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_READONLY_W;
1452 if(status.attrFile & FILE_HIDDEN)
1453 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN_W;
1454 if(status.attrFile & FILE_SYSTEM)
1455 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM_W;
1456 if(status.attrFile & FILE_DIRECTORY)
1457 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY_W;
1458 if(status.attrFile & FILE_ARCHIVED)
1459 pInfo->dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE_W;
1460
1461 pmDateTimeToFileTime(&status.fdateCreation,
1462 &status.ftimeCreation,
1463 &pInfo->ftCreationTime);
1464 pmDateTimeToFileTime(&status.fdateLastAccess,
1465 &status.ftimeLastAccess,
1466 &pInfo->ftLastAccessTime);
1467 pmDateTimeToFileTime(&status.fdateLastWrite,
1468 &status.ftimeLastWrite,
1469 &pInfo->ftLastWriteTime);
1470
1471 pInfo->nFileSizeHigh = 0;
1472 pInfo->nFileSizeLow = status.cbFile;
1473 pInfo->dwVolumeSerialNumber = 0; //todo
1474 pInfo->nNumberOfLinks = 1;
1475 pInfo->nFileIndexHigh = 0;
1476 pInfo->nFileIndexLow = 0;
1477 }
1478 }
1479 if(rc) {
1480 SetLastError(error2WinError(rc));
1481 return FALSE;
1482 }
1483 SetLastError(ERROR_SUCCESS_W);
1484 return TRUE;
1485}
1486//******************************************************************************
1487//******************************************************************************
1488BOOL OSLibDosSetFileTime(DWORD hFile, LPFILETIME pFT1,
1489 LPFILETIME pFT2, LPFILETIME pFT3)
1490{
1491 FILESTATUS3 fileInfo;
1492 APIRET rc;
1493
1494 rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fileInfo, sizeof(fileInfo));
1495
1496 if (rc == NO_ERROR)
1497 {
1498 if (pFT1) pmFileTimeToDateTime(pFT1, &fileInfo.fdateCreation, &fileInfo.ftimeCreation);
1499 if (pFT2) pmFileTimeToDateTime(pFT2, &fileInfo.fdateLastAccess,&fileInfo.ftimeLastAccess);
1500 if (pFT3) pmFileTimeToDateTime(pFT3, &fileInfo.fdateLastWrite, &fileInfo.ftimeLastWrite);
1501
1502 rc = DosSetFileInfo(hFile, FIL_STANDARD, &fileInfo, sizeof(fileInfo));
1503 }
1504
1505 if(rc)
1506 {
1507 SetLastError(error2WinError(rc));
1508 return FALSE;
1509 }
1510 SetLastError(ERROR_SUCCESS_W);
1511 return TRUE;
1512}
1513//******************************************************************************
1514//******************************************************************************
1515BOOL OSLibDosGetFileTime(DWORD hFile, LPFILETIME pFT1,
1516 LPFILETIME pFT2, LPFILETIME pFT3)
1517{
1518 FILESTATUS3 fileInfo;
1519 APIRET rc;
1520
1521 rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fileInfo, sizeof(fileInfo));
1522
1523 if(rc == NO_ERROR)
1524 {
1525 if (pFT1) pmDateTimeToFileTime(&fileInfo.fdateCreation, &fileInfo.ftimeCreation, pFT1);
1526 if (pFT2) pmDateTimeToFileTime(&fileInfo.fdateLastAccess,&fileInfo.ftimeLastAccess,pFT2);
1527 if (pFT3) pmDateTimeToFileTime(&fileInfo.fdateLastWrite, &fileInfo.ftimeLastWrite, pFT3);
1528 }
1529 if(rc)
1530 {
1531 SetLastError(error2WinError(rc));
1532 return FALSE;
1533 }
1534 SetLastError(ERROR_SUCCESS_W);
1535 return TRUE;
1536}
1537//******************************************************************************
1538//******************************************************************************
1539DWORD OSLibDosSetFilePtr2(DWORD hFile, DWORD offset, DWORD method)
1540{
1541 DWORD newoffset;
1542 APIRET rc;
1543
1544
1545 rc = DosSetFilePtr(hFile, offset, method, &newoffset);
1546 if(rc) {
1547 dprintf(("DosSetFilePtr Error rc:%d", rc));
1548 return -1;
1549 }
1550 else return newoffset;
1551}
1552//******************************************************************************
1553//******************************************************************************
1554DWORD OSLibDosDupHandle(DWORD hFile, DWORD *hNew)
1555{
1556 DWORD dwNewHandle = -1, ret;
1557
1558 //Use the stack for storing the new handle; DosDupHandle doesn't like high
1559 //addresses
1560 ret = DosDupHandle(hFile, &dwNewHandle);
1561 *hNew = dwNewHandle;
1562 return ret;
1563}
1564//******************************************************************************
1565//******************************************************************************
1566DWORD OSLibDosSetFHState(DWORD hFile, DWORD dwFlags)
1567{
1568 DWORD ulMode;
1569 APIRET rc;
1570
1571 rc = DosQueryFHState(hFile, &ulMode);
1572 if(rc != NO_ERROR) return error2WinError(rc);
1573
1574 //turn off non-participating bits
1575 ulMode &= 0x7F88;
1576
1577 if(dwFlags & HANDLE_FLAG_INHERIT_W) {
1578 ulMode &= ~OPEN_FLAGS_NOINHERIT;
1579 }
1580 else
1581 ulMode |= OPEN_FLAGS_NOINHERIT;
1582
1583 rc = DosSetFHState(hFile, ulMode);
1584 return error2WinError(rc);
1585}
1586//******************************************************************************
1587//Returns time spent in kernel & user mode in milliseconds
1588//******************************************************************************
1589BOOL OSLibDosQueryProcTimes(DWORD procid, ULONG *kerneltime, ULONG *usertime)
1590{
1591 APIRET rc;
1592 char *buf;
1593 ULONG size;
1594 ULONG nrthreads = 4;
1595
1596tryagain:
1597 size = sizeof(QTOPLEVEL)+sizeof(QGLOBAL)+sizeof(QPROCESS) + nrthreads*sizeof(QTHREAD);
1598 buf = (char *)malloc(size);
1599 rc = DosQuerySysState(0x1, RESERVED, procid, RESERVED, (PCHAR)buf, size);
1600
1601 if(rc) {
1602 free(buf);
1603 if(rc == ERROR_BUFFER_OVERFLOW) {
1604 nrthreads += 4;
1605 goto tryagain;
1606 }
1607 return FALSE;
1608 }
1609 PQTOPLEVEL top = (PQTOPLEVEL)buf;
1610
1611 *kerneltime = 0;
1612 *usertime = 0;
1613 for(int i=0;i<top->procdata->threadcnt;i++) {
1614 *kerneltime += top->procdata->threads[i].systime;
1615 *usertime += top->procdata->threads[i].usertime;
1616 }
1617 free(buf);
1618 return TRUE;
1619}
1620//******************************************************************************
1621//******************************************************************************
1622// TODO: implement SecurityAttributes parameter
1623DWORD OSLibDosCreateNamedPipe(LPCTSTR lpName,
1624 DWORD dwOpenMode,
1625 DWORD dwPipeMode,
1626 DWORD nMaxInstances,
1627 DWORD nOutBufferSize,
1628 DWORD nInBufferSize,
1629 DWORD nDefaultTimeOut,
1630 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1631{ DWORD dwOS2Mode = NP_NOINHERIT; //default is not inherited by child processes
1632 DWORD dwOS2PipeMode = 0;
1633 LPSTR lpOS2Name;
1634 DWORD hPipe;
1635 DWORD rc, ulAction;
1636
1637 if ((dwOpenMode & PIPE_ACCESS_DUPLEX_W) == PIPE_ACCESS_DUPLEX_W)
1638 dwOS2Mode |= NP_ACCESS_DUPLEX;
1639 else
1640 if (dwOpenMode & PIPE_ACCESS_INBOUND_W)
1641 dwOS2Mode |= NP_ACCESS_INBOUND;
1642 else
1643 if (dwOpenMode & PIPE_ACCESS_OUTBOUND_W)
1644 dwOS2Mode |= NP_ACCESS_OUTBOUND;
1645 // TODO:
1646 // if(dwOpenMode & FILE_FLAG_OVERLAPPED)
1647 // if(dwOpenMode & WRITE_DAC)
1648 // if(dwOpenMode & WRITE_OWNER)
1649 // if(dwOpenMode & ACCESS_SYSTEM_SECURITY)
1650 if(dwOpenMode & FILE_FLAG_WRITE_THROUGH_W)
1651 dwOS2Mode |= NP_WRITEBEHIND; // FIXME: I'm not sure!
1652
1653 if (dwPipeMode & PIPE_WAIT_W)
1654 dwOS2PipeMode |= NP_WAIT;
1655 if (dwPipeMode & PIPE_NOWAIT_W)
1656 dwOS2PipeMode |= NP_NOWAIT;
1657 if (dwPipeMode & PIPE_READMODE_BYTE_W)
1658 dwOS2PipeMode |= NP_READMODE_BYTE;
1659 if (dwPipeMode & PIPE_READMODE_MESSAGE_W)
1660 dwOS2PipeMode |= NP_READMODE_MESSAGE;
1661 if (dwPipeMode & PIPE_TYPE_BYTE_W)
1662 dwOS2PipeMode |= NP_TYPE_BYTE;
1663 if (dwPipeMode & PIPE_TYPE_MESSAGE_W)
1664 dwOS2PipeMode |= NP_TYPE_MESSAGE;
1665
1666 if (nMaxInstances>0xff)
1667 {
1668 SetLastError(ERROR_INVALID_PARAMETER_W); // ERROR_INVALID_PARAMETER
1669 return -1; // INVALID_HANDLE_VALUE
1670 }
1671 dwOS2PipeMode |= nMaxInstances;
1672
1673 if (strstr(lpName,"\\\\."))
1674 {
1675 // If pipe is created on the local machine
1676 // we must delete string \\. because
1677 // in Windows named pipes scheme is a \\.\PIPE\pipename
1678 // but in OS/2 only \PIPE\pipename
1679 lpOS2Name = (LPSTR)lpName + 3;
1680 }
1681 else lpOS2Name = (LPSTR)lpName;
1682
1683 dprintf(("DosCreateNPipe(%s,%x,%x,%x,%x,%x)",lpOS2Name,dwOS2Mode,dwOS2PipeMode,nInBufferSize,nOutBufferSize,nDefaultTimeOut));
1684
1685 //if the windows app tries to open another instance of an existing pipe, then
1686 //we must use DosOpen here. So first try DosOpen, if that fails then we can
1687 //create the named pipe
1688 rc = DosOpen(lpOS2Name, &hPipe, &ulAction, 0, FILE_NORMAL, FILE_OPEN,
1689 ((dwOpenMode & PIPE_ACCESS_INBOUND_W) ? OPEN_ACCESS_READWRITE : OPEN_ACCESS_READONLY) |
1690 OPEN_SHARE_DENYNONE | OPEN_FLAGS_NOINHERIT, NULL);
1691
1692 if(rc == NO_ERROR) {
1693#if 0
1694 //TODO:
1695 if(dwOpenMode & FILE_FLAG_FIRST_PIPE_INSTANCE_W) {
1696 DosClose(hPipe);
1697 SetLastError(ERROR_ALREADY_EXISTS_W);
1698 return -1;
1699 }
1700 else {
1701#endif
1702 dprintf(("Opening of existing named pipe succeeded"));
1703 SetLastError(ERROR_SUCCESS_W);
1704 return hPipe;
1705// }
1706 }
1707
1708 rc=DosCreateNPipe(lpOS2Name,
1709 &hPipe,
1710 dwOS2Mode,
1711 dwOS2PipeMode,
1712 nInBufferSize,
1713 nInBufferSize,
1714 nDefaultTimeOut); // Timeouts must be tested!
1715
1716 dprintf(("DosCreateNPipe rc=%d",rc));
1717 if (rc)
1718 {
1719 SetLastError(error2WinError(rc,ERROR_INVALID_PARAMETER_W));
1720 return -1; // INVALID_HANDLE_VALUE
1721 }
1722 SetLastError(ERROR_SUCCESS_W);
1723 return hPipe;
1724}
1725//******************************************************************************
1726//******************************************************************************
1727BOOL OSLibSetNamedPipeState(DWORD hNamedPipe, DWORD dwPipeMode)
1728{
1729 ULONG dwOS2PipeMode = 0;
1730 APIRET rc;
1731
1732 if (dwPipeMode & PIPE_WAIT_W)
1733 dwOS2PipeMode |= NP_WAIT;
1734 if (dwPipeMode & PIPE_NOWAIT_W)
1735 dwOS2PipeMode |= NP_NOWAIT;
1736 if (dwPipeMode & PIPE_READMODE_BYTE_W)
1737 dwOS2PipeMode |= NP_READMODE_BYTE;
1738 if (dwPipeMode & PIPE_READMODE_MESSAGE_W)
1739 dwOS2PipeMode |= NP_READMODE_MESSAGE;
1740
1741 rc = DosSetNPHState(hNamedPipe, dwOS2PipeMode);
1742 if(rc) {
1743 SetLastError(error2WinError(rc, ERROR_INVALID_PARAMETER_W));
1744 return FALSE;
1745 }
1746 SetLastError(ERROR_SUCCESS_W);
1747 return TRUE;
1748}
1749//******************************************************************************
1750//******************************************************************************
1751DWORD OSLibDosOpenPipe(LPCTSTR lpName,
1752 DWORD fuAccess,
1753 DWORD fuShare,
1754 LPSECURITY_ATTRIBUTES lpSecurityAttributes,
1755 DWORD fuCreate,
1756 DWORD fuAttrFlags)
1757{
1758 LPSTR lpOS2Name;
1759 ULONG hPipe;
1760 ULONG rc, ulAction;
1761 ULONG openFlag = 0;
1762 ULONG openMode = OPEN_FLAGS_NOINHERIT; //default is not inherited by child processes
1763
1764
1765 switch(fuCreate)
1766 {
1767 case CREATE_NEW_W:
1768 openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS;
1769 break;
1770 case CREATE_ALWAYS_W:
1771 /* kso 2000-11-26: Not sure if OPEN_ACTION_REPLACE_IF_EXISTS is correct here! It is correct according to
1772 * MSDN, but not according to "The Win32 API SuperBible". Anyway I haven't got time to check it out in
1773 * NT now.
1774 * The problem is that OPEN_ACTION_REPLACE_IF_EXISTS requires write access. It failes with
1775 * rc = ERROR_ACCESS_DENIED (5). Quick fix, use OPEN_IF_EXIST if readonly access.
1776 */
1777 if (fuAccess & GENERIC_WRITE_W)
1778 openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS;
1779 else
1780 openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
1781 break;
1782 case OPEN_EXISTING_W:
1783 openFlag |= OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
1784 break;
1785 case OPEN_ALWAYS_W:
1786 openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
1787 break;
1788 case TRUNCATE_EXISTING_W:
1789 openFlag |= OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS;
1790 break;
1791 }
1792
1793 if(fuAttrFlags & FILE_FLAG_WRITE_THROUGH_W) openMode |= OPEN_FLAGS_WRITE_THROUGH;
1794 if(fuAttrFlags & FILE_FLAG_NO_BUFFERING_W) openMode |= OPEN_FLAGS_NO_CACHE;
1795 if(fuAttrFlags & FILE_FLAG_RANDOM_ACCESS_W) openMode |= OPEN_FLAGS_RANDOM;
1796 if(fuAttrFlags & FILE_FLAG_SEQUENTIAL_SCAN_W) openMode |= OPEN_FLAGS_SEQUENTIAL;
1797 // TODO: FILE_FLAG_BACKUP_SEMANTICS_W
1798 // FILE_FLAG_POSIX_SEMANTICS_W are not supported
1799
1800 //TODO: FILE_SHARE_DELETE
1801 if((fuShare & (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W)) == 0 )
1802 openMode |= OPEN_SHARE_DENYREADWRITE;
1803 else
1804 if((fuShare & (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W)) == (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W))
1805 openMode |= OPEN_SHARE_DENYNONE;
1806 else
1807 if(fuShare & FILE_SHARE_READ_W)
1808 openMode |= OPEN_SHARE_DENYWRITE;
1809 else
1810 if(fuShare & FILE_SHARE_WRITE_W)
1811 openMode |= OPEN_SHARE_DENYREAD;
1812
1813 if(fuAccess == (GENERIC_READ_W | GENERIC_WRITE_W))
1814 openMode |= OPEN_ACCESS_READWRITE;
1815 else
1816 if(fuAccess & GENERIC_READ_W)
1817 openMode |= OPEN_ACCESS_READONLY;
1818 else
1819 if(fuAccess & GENERIC_WRITE_W)
1820 openMode |= OPEN_ACCESS_WRITEONLY;
1821
1822 if (strstr(lpName,"\\\\."))
1823 {
1824 // If pipe is created on the local machine
1825 // we must delete string \\. because
1826 // in Windows named pipes scheme is a \\.\PIPE\pipename
1827 // but in OS/2 only \PIPE\pipename
1828 lpOS2Name = (LPSTR)lpName + 3;
1829 }
1830 else lpOS2Name = (LPSTR)lpName;
1831
1832 rc = DosOpen(lpOS2Name, &hPipe, &ulAction, 0, 0,
1833 openFlag, openMode, NULL);
1834
1835 if(rc == NO_ERROR) {
1836 dprintf(("Opening of existing named pipe succeeded"));
1837 SetLastError(ERROR_SUCCESS_W);
1838 return hPipe;
1839 }
1840
1841 SetLastError(error2WinError(rc,ERROR_INVALID_PARAMETER_W));
1842 return -1; // INVALID_HANDLE_VALUE
1843}
1844
1845//******************************************************************************
1846//******************************************************************************
1847// TODO: implement lpOverlapped parameter!
1848BOOL OSLibDosConnectNamedPipe(DWORD hNamedPipe, LPOVERLAPPED lpOverlapped)
1849{
1850 DWORD rc;
1851
1852 rc=DosConnectNPipe(hNamedPipe);
1853 dprintf(("DosConnectNPipe rc=%d",rc));
1854
1855 if(rc == NO_ERROR) {
1856 SetLastError(ERROR_SUCCESS_W);
1857 return (TRUE);
1858 }
1859 SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1860 return (FALSE);
1861}
1862
1863//******************************************************************************
1864//******************************************************************************
1865BOOL OSLibDosCallNamedPipe( LPCTSTR lpNamedPipeName,
1866 LPVOID lpInBuffer,
1867 DWORD nInBufferSize,
1868 LPVOID lpOutBuffer,
1869 DWORD nOutBufferSize,
1870 LPDWORD lpBytesRead,
1871 DWORD nTimeOut )
1872{
1873 LPSTR lpOS2Name;
1874 DWORD rc;
1875
1876 if (strstr(lpNamedPipeName,"\\\\."))
1877 {
1878 // If pipe is created on the local machine
1879 // we must delete string \\. because
1880 // in Windows named pipes scheme is a \\.\PIPE\pipename
1881 // but in OS/2 only \PIPE\pipename
1882 lpOS2Name = (LPSTR)lpNamedPipeName + 3;
1883 }
1884 else lpOS2Name = (LPSTR)lpNamedPipeName;
1885
1886 rc=DosCallNPipe(lpOS2Name,
1887 lpInBuffer,
1888 nInBufferSize,
1889 lpOutBuffer,
1890 nOutBufferSize,
1891 lpBytesRead,
1892 nTimeOut );
1893
1894
1895 if(rc == NO_ERROR) {
1896 SetLastError(ERROR_SUCCESS_W);
1897 return (TRUE);
1898 }
1899 SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1900 return (FALSE);
1901}
1902
1903//******************************************************************************
1904//******************************************************************************
1905BOOL OSLibDosTransactNamedPipe( DWORD hNamedPipe,
1906 LPVOID lpInBuffer,
1907 DWORD nInBufferSize,
1908 LPVOID lpOutBuffer,
1909 DWORD nOutBufferSize,
1910 LPDWORD lpBytesRead,
1911 LPOVERLAPPED lpOverlapped)
1912{
1913 DWORD rc;
1914
1915 rc=DosTransactNPipe(hNamedPipe,
1916 lpOutBuffer,
1917 nOutBufferSize,
1918 lpInBuffer,
1919 nInBufferSize,
1920 lpBytesRead);
1921
1922 dprintf(("DosTransactNPipe returned rc=%d");)
1923 if(rc == NO_ERROR) {
1924 SetLastError(ERROR_SUCCESS_W);
1925 return (TRUE);
1926 }
1927 SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1928 return (FALSE);
1929}
1930
1931//******************************************************************************
1932//******************************************************************************
1933BOOL OSLibDosPeekNamedPipe(DWORD hPipe,
1934 LPVOID lpvBuffer,
1935 DWORD cbBuffer,
1936 LPDWORD lpcbRead,
1937 LPDWORD lpcbAvail,
1938 LPDWORD lpcbMessage)
1939{
1940 DWORD rc;
1941 AVAILDATA availData ={0};
1942 ULONG ulState, ulRead, ulMessage;
1943 char buffer;
1944
1945 if(lpcbRead == NULL) {
1946 lpcbRead = &ulRead;
1947 }
1948 if(lpcbMessage == NULL) {
1949 lpcbMessage = &ulMessage;
1950 }
1951 if(lpvBuffer == NULL) {
1952 lpvBuffer = &buffer;
1953 cbBuffer = 0;
1954 }
1955
1956 rc = DosPeekNPipe(hPipe,lpvBuffer,cbBuffer,lpcbRead,&availData,&ulState);
1957
1958 dprintf(("DosPeekNPipe returned rc=%d",rc));
1959
1960 //OS/2 doesn't support DosPeekNPipe for unnamed pipes; win32 does
1961 if (rc == 1) {
1962 dprintf(("WARNING: Pretend broken pipe for PeekNamedPipe with unnamed pipe handle"));
1963 SetLastError(ERROR_BROKEN_PIPE_W);
1964 return FALSE;
1965 }
1966 if (rc == NO_ERROR)
1967 {
1968 if(lpcbAvail) {
1969 *lpcbAvail = availData.cbpipe;
1970 }
1971 if(lpcbMessage) {
1972 *lpcbMessage = availData.cbmessage;
1973 }
1974 SetLastError(ERROR_SUCCESS_W);
1975 return (TRUE);
1976 }
1977 SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1978 return (FALSE);
1979}
1980//******************************************************************************
1981//******************************************************************************
1982BOOL OSLibDosDisconnectNamedPipe(DWORD hPipe)
1983{
1984 DWORD rc;
1985
1986 rc=DosDisConnectNPipe(hPipe);
1987
1988 dprintf(("DosDisConnectNPipe returned rc=%d",rc));
1989
1990 if(rc == NO_ERROR) {
1991 SetLastError(ERROR_SUCCESS_W);
1992 return (TRUE);
1993 }
1994 SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1995 return (FALSE);
1996}
1997//******************************************************************************
1998//******************************************************************************
1999BOOL OSLibDosWaitNamedPipe(LPCSTR lpszNamedPipeName,
2000 DWORD dwTimeout)
2001{
2002 LPSTR lpOS2Name;
2003 DWORD rc;
2004
2005 if (strstr(lpszNamedPipeName,"\\\\."))
2006 {
2007 // If pipe is created on the local machine
2008 // we must delete string \\. because
2009 // in Windows named pipes scheme is a \\.\PIPE\pipename
2010 // but in OS/2 only \PIPE\pipename
2011 lpOS2Name = (LPSTR)lpszNamedPipeName + 3;
2012 }
2013 else lpOS2Name = (LPSTR)lpszNamedPipeName;
2014
2015 rc=DosWaitNPipe(lpOS2Name,dwTimeout);
2016
2017 dprintf(("DosWaitNPipe returned rc=%d",rc));
2018
2019 if(rc == NO_ERROR) {
2020 SetLastError(ERROR_SUCCESS_W);
2021 return (TRUE);
2022 }
2023 SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
2024
2025 return (FALSE);
2026}
2027//******************************************************************************
2028//******************************************************************************
2029BOOL isRoot(CHAR* name)
2030{
2031 if (name[1] == ':')
2032 {
2033 //local name (x:\)
2034 return (name[2] == 0) || !strchr(&name[3],'\\');
2035 } else if (name[0] == '\\')
2036 {
2037 //UNC name (\\resource\drive\)
2038 CHAR *drive,*dir;
2039
2040 drive = strchr(&name[2],'\\');
2041 if (!drive) return FALSE;
2042 dir = strchr(&drive[1],'\\');
2043 if (!dir) return TRUE;
2044 return !strchr(&dir[1],'\\');
2045 } else return FALSE; //unknown
2046}
2047//******************************************************************************
2048//******************************************************************************
2049inline CHAR system2DOSCharacter(CHAR ch)
2050{
2051 switch(ch)
2052 {
2053 case ' ':
2054 case '.':
2055 case '~':
2056 return '_';
2057
2058 default:
2059 return toupper(ch);
2060 }
2061}
2062
2063// TODO: not finished nor correct!!!!
2064VOID long2ShortName(CHAR* longName, CHAR* shortName)
2065{
2066 // check for uplink / root: "." and ".."
2067 if (longName[0] == '.')
2068 {
2069 // if ((strcmp(longName,".") == 0) || (strcmp(longName,"..") == 0))
2070 if (longName[1] == 0) // "."
2071 {
2072 shortName[0] = '.';
2073 shortName[1] = 0;
2074 return;
2075 }
2076
2077 if (longName[1] == '.' && longName[2] == 0) // ".."
2078 {
2079 shortName[0] = '.';
2080 shortName[1] = '.';
2081 shortName[2] = 0;
2082 return;
2083 }
2084 }
2085 else
2086 // check for empty name
2087 if(longName[0] == 0)
2088 {
2089 shortName[0] = 0;
2090 return;
2091 }
2092
2093 INT x;
2094 CHAR *source = longName;
2095
2096 // Test if longName is 8:3 compliant and simply copy
2097 // the filename.
2098 BOOL flag83 = TRUE;
2099
2100 // verify forbidden characters
2101 for (x = 0;
2102 (x < 8) &&
2103 (flag83 == TRUE);
2104 x++)
2105 {
2106 switch (*source)
2107 {
2108 case '.': // a period will cause the loop to abort!
2109 x=1000;
2110 break;
2111
2112 case '/': case '?':
2113 case '*': case ':':
2114 case '\\': case '"':
2115 case ' ':
2116 flag83 = FALSE;
2117 break;
2118 default:
2119 source++;
2120 break;
2121 }
2122 }
2123
2124 // verify we're on a period now
2125 if (flag83 == TRUE)
2126 if (*source != '.')
2127 flag83 = FALSE;
2128 else source++;
2129
2130 // verify extension
2131 if (flag83 == TRUE)
2132 for (INT y = 0;
2133 (y < 3) && (flag83 == TRUE);
2134 y++)
2135 {
2136 switch (*source)
2137 {
2138 case '/': case '?':
2139 case '*': case ':':
2140 case '\\': case '"':
2141 case ' ': case '.':
2142 flag83 = FALSE;
2143 break;
2144 }
2145 source++;
2146 }
2147
2148 // verify we're at the end of the string now
2149 if (flag83 == TRUE)
2150 if (*source != 0)
2151 flag83 = FALSE;
2152
2153 // OK, done
2154 if (flag83 == TRUE)
2155 {
2156 // we might not alter any character here, since
2157 // an app opening a specific file with an 8:3 "alias",
2158 // would surely fail.
2159 strcpy(shortName, longName);
2160
2161 return; // Done
2162 }
2163
2164
2165 // @@@PH
2166 shortName[0] = 0; // this function is disabled anyway ...
2167 return;
2168
2169 CHAR *dest = shortName;
2170 CHAR *ext = strrchr(longName,'.');
2171
2172 //CB: quick and dirty, real FILE~12.EXT is too slow
2173 //PH: We'd have to count the number of non-8:3-compliant files
2174 // within a directory. Or simpler: the number of files within
2175 // the current directory.
2176
2177 //8 character file name
2178 for (x = 0;x < 8;x++)
2179 {
2180 if ((source == ext) || (source[0] == 0)) break;
2181 dest[0] = system2DOSCharacter(source[0]);
2182 source++;
2183 dest++;
2184 }
2185
2186 if (source[0] == 0)
2187 {
2188 dest[0] = 0;
2189 return;
2190 }
2191
2192 if (source != ext)
2193 {
2194 //longName > 8 characters, insert ~1
2195 shortName[6] = '~';
2196 shortName[7] = '1';
2197 }
2198
2199 if (ext)
2200 {
2201 //add extension, 3 characters
2202 dest[0] = ext[0];
2203 dest++;
2204 ext++;
2205 for (x = 0;x < 3;x++)
2206 {
2207 if (ext[0] == 0) break;
2208 dest[0] = system2DOSCharacter(ext[0]);
2209 ext++;
2210 dest++;
2211 }
2212 }
2213 dest[0] = 0;
2214}
2215//******************************************************************************
2216//******************************************************************************
2217VOID translateFileResults(FILESTATUS3 *pResult,LPWIN32_FIND_DATAA pFind,CHAR* achName)
2218{
2219 CHAR* name;
2220
2221 pFind->dwReserved0 = pFind->dwReserved1 = 0;
2222 pFind->dwFileAttributes = pm2WinFileAttributes(pResult->attrFile);
2223
2224 pmDateTimeToFileTime(&pResult->fdateCreation,&pResult->ftimeCreation,&pFind->ftCreationTime);
2225 pmDateTimeToFileTime(&pResult->fdateLastAccess,&pResult->ftimeLastAccess,&pFind->ftLastAccessTime);
2226 pmDateTimeToFileTime(&pResult->fdateLastWrite,&pResult->ftimeLastWrite,&pFind->ftLastWriteTime);
2227
2228 pFind->nFileSizeHigh = 0; //CB: fixme
2229 pFind->nFileSizeLow = pResult->cbFile;
2230 name = strrchr(achName,'\\');
2231 if (name)
2232 {
2233 name++;
2234// strcpy(pFind->cFileName,name);
2235 OemToCharA( name, pFind->cFileName );
2236 }
2237 else
2238 pFind->cFileName[0] = 0;
2239
2240 long2ShortName(pFind->cFileName,pFind->cAlternateFileName);
2241}
2242
2243
2244VOID translateFindResults(FILEFINDBUF3 *pResult,LPWIN32_FIND_DATAA pFind)
2245{
2246 pFind->dwFileAttributes = pm2WinFileAttributes(pResult->attrFile);
2247 pFind->dwReserved0 = pFind->dwReserved1 = 0;
2248
2249 pmDateTimeToFileTime(&pResult->fdateCreation,&pResult->ftimeCreation,&pFind->ftCreationTime);
2250 pmDateTimeToFileTime(&pResult->fdateLastAccess,&pResult->ftimeLastAccess,&pFind->ftLastAccessTime);
2251 pmDateTimeToFileTime(&pResult->fdateLastWrite,&pResult->ftimeLastWrite,&pFind->ftLastWriteTime);
2252
2253 pFind->nFileSizeHigh = 0; //CB: fixme
2254 pFind->nFileSizeLow = pResult->cbFile;
2255// strcpy(pFind->cFileName,pResult->achName);
2256 OemToCharA( pResult->achName, pFind->cFileName );
2257 long2ShortName(pFind->cFileName,pFind->cAlternateFileName);
2258}
2259//******************************************************************************
2260//******************************************************************************
2261DWORD OSLibDosFindFirst(LPCSTR lpFileName,WIN32_FIND_DATAA* lpFindFileData)
2262{
2263 HDIR hDir = -1;
2264 ULONG attrs;
2265 FILEFINDBUF3 result;
2266 ULONG searchCount = 1;
2267
2268 attrs = FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY | FILE_ARCHIVED;
2269 result.achName[0] = 0;
2270
2271 ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS_W);
2272 char lOemFileName[260];
2273
2274 CharToOemA(ODINHelperStripUNC((char*)lpFileName), lOemFileName);
2275
2276 APIRET rc = DosFindFirst((PSZ)lOemFileName,&hDir,attrs,&result,sizeof(result),&searchCount,FIL_STANDARD);
2277
2278 //check root: skip "." and ".." (HPFS, not on FAT)
2279 //check in OSLibDosFindNext not necessary: "." and ".." are the first two entries
2280 if ((rc == 0) && isRoot((LPSTR)ODINHelperStripUNC((char*)lpFileName)))
2281 {
2282 while ((strcmp(result.achName,".") == 0) ||
2283 (strcmp(result.achName,"..") == 0))
2284 {
2285 result.achName[0] = 0;
2286 searchCount = 1;
2287 APIRET rc = DosFindNext(hDir,&result,sizeof(result),&searchCount);
2288 if (rc)
2289 {
2290 DosFindClose(hDir);
2291 SetLastError(error2WinError(rc));
2292
2293 SetErrorMode(oldmode);
2294 return INVALID_HANDLE_VALUE_W;
2295 }
2296 }
2297 }
2298
2299 // enable i/o kernel exceptions again
2300 SetErrorMode(oldmode);
2301
2302 if(rc)
2303 {
2304 DosFindClose(hDir);
2305
2306 //Windows returns ERROR_FILE_NOT_FOUND if the file/directory is not present
2307 if(rc == ERROR_NO_MORE_FILES || rc == ERROR_PATH_NOT_FOUND) {
2308 SetLastError(ERROR_FILE_NOT_FOUND_W);
2309 }
2310 else SetLastError(error2WinError(rc));
2311 return INVALID_HANDLE_VALUE_W;
2312 }
2313 translateFindResults(&result,lpFindFileData);
2314 SetLastError(ERROR_SUCCESS_W);
2315 return hDir;
2316}
2317//******************************************************************************
2318// NOTE: returns "." and ".." in root
2319//******************************************************************************
2320DWORD OSLibDosFindFirstMulti(LPCSTR lpFileName,WIN32_FIND_DATAA *lpFindFileData,DWORD *count)
2321{
2322 HDIR hDir = -1;
2323 ULONG attrs;
2324 FILEFINDBUF3 *result,*data;
2325 ULONG searchCount = *count;
2326
2327 attrs = FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY | FILE_ARCHIVED;
2328 result = (FILEFINDBUF3*)malloc(searchCount*sizeof(FILEFINDBUF3));
2329
2330 ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS_W);
2331 char lOemFileName[260];
2332
2333 CharToOemA(ODINHelperStripUNC((char*)lpFileName), lOemFileName);
2334 APIRET rc = DosFindFirst((PSZ)lOemFileName,&hDir,attrs,result,searchCount*sizeof(FILEFINDBUF3),&searchCount,FIL_STANDARD);
2335 SetErrorMode(oldmode);
2336 if (rc)
2337 {
2338 free(result);
2339 *count = 0;
2340 SetLastError(error2WinError(rc));
2341
2342 return INVALID_HANDLE_VALUE_W;
2343 }
2344
2345 data = result;
2346 for (int x = 0;x < searchCount;x++)
2347 {
2348 translateFindResults(data,&lpFindFileData[x]);
2349 data = (FILEFINDBUF3*)(((DWORD)data)+data->oNextEntryOffset);
2350 }
2351 free(result);
2352 *count = searchCount;
2353
2354 SetLastError(ERROR_SUCCESS_W);
2355 return hDir;
2356}
2357//******************************************************************************
2358//******************************************************************************
2359BOOL OSLibDosFindNext(DWORD hFindFile,WIN32_FIND_DATAA *lpFindFileData)
2360{
2361 FILEFINDBUF3 result;
2362 ULONG searchCount = 1;
2363
2364 APIRET rc = DosFindNext((HDIR)hFindFile,&result,sizeof(result),&searchCount);
2365 if (rc)
2366 {
2367 SetLastError(error2WinError(rc));
2368
2369 return FALSE;
2370 }
2371
2372 translateFindResults(&result,lpFindFileData);
2373 SetLastError(ERROR_SUCCESS_W);
2374 return TRUE;
2375}
2376//******************************************************************************
2377//******************************************************************************
2378BOOL OSLibDosFindNextMulti(DWORD hFindFile,WIN32_FIND_DATAA *lpFindFileData,DWORD *count)
2379{
2380 FILEFINDBUF3 *result,*data;
2381 ULONG searchCount = *count;
2382
2383 result = (FILEFINDBUF3*)malloc(searchCount*sizeof(FILEFINDBUF3));
2384 APIRET rc = DosFindNext((HDIR)hFindFile,result,searchCount*sizeof(FILEFINDBUF3),&searchCount);
2385 if (rc)
2386 {
2387 free(result);
2388 *count = 0;
2389 SetLastError(error2WinError(rc));
2390
2391 return FALSE;
2392 }
2393
2394 data = result;
2395 for (int x = 0;x < searchCount;x++)
2396 {
2397 translateFindResults(data,&lpFindFileData[x]);
2398 data = (FILEFINDBUF3*)(((DWORD)data)+data->oNextEntryOffset);
2399 }
2400 free(result);
2401 *count = searchCount;
2402
2403 SetLastError(ERROR_SUCCESS_W);
2404 return TRUE;
2405}
2406//******************************************************************************
2407//******************************************************************************
2408BOOL OSLibDosFindClose(DWORD hFindFile)
2409{
2410 APIRET rc = DosFindClose((HDIR)hFindFile);
2411 if (rc)
2412 {
2413 SetLastError(error2WinError(rc));
2414 return FALSE;
2415 }
2416
2417 SetLastError(ERROR_SUCCESS_W);
2418 return TRUE;
2419}
2420//******************************************************************************
2421//******************************************************************************
2422DWORD OSLibGetFileAttributes(LPSTR lpFileName)
2423{
2424 FILESTATUS3 statusBuf;
2425 char lOemFileName[CCHMAXPATH];
2426 char *lpszBackslash, *lpszColon;
2427 APIRET rc;
2428
2429//testestest
2430 if(strlen(lpFileName) > CCHMAXPATH) DebugInt3();
2431//testestset
2432
2433 //Convert file name from Windows to OS/2 codepage
2434 CharToOemA(ODINHelperStripUNC(lpFileName), lOemFileName);
2435 lpszBackslash = CharPrevA(lOemFileName, lOemFileName + strlen(lOemFileName));
2436 if(lpszBackslash)
2437 {
2438 if(*lpszBackslash == '\\')
2439 {
2440 lpszColon = CharPrevA(lOemFileName, lpszBackslash);
2441 if(lpszColon && *lpszColon != ':')
2442 {//only rootdir is allowed to have terminating backslash
2443 *lpszBackslash = 0;
2444 }
2445 }
2446 else
2447 if(*lpszBackslash == ':')
2448 {//root dir must end with backslash
2449 strcat(lOemFileName, "\\");
2450 }
2451 }
2452
2453 rc = DosQueryPathInfo(lOemFileName, FIL_STANDARD, &statusBuf, sizeof(statusBuf));
2454 if(rc == ERROR_TOO_MANY_OPEN_FILES)
2455 {
2456 LONG reqCount = 2;
2457 ULONG maxFiles;
2458
2459 if(DosSetRelMaxFH(&reqCount, &maxFiles) == NO_ERROR)
2460 rc = DosQueryPathInfo(lOemFileName, FIL_STANDARD, &statusBuf, sizeof(statusBuf));
2461 }
2462
2463 if(rc == NO_ERROR)
2464 {
2465 DWORD status = 0;
2466 if(!(statusBuf.attrFile & NOT_NORMAL))
2467 status |= FILE_ATTRIBUTE_NORMAL_W;
2468 if(statusBuf.attrFile & FILE_READONLY)
2469 status |= FILE_ATTRIBUTE_READONLY_W;
2470 if(statusBuf.attrFile & FILE_HIDDEN)
2471 status |= FILE_ATTRIBUTE_HIDDEN_W;
2472 if(statusBuf.attrFile & FILE_SYSTEM)
2473 status |= FILE_ATTRIBUTE_SYSTEM_W;
2474 if(statusBuf.attrFile & FILE_DIRECTORY)
2475 status |= FILE_ATTRIBUTE_DIRECTORY_W;
2476 if(statusBuf.attrFile & FILE_ARCHIVED)
2477 status |= FILE_ATTRIBUTE_ARCHIVE_W;
2478
2479 SetLastError(ERROR_SUCCESS_W);
2480 return status;
2481 }
2482 SetLastError(error2WinError(rc));
2483 return -1;
2484}
2485//******************************************************************************
2486#define FSATTACH_SIZE 256
2487//******************************************************************************
2488DWORD OSLibDosQueryVolumeFS(int drive, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize)
2489{
2490 PFSQBUFFER2 fsinfo = (PFSQBUFFER2) alloca(FSATTACH_SIZE);
2491 ULONG cb = FSATTACH_SIZE;
2492 char drv[3] = "A:";
2493 char *fsname;
2494 APIRET rc;
2495
2496 if(lpFileSystemNameBuffer == NULL) {
2497 DebugInt3();
2498 return ERROR_INVALID_PARAMETER_W;
2499 }
2500 drv[0] = (char)('A' + drive - 1);
2501
2502 ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS_W);
2503 rc = DosQueryFSAttach(drv, 1, FSAIL_QUERYNAME, fsinfo, &cb);
2504 SetErrorMode(oldmode);
2505
2506 switch(rc) {
2507 case ERROR_INVALID_DRIVE:
2508 return ERROR_INVALID_DRIVE_W;
2509 case ERROR_NO_VOLUME_LABEL:
2510 return ERROR_NO_VOLUME_LABEL_W;
2511 case NO_ERROR:
2512 break;
2513 default:
2514 return ERROR_NOT_ENOUGH_MEMORY; //whatever
2515 }
2516
2517 fsname = (char *)&fsinfo->szName[0] + fsinfo->cbName + 1;
2518
2519 /* @@@PH 2000/08/10 CMD.EXE querys with nFileSystemNameSize == 0
2520 * however does NOT expect to receive an error.
2521 */
2522 strncpy(lpFileSystemNameBuffer,
2523 fsname,
2524 nFileSystemNameSize);
2525 /*
2526 if(strlen(fsname) < nFileSystemNameSize) {
2527 strcpy(lpFileSystemNameBuffer, fsname);
2528 }
2529 else return ERROR_BUFFER_OVERFLOW_W;
2530 */
2531 return ERROR_SUCCESS_W;
2532}
2533//******************************************************************************
2534typedef struct _FSINFOBUF
2535{
2536 ULONG ulVolser; /* Volume serial number */
2537 VOLUMELABEL vol; /* Volume lable */
2538} FSINFOBUF;
2539//******************************************************************************
2540DWORD OSLibDosQueryVolumeSerialAndName(int drive, LPDWORD lpVolumeSerialNumber,
2541 LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize)
2542{
2543 FSINFOBUF fsi;
2544 APIRET rc;
2545
2546 ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS_W);
2547 rc = DosQueryFSInfo(drive, FSIL_VOLSER, &fsi, sizeof(fsi));
2548 SetErrorMode(oldmode);
2549
2550 switch(rc) {
2551 case ERROR_INVALID_DRIVE:
2552 return ERROR_INVALID_DRIVE_W;
2553 case ERROR_NO_VOLUME_LABEL:
2554 return ERROR_NO_VOLUME_LABEL_W;
2555 case NO_ERROR:
2556 break;
2557 default:
2558 return ERROR_NOT_ENOUGH_MEMORY; //whatever
2559 }
2560
2561 if(lpVolumeSerialNumber) {
2562 *lpVolumeSerialNumber = fsi.ulVolser;
2563 }
2564 if(lpVolumeNameBuffer)
2565 {
2566 if(nVolumeNameSize > fsi.vol.cch) {
2567 strcpy(lpVolumeNameBuffer, (PCHAR)fsi.vol.szVolLabel);
2568 }
2569 else return ERROR_BUFFER_OVERFLOW_W;
2570 }
2571
2572 return ERROR_SUCCESS_W;
2573}
2574//******************************************************************************
2575//******************************************************************************
2576BOOL OSLibGetDiskFreeSpace(LPSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
2577 LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters,
2578 LPDWORD lpTotalNumberOfClusters)
2579{
2580 ULONG diskNum;
2581 FSALLOCATE fsAlloc;
2582 APIRET rc;
2583
2584 if(lpRootPathName == 0)
2585 diskNum = 0;
2586 else
2587 if('A' <= *lpRootPathName && *lpRootPathName <= 'Z' )
2588 diskNum = *lpRootPathName - 'A' + 1;
2589 else
2590 if('a' <= *lpRootPathName && *lpRootPathName <= 'z' )
2591 diskNum = *lpRootPathName - 'a' + 1;
2592 else
2593 diskNum = 0;
2594
2595 ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS_W);
2596 rc = DosQueryFSInfo(diskNum, FSIL_ALLOC, &fsAlloc, sizeof(fsAlloc));
2597 SetErrorMode(oldmode);
2598
2599 if(rc == 0)
2600 {
2601 *lpSectorsPerCluster = fsAlloc.cSectorUnit;
2602 *lpBytesPerSector = fsAlloc.cbSector;
2603 *lpNumberOfFreeClusters = fsAlloc.cUnitAvail;
2604 *lpTotalNumberOfClusters = fsAlloc.cUnit;
2605 SetLastError(ERROR_SUCCESS_W);
2606 return TRUE;
2607 }
2608 SetLastError(error2WinError(rc));
2609 return FALSE;
2610}
2611//******************************************************************************
2612//******************************************************************************
2613BOOL OSLibDosGetDiskGeometry(HANDLE hDisk, DWORD cDisk, PVOID pdiskgeom)
2614{
2615 PDISK_GEOMETRY pGeom = (PDISK_GEOMETRY)pdiskgeom;
2616 BYTE param[2] = {0, 0};
2617 ULONG parsize = 2;
2618 BIOSPARAMETERBLOCK bpb;
2619 ULONG datasize = sizeof(bpb);
2620 APIRET rc;
2621
2622 dprintf(("OSLibDosGetDiskGeometry %x %d %x", hDisk, cDisk, pdiskgeom));
2623 param[1] = cDisk - 'A';
2624 rc = DosDevIOCtl((hDisk) ? hDisk : -1, IOCTL_DISK, DSK_GETDEVICEPARAMS, param, 2, &parsize, &bpb, sizeof(bpb), &datasize);
2625 if(rc == 0)
2626 {
2627 pGeom->SectorsPerTrack = bpb.usSectorsPerTrack;
2628 pGeom->BytesPerSector = bpb.usBytesPerSector;
2629 pGeom->TracksPerCylinder = 80; //TODO:!!!!!
2630 pGeom->Cylinders.u.LowPart = bpb.cCylinders;
2631 pGeom->Cylinders.u.HighPart = 0;
2632 switch(bpb.bDeviceType) {
2633 case DEVTYPE_48TPI:
2634 pGeom->MediaType = F5_360_512; //?????
2635 break;
2636 case DEVTYPE_96TPI:
2637 pGeom->MediaType = F5_1Pt2_512; //?????
2638 break;
2639 case DEVTYPE_35:
2640 pGeom->MediaType = F3_720_512;
2641 break;
2642 case DEVTYPE_8SD:
2643 case DEVTYPE_8DD:
2644 pGeom->MediaType = RemovableMedia;
2645 break;
2646 case DEVTYPE_FIXED:
2647 pGeom->MediaType = FixedMedia;
2648 break;
2649 case DEVTYPE_TAPE:
2650 pGeom->MediaType = RemovableMedia;
2651 break;
2652 case DEVTYPE_UNKNOWN: //others, include 1.44 3.5 inch disk drive
2653 pGeom->MediaType = F3_1Pt44_512;
2654 break;
2655 case 8: //RW optical disk
2656 pGeom->MediaType = RemovableMedia;
2657 break;
2658 case 9: //2.88 3.5 inch disk
2659 pGeom->MediaType = F3_2Pt88_512;
2660 break;
2661 }
2662 SetLastError(ERROR_SUCCESS_W);
2663 return TRUE;
2664 }
2665 dprintf(("OSLibDosGetDiskGeometry: error %d -> %d", rc, error2WinError(rc)));
2666 SetLastError(error2WinError(rc));
2667 return FALSE;
2668}
2669//******************************************************************************
2670
2671#define CDType 0x8000
2672#define FloppyType 0x4000
2673#define LanType 0x2000
2674#define LogicalType 0x1000
2675#define VDISKType 0x0800
2676#define OpticalType 0x0400
2677#define NonRemovable 0x01
2678
2679#define FirstDrive 0
2680#define B_Drive_0_Based 1
2681#define Base_1_offset 1
2682#define Binary_to_Printable 0x41
2683#define LastDrive 26
2684#define OpticalSectorsPerCluster 4
2685
2686#define DisketteCylinders 80
2687
2688
2689
2690/**
2691 * Determin the type of a specific drive or the current drive.
2692 *
2693 * @returns DRIVE_UNKNOWN
2694 * DRIVE_NO_ROOT_DIR
2695 * DRIVE_CANNOTDETERMINE
2696 * DRIVE_DOESNOTEXIST
2697 * DRIVE_REMOVABLE
2698 * DRIVE_FIXED
2699 * DRIVE_REMOTE
2700 * DRIVE_CDROM
2701 * DRIVE_RAMDISK
2702 *
2703 * @param ulDrive Index of the drive which type we query.
2704 *
2705 * @status completely implemented and tested
2706 * @author Vitali Pelenyov <sunlover@anduin.net>
2707 * @author bird
2708 */
2709ULONG OSLibGetDriveType(ULONG ulDrive)
2710{
2711 ULONG cbParm;
2712 ULONG cbData;
2713 ULONG ulDriveNum = 0;
2714 ULONG ulDriveMap = 0;
2715 APIRET rc;
2716 ULONG ulDriveType;
2717
2718
2719 /*
2720 * Check if drive is present in the logical drive mask,
2721 */
2722 if ( DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap)
2723 || !(ulDriveMap & (1 << ulDrive))
2724 )
2725 return DRIVE_DOESNOTEXIST_W;
2726
2727
2728 /*
2729 * Optimize floppy queries for A: and B:.
2730 * (These aren't currently a subject of change.)
2731 */
2732 static ULONG ulFloppyMask = 0;
2733 if (ulFloppyMask & (1 << ulDrive))
2734 return DRIVE_REMOVABLE_W;
2735
2736 /*
2737 * Optimize for CDROM requests.
2738 * (These aren't currently a subject of change.)
2739 */
2740 static ULONG ulCDROMMask = 0;
2741 if (ulCDROMMask & (1 << ulDrive))
2742 return DRIVE_CDROM_W;
2743
2744 /*
2745 * Check for CD drives
2746 * We don't have to this everytime. I mean, the os2cdrom.dmd is
2747 * exactly very dynamic when it comes to this info.
2748 */
2749 if (cdDrvLtr.drive_count == 0xffff)
2750 {
2751 HFILE hCDRom2;
2752 ULONG ulAction = 0;
2753
2754 if (DosOpen("\\DEV\\CD-ROM2$", &hCDRom2, &ulAction, 0,
2755 FILE_NORMAL, OPEN_ACTION_OPEN_IF_EXISTS,
2756 OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY | OPEN_FLAGS_NOINHERIT, NULL)
2757 == NO_ERROR)
2758 {
2759 cbData = sizeof(cdDrvLtr);
2760 rc = DosDevIOCtl(hCDRom2,
2761 IOC_CDROM_2,
2762 IOCD_RETURN_DRIVE_LETTER,
2763 NULL, 0, NULL,
2764 (PVOID)&cdDrvLtr, sizeof(cdDrvLtr), &cbData);
2765 DosClose(hCDRom2);
2766 }
2767 else
2768 cdDrvLtr.drive_count = 0;
2769 }
2770
2771
2772 /*
2773 * Is the drive present?? Lets the the BPB to check this.
2774 * this should be a pretty speedy call if I'm not much mistaken.
2775 */
2776 BIOSPARAMETERBLOCK bpb = {0};
2777 DSKREQ DskReq;
2778 DskReq.Infotype = 0;
2779 DskReq.DriveUnit = (UCHAR)ulDrive;
2780 cbParm = sizeof(DskReq);
2781 cbData = sizeof(bpb);
2782 if (DosDevIOCtl(-1, IOCTL_DISK, DSK_GETDEVICEPARAMS,
2783 (PVOID)&DskReq, sizeof(DskReq), &cbParm,
2784 (PVOID)&bpb, sizeof(BIOSPARAMETERBLOCK), &cbData)
2785 == NO_ERROR)
2786 {
2787 if (bpb.bDeviceType == 0 && bpb.fsDeviceAttr == 0)
2788 bpb.fsDeviceAttr = LanType; // fix for LAN type drives
2789 }
2790 else
2791 bpb.fsDeviceAttr = LanType; //could be a LAN drive - could it??
2792
2793
2794 /*
2795 * This is a CDROM/DVD drive
2796 *
2797 * Fix: When the cdrom is not last drive letter that
2798 * sometimes reports wrong index, have to check
2799 * that device type can be a CDROM one.
2800 */
2801 if ( cdDrvLtr.drive_count > 0
2802 && (bpb.bDeviceType == DEVTYPE_UNKNOWN || bpb.bDeviceType == DEVTYPE_OPTICAL) // Other or RW optical
2803 && ulDrive >= cdDrvLtr.first_drive_number
2804 && ulDrive < cdDrvLtr.first_drive_number + cdDrvLtr.drive_count
2805 )
2806 bpb.fsDeviceAttr |= CDType;
2807
2808
2809 if (bpb.bDeviceType || bpb.fsDeviceAttr == LanType)
2810 {
2811 if ((bpb.fsDeviceAttr & (CDType | NonRemovable)) == 0)
2812 { // if the device is removable and NOT a CD
2813 CHAR szDevName[4] = "A:";
2814 PFSQBUFFER2 pfsqbuf2;
2815
2816 szDevName[0] += ulDrive;
2817 cbData = sizeof(PFSQBUFFER2) + 3 * CCHMAXPATH;
2818 pfsqbuf2 = (PFSQBUFFER2)malloc(cbData);
2819 DosError(FERR_DISABLEEXCEPTION | FERR_DISABLEHARDERR); // disable error popups
2820 rc = DosQueryFSAttach(&szDevName[0], 0L, FSAIL_QUERYNAME, pfsqbuf2, &cbData);
2821 if (rc == NO_ERROR)
2822 {
2823 if (pfsqbuf2->iType == FSAT_REMOTEDRV)
2824 bpb.fsDeviceAttr |= LanType;
2825 else if (pfsqbuf2->iType == FSAT_LOCALDRV)
2826 {
2827 PSZ pszFSName = (PSZ)pfsqbuf2->szName + pfsqbuf2->cbName + 1;
2828 if (!strcmp(pszFSName, "FAT"))
2829 {
2830 // device is a removable FAT drive, so it MUST be diskette
2831 // as Optical has another name as does LAN and SRVIFS
2832 if (bpb.bSectorsPerCluster != OpticalSectorsPerCluster)
2833 bpb.fsDeviceAttr |= FloppyType;
2834 else
2835 bpb.fsDeviceAttr |= OpticalType;
2836 }
2837 /*
2838 * CDROM detection fix
2839 */
2840 else
2841 {
2842 // device is removable non-FAT, maybe it is CD?
2843 if ( bpb.bDeviceType == DEVTYPE_UNKNOWN
2844 && bpb.bMedia == 5
2845 && bpb.usBytesPerSector > 512
2846 )
2847 bpb.fsDeviceAttr |= CDType;
2848 }
2849 // CDROM detection fix
2850 }
2851 }
2852 else // must be no media or audio only (for CDs at least)
2853 {
2854 if (bpb.cCylinders <= DisketteCylinders) // floppies will always be 80
2855 {
2856 // or less cylinders
2857 if (bpb.bSectorsPerCluster != OpticalSectorsPerCluster)
2858 bpb.fsDeviceAttr |= FloppyType;
2859 else
2860 bpb.fsDeviceAttr |= OpticalType;
2861 }
2862 }
2863
2864 //Enable error popups again
2865 DosError(FERR_ENABLEEXCEPTION | FERR_ENABLEHARDERR);
2866
2867 free(pfsqbuf2);
2868 }
2869 else
2870 {// non removable or CD type. maybe RAM disk
2871 if (!(bpb.fsDeviceAttr & CDType)) // if NOT CD
2872 {
2873 if (bpb.cFATs == 1) // is there only one FAT?
2874 bpb.fsDeviceAttr |= VDISKType; // -> RAM disk
2875 }
2876 }
2877 }
2878
2879
2880 /*
2881 * Determin return value.
2882 */
2883 if (bpb.fsDeviceAttr & FloppyType)
2884 {
2885 ulDriveType = DRIVE_REMOVABLE_W;
2886 /* update floppy cache if A or B */
2887 if (ulDrive <= 1)
2888 ulFloppyMask |= 1 << ulDrive;
2889 }
2890 else if (bpb.fsDeviceAttr & CDType)
2891 {
2892 ulDriveType = DRIVE_CDROM_W;
2893 /* update cdrom cache */
2894 ulCDROMMask |= 1 << ulDrive;
2895 }
2896 else if (bpb.fsDeviceAttr & LanType)
2897 ulDriveType = DRIVE_REMOTE_W;
2898 else if (bpb.fsDeviceAttr & VDISKType)
2899 ulDriveType = DRIVE_RAMDISK_W;
2900 else if (bpb.fsDeviceAttr & OpticalType || bpb.bDeviceType == DEVTYPE_OPTICAL)
2901 ulDriveType = DRIVE_FIXED_W;
2902 else if (bpb.bDeviceType == DEVTYPE_FIXED)
2903 ulDriveType = DRIVE_FIXED_W;
2904 else
2905 ulDriveType = DRIVE_UNKNOWN_W;
2906
2907 return ulDriveType;
2908}
2909//******************************************************************************
2910//Returns bit map where with the mapping of the logical drives
2911//******************************************************************************
2912ULONG OSLibGetLogicalDrives()
2913{
2914 ULONG ulDriveNum = 0; /* Drive number (A=1, B=2, C=3, ...) */
2915 ULONG ulDriveMap = 0; /* Mapping of valid drives */
2916 APIRET rc;
2917
2918 rc = DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap);
2919 if(rc) {
2920 DebugInt3();
2921 SetLastError(error2WinError(rc));
2922 return 0;
2923 }
2924 return ulDriveMap;
2925}
2926//******************************************************************************
2927//******************************************************************************
2928ULONG OSLibDosQueryCurrentDisk()
2929
2930{
2931 ULONG ulDriveNum = 0; /* Drive number (A=1, B=2, C=3, ...) */
2932 ULONG ulDriveMap = 0; /* Mapping of valid drives */
2933 APIRET rc;
2934
2935 rc = DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap);
2936 if(rc) {
2937 DebugInt3();
2938 SetLastError(error2WinError(rc));
2939 return 0;
2940 }
2941 return ulDriveNum;
2942}
2943//******************************************************************************
2944//******************************************************************************
2945BOOL OSLibDosCreatePipe(PHANDLE phfRead,
2946 PHANDLE phfWrite,
2947 LPSECURITY_ATTRIBUTES lpsa,
2948 DWORD dwSize)
2949{
2950 APIRET rc;
2951
2952 dprintf(("DosCreatePipe(%08xh,%08xh,%08xh)\n",
2953 phfRead,
2954 phfWrite,
2955 dwSize));
2956
2957 // select default buffer size
2958 if (dwSize == 0)
2959 dwSize = 4096;
2960
2961 rc = DosCreatePipe(phfRead,
2962 phfWrite,
2963 dwSize);
2964 dprintf(("DosCreatePipe rc=%d",rc));
2965 if (rc)
2966 {
2967 SetLastError(error2WinError(rc,ERROR_INVALID_PARAMETER_W));
2968 return -1; // INVALID_HANDLE_VALUE
2969 }
2970 SetLastError(ERROR_SUCCESS_W);
2971 return NO_ERROR;
2972}
2973//******************************************************************************
2974//******************************************************************************
2975DWORD SYSTEM OSLibDosDevIOCtl( DWORD hFile, DWORD dwCat, DWORD dwFunc,
2976 PVOID pParm, DWORD dwParmMaxLen, DWORD *pdwParmLen,
2977 PVOID pData, DWORD dwDataMaxLen, DWORD *pdwDataLen)
2978{
2979 APIRET rc;
2980 PVOID pTiledParm = pParm;
2981 BOOL flagTiledParm = FALSE;
2982 PVOID pTiledData = pData;
2983 BOOL flagTiledData = FALSE;
2984
2985#if 1
2986 /*
2987 * Quick and Dirty Fix!
2988 * TO BE REMOVED!
2989 *
2990 * On some VPC installation without CDROM we seem to
2991 * use a concidrable amount of time during Win2k shutdown.
2992 * No idea why, but it has to do with CDROM we think.
2993 *
2994 * So, let's just fail all IOCtls to CD01 if there aren't any
2995 * CDROMs in the system.
2996 *
2997 */
2998
2999 /*
3000 * Check for CD drives
3001 * We don't have to this everytime. I mean, the os2cdrom.dmd is
3002 * exactly very dynamic when it comes to this info.
3003 */
3004 if (cdDrvLtr.drive_count == 0xffff)
3005 {
3006 HFILE hCDRom2;
3007 ULONG ulAction = 0;
3008
3009 if (DosOpen("\\DEV\\CD-ROM2$", &hCDRom2, &ulAction, 0,
3010 FILE_NORMAL, OPEN_ACTION_OPEN_IF_EXISTS,
3011 OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY | OPEN_FLAGS_NOINHERIT, NULL)
3012 == NO_ERROR)
3013 {
3014 ULONG cbData = sizeof(cdDrvLtr);
3015 rc = DosDevIOCtl(hCDRom2,
3016 IOC_CDROM_2,
3017 IOCD_RETURN_DRIVE_LETTER,
3018 NULL, 0, NULL,
3019 (PVOID)&cdDrvLtr, sizeof(cdDrvLtr), &cbData);
3020 DosClose(hCDRom2);
3021 }
3022 else
3023 cdDrvLtr.drive_count = 0;
3024 }
3025
3026 if ( cdDrvLtr.drive_count == 0
3027 && (dwCat == IOCTL_CDROMDISK
3028 || (dwCat == IOCTL_CDROMAUDIO
3029 && dwParmMaxLen >= 4 && strncmp((char*)pParm, "CD01", 4))
3030 )
3031 )
3032 {
3033 /* just return some error code */
3034 return ERROR_BAD_COMMAND;
3035 }
3036
3037#endif
3038
3039#define MEM_TILED_CEILING 0x1fffffff
3040
3041 // bounce buffer support
3042 // make sure no parameter or data buffer can pass the tiled memory region
3043 // barrier (usually 512MB). OS/2 kernel does not correctly translate these
3044 // addresses to a 16:16 address used in device driver land. In fact,
3045 // DosDevIOCtl is not a high memory enabled API!
3046
3047 if (pTiledParm && (((DWORD)pTiledParm + max(dwParmMaxLen, *pdwParmLen)) > MEM_TILED_CEILING))
3048 {
3049 rc = DosAllocMem(&pTiledParm, dwParmMaxLen, PAG_READ | PAG_WRITE);
3050 if (rc)
3051 goto _exit_ioctl;
3052
3053 flagTiledParm = TRUE;
3054 }
3055
3056 if (pTiledData && (((DWORD)pTiledData + max(dwDataMaxLen, *pdwDataLen)) > MEM_TILED_CEILING))
3057 {
3058 rc = DosAllocMem(&pTiledData, dwDataMaxLen, PAG_READ | PAG_WRITE);
3059 if (rc)
3060 goto _exit_ioctl;
3061
3062 flagTiledData = TRUE;
3063 }
3064
3065 // copy data from real buffers to
3066 // bounce buffers if necessary
3067 if (pTiledParm != pParm)
3068 memcpy(pTiledParm, pParm, *pdwParmLen);
3069
3070 if (pTiledData != pData)
3071 memcpy(pTiledData, pData, *pdwDataLen);
3072
3073
3074 rc = DosDevIOCtl( (HFILE)hFile, dwCat, dwFunc,
3075 pParm, dwParmMaxLen, pdwParmLen,
3076 pData, dwDataMaxLen, pdwDataLen);
3077
3078 // copy data from bounce buffers to real
3079 // target buffers if necessary
3080 if (pTiledParm != pParm)
3081 memcpy(pParm, pTiledParm, *pdwParmLen);
3082
3083 if (pTiledData != pData)
3084 memcpy(pData, pTiledData, *pdwDataLen);
3085
3086
3087 _exit_ioctl:
3088
3089 // deallocate bounce buffers
3090 if (flagTiledParm)
3091 DosFreeMem(pTiledParm);
3092
3093 if (flagTiledData)
3094 DosFreeMem(pTiledData);
3095
3096 rc = error2WinError(rc, ERROR_INVALID_HANDLE);
3097 SetLastError(rc);
3098 return (DWORD)rc;
3099}
3100
3101/**
3102 * Pure wrapper for DosQueryModulName which returns the OS/2 returncode.
3103 * @returns Returncode from DosQueryModuleName.
3104 * @param hModule Handle of the module which name we query.
3105 * @param cchName Length of the output name buffer.
3106 * @param pszname Pointer to the output name buffer.
3107 * @status Completely implemented.
3108 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
3109 */
3110ULONG OSLibDosQueryModuleName(ULONG hModule, int cchName, char *pszName)
3111{
3112 return DosQueryModuleName(hModule, cchName, pszName);
3113}
3114
3115
3116HINSTANCE OSLibDosLoadModule(LPSTR szModName)
3117{
3118 APIRET rc;
3119 HMODULE hModule = NULLHANDLE;
3120 char name[ CCHMAXPATH ];
3121
3122 rc = DosLoadModule(name, CCHMAXPATH, szModName, &hModule);
3123 if(rc) {
3124 SetLastError(error2WinError(rc,ERROR_FILE_NOT_FOUND));
3125 return 0;
3126 }
3127 SetLastError(ERROR_SUCCESS_W);
3128 return hModule;
3129}
3130//******************************************************************************
3131//******************************************************************************
3132void OSLibDosFreeModule(HINSTANCE hinst)
3133{
3134 DosFreeModule(hinst);
3135}
3136//******************************************************************************
3137//******************************************************************************
3138ULONG OSLibDosQuerySysInfo(ULONG iStart, ULONG iLast, PVOID pBuf, ULONG cbBuf)
3139{
3140 APIRET rc;
3141
3142 rc = DosQuerySysInfo(iStart, iLast, pBuf, cbBuf);
3143 SetLastError(error2WinError(rc,ERROR_INVALID_HANDLE));
3144 return rc;
3145}
3146//******************************************************************************
3147//returned length is number of characters required or used for current dir
3148//*excluding* terminator
3149//******************************************************************************
3150ULONG OSLibDosQueryDir(DWORD length, LPSTR lpszCurDir)
3151{
3152 ULONG drivemap, currentdisk, len;
3153 char *lpszCurDriveAndDir = lpszCurDir +3;
3154 APIRET rc;
3155
3156 len = (length > 3) ? length - 3 : 0;
3157
3158 rc = DosQueryCurrentDir(0, lpszCurDriveAndDir, &len);
3159 if(rc != ERROR_BUFFER_OVERFLOW)
3160 {
3161 if(rc)
3162 {
3163 SetLastError(error2WinError(rc,ERROR_INVALID_PARAMETER));
3164 return 0;
3165 }
3166 len = strlen(lpszCurDriveAndDir) + 3;
3167
3168 // Dir returned by DosQueryCurDir doesn't include drive, so add it
3169 DosQueryCurrentDisk(&currentdisk, &drivemap);
3170
3171 if(isupper(lpszCurDir[3])) {
3172 lpszCurDir[0] = (char)('A' - 1 + currentdisk);
3173 }
3174 else lpszCurDir[0] = (char)('a' - 1 + currentdisk);
3175
3176 lpszCurDir[1] = ':';
3177 lpszCurDir[2] = '\\';
3178 }
3179 else len += 3; // + 3 since DosQueryCurDir doesn't include drive
3180
3181 SetLastError(ERROR_SUCCESS_W);
3182 return len;
3183}
3184//******************************************************************************
3185//******************************************************************************
3186BOOL OSLibDosBeep(DWORD ulFreq, DWORD ulDuration)
3187{
3188 APIRET rc;
3189
3190 if (ulDuration == -1)
3191 {
3192 SetLastError(ERROR_NOT_SUPPORTED_W);
3193 return FALSE;
3194 }
3195 rc = DosBeep(ulFreq, ulDuration);
3196 SetLastError(error2WinError(rc,ERROR_INVALID_HANDLE));
3197
3198 return (rc == 0);
3199}
3200//******************************************************************************
3201//******************************************************************************
3202ULONG OSLibDosGetModuleFileName(HMODULE hModule, LPTSTR lpszPath, DWORD cchPath)
3203{
3204 PTIB pTIB;
3205 PPIB pPIB;
3206 APIRET rc;
3207
3208 if(hModule == -1 || hModule == 0)
3209 {
3210 DosGetInfoBlocks(&pTIB, &pPIB);
3211 hModule = pPIB->pib_hmte;
3212 }
3213 *lpszPath = 0;
3214 rc = DosQueryModuleName(hModule, cchPath, lpszPath);
3215
3216 DWORD len = strlen(lpszPath);
3217 SetLastError(error2WinError(rc,ERROR_INVALID_HANDLE));
3218 return len;
3219}
3220//******************************************************************************
3221//******************************************************************************
3222ULONG OSLibDosGetProcAddress(HMODULE hModule, LPCSTR lpszProc)
3223{
3224 APIRET rc;
3225 PFN pfn = NULL;
3226 ULONG ordinal = (((ULONG)lpszProc) <= 0xFFFF) ? (ULONG)lpszProc : 0;
3227 HMODULE hmod = (HMODULE)hModule;
3228
3229 rc = DosQueryProcAddr( hmod, ordinal, (PSZ)lpszProc, &pfn );
3230 if(rc == ERROR_INVALID_HANDLE && pfn == NULL) {
3231 CHAR pszError[32], pszModule[CCHMAXPATH];
3232
3233 if(DosQueryModuleName( hmod, CCHMAXPATH, pszModule ) == 0 &&
3234 DosLoadModule( pszError, 32, pszModule, &hmod ) == 0)
3235 {
3236 rc = DosQueryProcAddr(hmod, ordinal, (PSZ)lpszProc, &pfn);
3237 }
3238 }
3239 SetLastError(error2WinError(rc,ERROR_INVALID_HANDLE));
3240
3241 return (ULONG)pfn;
3242}
3243//******************************************************************************
3244//******************************************************************************
3245BOOL OSLibDosSetThreadAffinity(DWORD dwThreadAffinityMask)
3246{
3247 static PROC_DosSetThreadAffinity pfnDosSetThreadAffinity = NULL;
3248 static BOOL fInit = FALSE;
3249 MPAFFINITY mask;
3250 APIRET rc;
3251
3252 if(fInit == FALSE && pfnDosSetThreadAffinity == NULL)
3253 {
3254 ULONG nrCPUs;
3255
3256 rc = DosQuerySysInfo(QSV_NUMPROCESSORS, QSV_NUMPROCESSORS, &nrCPUs, sizeof(nrCPUs));
3257 if (rc != 0 || nrCPUs == 1)
3258 {//not supported
3259 fInit = TRUE;
3260 SetLastError(ERROR_SUCCESS_W);
3261 return TRUE;
3262 }
3263
3264 HMODULE hDoscalls;
3265 if(DosQueryModuleHandleStrict("DOSCALLS", &hDoscalls) == NO_ERROR) {
3266 DosQueryProcAddr(hDoscalls, 564, NULL, (PFN *)&pfnDosSetThreadAffinity);
3267 }
3268 fInit = TRUE;
3269 }
3270 if(fInit && pfnDosSetThreadAffinity == NULL) {
3271 SetLastError(ERROR_SUCCESS_W);
3272 return TRUE;
3273 }
3274 USHORT sel = RestoreOS2FS();
3275
3276 mask.mask[0] = dwThreadAffinityMask;
3277 mask.mask[1] = 0; //TODO: this might not be a good idea, but then again, not many people have > 32 cpus
3278
3279 rc = pfnDosSetThreadAffinity(&mask);
3280 SetFS(sel);
3281
3282 SetLastError(error2WinError(rc,ERROR_INVALID_PARAMETER));
3283 return (rc == NO_ERROR);
3284}
3285//******************************************************************************
3286//******************************************************************************
3287BOOL OSLibDosQueryAffinity(DWORD fMaskType, DWORD *pdwThreadAffinityMask)
3288{
3289 static PROC_DosQueryThreadAffinity pfnDosQueryThreadAffinity = NULL;
3290 static BOOL fInit = FALSE;
3291 MPAFFINITY mask;
3292 APIRET rc;
3293
3294 if(fInit == FALSE && pfnDosQueryThreadAffinity == NULL)
3295 {
3296 ULONG nrCPUs;
3297
3298 rc = DosQuerySysInfo(QSV_NUMPROCESSORS, QSV_NUMPROCESSORS, &nrCPUs, sizeof(nrCPUs));
3299 if (rc != 0 || nrCPUs == 1)
3300 {//not supported
3301 fInit = TRUE;
3302 *pdwThreadAffinityMask = 1;
3303 SetLastError(ERROR_SUCCESS_W);
3304 return TRUE;
3305 }
3306
3307 HMODULE hDoscalls;
3308 if(DosQueryModuleHandleStrict("DOSCALLS", &hDoscalls) == NO_ERROR) {
3309 DosQueryProcAddr(hDoscalls, 563, NULL, (PFN *)&pfnDosQueryThreadAffinity);
3310 }
3311 fInit = TRUE;
3312 }
3313 if(fInit && pfnDosQueryThreadAffinity == NULL) {
3314 *pdwThreadAffinityMask = 1;
3315 SetLastError(ERROR_SUCCESS_W);
3316 return TRUE;
3317 }
3318
3319 ULONG scope = (fMaskType == MASK_SYSTEM) ? AFNTY_SYSTEM : AFNTY_THREAD;
3320
3321 USHORT sel = RestoreOS2FS();
3322
3323 rc = pfnDosQueryThreadAffinity(scope, &mask);
3324 SetFS(sel);
3325
3326 if(rc == NO_ERROR) {
3327 *pdwThreadAffinityMask = mask.mask[0];
3328 }
3329
3330 SetLastError(error2WinError(rc,ERROR_INVALID_PARAMETER));
3331 return (rc == NO_ERROR);
3332}
3333//******************************************************************************
3334//******************************************************************************
3335void OSLibDosSleep(ULONG msecs)
3336{
3337 DosSleep(msecs);
3338}
3339//******************************************************************************
3340//******************************************************************************
3341DWORD OSLibDosDevConfig(PVOID pdevinfo,
3342 ULONG item)
3343{
3344 return (DWORD)DosDevConfig(pdevinfo, item);
3345}
3346//******************************************************************************
3347//******************************************************************************
3348DWORD OSLibDosGetNumPhysDrives()
3349{
3350 USHORT usNumDrives = 0; /* Data return buffer */
3351 ULONG ulDataLen = sizeof(USHORT); /* Data return buffer length */
3352 APIRET rc = NO_ERROR; /* Return code */
3353
3354 /* Request a count of the number of partitionable disks in the system */
3355
3356 rc = DosPhysicalDisk(INFO_COUNT_PARTITIONABLE_DISKS,
3357 &usNumDrives,
3358 ulDataLen,
3359 NULL, /* No parameter for this function */
3360 0L);
3361
3362 if (rc != NO_ERROR) {
3363 dprintf(("DosPhysicalDisk error: return code = %u\n", rc));
3364 return 0;
3365 }
3366 else {
3367 dprintf(("DosPhysicalDisk: %u partitionable disk(s)\n",usNumDrives));
3368 }
3369 return usNumDrives;
3370}
3371//******************************************************************************
3372//******************************************************************************
3373
Note: See TracBrowser for help on using the repository browser.