Context Navigation

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

Visit:

Last change on this file since 3756 was 3748, checked in by sandervl, 25 years ago
MN: creating file & readonly -> readwrite (or else DosOpen fails)
File size: 58.1 KB

Line
1	/* $Id: oslibdos.cpp,v 1.32 2000-06-25 07:13:28 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	*
10	* Project Odin Software License can be found in LICENSE.TXT
11	*
12	*/
13	#define INCL_BASE
14	#define INCL_DOSEXCEPTIONS
15	#define INCL_DOSMEMMGR
16	#define INCL_DOSPROCESS
17	#define INCL_DOSFILEMGR
18	#define INCL_DOSERRORS
19	#define INCL_NPIPES
20	#include <os2wrap.h> //Odin32 OS/2 api wrappers
21	#include <stdlib.h>
22	#include <stdio.h>
23	#include <string.h>
24	#include <ctype.h>
25	#include <win32api.h>
26	#include <winconst.h>
27	#include <misc.h>
28	#include "initterm.h"
29	#include "oslibdos.h"
30	#include "dosqss.h"
31
32	#define DBG_LOCALLOG DBG_oslibdos
33	#include "dbglocal.h"
34
35	static PROC_DosSetFileSizeL DosSetFileSizeLProc = 0;
36	static PROC_DosSetFilePtrL DosSetFilePtrLProc = 0;
37	static PROC_DosSetFileLocksL DosSetFileLocksLProc = 0;
38	static BOOL f64BitIO = FALSE;
39	//******************************************************************************
40	//******************************************************************************
41	void OSLibInitWSeBFileIO()
42	{
43	HMODULE hDoscalls;
44
45	if(DosQueryModuleHandle("DOSCALLS", &hDoscalls) != NO_ERROR) {
46	return;
47	}
48	if(DosQueryProcAddr(hDoscalls, 989, NULL, (PFN *)&DosSetFileSizeLProc) != NO_ERROR) {
49	return;
50	}
51	if(DosQueryProcAddr(hDoscalls, 988, NULL, (PFN *)&DosSetFilePtrLProc) != NO_ERROR) {
52	return;
53	}
54	if(DosQueryProcAddr(hDoscalls, 986, NULL, (PFN *)&DosSetFileLocksLProc) != NO_ERROR) {
55	return;
56	}
57	f64BitIO = TRUE;
58	}
59	//******************************************************************************
60	//******************************************************************************
61	APIRET OdinDosSetFileSizeL(HFILE hFile, LONGLONG cbSize)
62	{
63	APIRET yyrc;
64	USHORT sel = RestoreOS2FS();
65
66	yyrc = DosSetFileSizeLProc(hFile, cbSize);
67	SetFS(sel);
68
69	return yyrc;
70	}
71	//******************************************************************************
72	//******************************************************************************
73	APIRET OdinDosSetFilePtrL(HFILE hFile, LONGLONG ib, ULONG method, PLONGLONG ibActual)
74	{
75	APIRET yyrc;
76	USHORT sel = RestoreOS2FS();
77
78	yyrc = DosSetFilePtrLProc(hFile, ib, method, ibActual);
79	SetFS(sel);
80
81	return yyrc;
82	}
83	//******************************************************************************
84	//******************************************************************************
85	APIRET OdinDosSetFileLocksL(HFILE hFile, PFILELOCKL pflUnlock, PFILELOCKL pflLock,
86	ULONG timeout, ULONG flags)
87	{
88	APIRET yyrc;
89	USHORT sel = RestoreOS2FS();
90
91	yyrc = DosSetFileLocksLProc(hFile, pflUnlock, pflLock, timeout, flags);
92	SetFS(sel);
93
94	return yyrc;
95	}
96	//******************************************************************************
97	// translate OS/2 error codes to Windows codes
98	// NOTE: add all codes you need, list is not complete!
99	//******************************************************************************
100	DWORD error2WinError(APIRET rc,DWORD defaultCode = ERROR_NOT_ENOUGH_MEMORY_W)
101	{
102	switch (rc)
103	{
104	case NO_ERROR: //0
105	return ERROR_SUCCESS_W;
106
107	case ERROR_INVALID_FUNCTION: //1
108	return ERROR_INVALID_FUNCTION_W;
109
110	case ERROR_FILE_NOT_FOUND: //2
111	return ERROR_FILE_NOT_FOUND_W;
112
113	case ERROR_PATH_NOT_FOUND: //3
114	return ERROR_PATH_NOT_FOUND_W;
115
116	case ERROR_TOO_MANY_OPEN_FILES: //4
117	return ERROR_TOO_MANY_OPEN_FILES_W;
118
119	case ERROR_ACCESS_DENIED: //5
120	return ERROR_ACCESS_DENIED_W;
121
122	case ERROR_INVALID_HANDLE: //6
123	return ERROR_INVALID_HANDLE_W;
124
125	case ERROR_NOT_ENOUGH_MEMORY: //8
126	return ERROR_NOT_ENOUGH_MEMORY_W;
127
128	case ERROR_BAD_FORMAT: //11
129	return ERROR_BAD_FORMAT_W;
130
131	case ERROR_INVALID_ACCESS: //12
132	return ERROR_INVALID_ACCESS_W;
133
134	case ERROR_NO_MORE_FILES: //18
135	return ERROR_NO_MORE_FILES_W;
136
137	case ERROR_WRITE_PROTECT: //19
138	return ERROR_WRITE_PROTECT_W;
139
140	case ERROR_NOT_DOS_DISK: //26
141	return ERROR_NOT_DOS_DISK_W;
142
143	case ERROR_WRITE_FAULT: //29
144	return ERROR_WRITE_FAULT_W;
145
146	case ERROR_SHARING_VIOLATION: //32
147	return ERROR_SHARING_VIOLATION_W;
148
149	case ERROR_LOCK_VIOLATION: //32
150	return ERROR_LOCK_VIOLATION_W;
151
152	case ERROR_SHARING_BUFFER_EXCEEDED: //36
153	return ERROR_SHARING_BUFFER_EXCEEDED_W;
154
155	case ERROR_CANNOT_MAKE: //82
156	return ERROR_CANNOT_MAKE_W;
157
158	case ERROR_OUT_OF_STRUCTURES: //84
159	return ERROR_OUT_OF_STRUCTURES_W;
160
161	case ERROR_INVALID_PARAMETER: //87
162	return ERROR_INVALID_PARAMETER_W;
163
164	case ERROR_INTERRUPT: //95
165	return ERROR_INVALID_AT_INTERRUPT_TIME_W; //CB: right???
166
167	case ERROR_DEVICE_IN_USE: //99
168	return ERROR_DEVICE_IN_USE_W;
169
170	case ERROR_DRIVE_LOCKED: //108
171	return ERROR_DRIVE_LOCKED_W;
172
173	case ERROR_BROKEN_PIPE: //109
174	return ERROR_BROKEN_PIPE_W;
175
176	case ERROR_OPEN_FAILED: //110
177	return ERROR_OPEN_FAILED_W;
178
179	case ERROR_BUFFER_OVERFLOW: //111
180	return ERROR_BUFFER_OVERFLOW_W;
181
182	case ERROR_DISK_FULL: //112
183	return ERROR_DISK_FULL_W;
184
185	case ERROR_NO_MORE_SEARCH_HANDLES: //113
186	return ERROR_NO_MORE_SEARCH_HANDLES_W;
187
188	case ERROR_SEM_TIMEOUT: //121
189	return ERROR_SEM_TIMEOUT_W;
190
191	case ERROR_DIRECT_ACCESS_HANDLE: //130
192	return ERROR_DIRECT_ACCESS_HANDLE_W;
193
194	case ERROR_NEGATIVE_SEEK: //131
195	return ERROR_NEGATIVE_SEEK;
196
197	case ERROR_SEEK_ON_DEVICE: //132
198	return ERROR_SEEK_ON_DEVICE_W;
199
200	case ERROR_DISCARDED: //157
201	return ERROR_DISCARDED_W;
202
203	case ERROR_FILENAME_EXCED_RANGE: //206
204	return ERROR_FILENAME_EXCED_RANGE_W;
205
206	case ERROR_META_EXPANSION_TOO_LONG: //208
207	return ERROR_META_EXPANSION_TOO_LONG_W;
208
209	case ERROR_BAD_PIPE: //230
210	return ERROR_BAD_PIPE_W;
211
212	case ERROR_PIPE_BUSY: //231
213	return ERROR_PIPE_BUSY_W;
214
215	case ERROR_NO_DATA: //232
216	return ERROR_NO_DATA_W;
217
218	case ERROR_PIPE_NOT_CONNECTED: //233
219	return ERROR_PIPE_NOT_CONNECTED_W;
220
221	case ERROR_MORE_DATA: //234
222	return ERROR_MORE_DATA_W;
223
224	case ERROR_INVALID_EA_NAME: //254
225	return ERROR_INVALID_EA_NAME_W;
226
227	case ERROR_EA_LIST_INCONSISTENT: //255
228	return ERROR_EA_LIST_INCONSISTENT_W;
229
230	case ERROR_EAS_DIDNT_FIT: //275
231	return ERROR_EAS_DIDNT_FIT;
232
233	default:
234	dprintf(("WARNING: error2WinError: error %d not included!!!!", rc));
235	return defaultCode;
236	}
237	}
238	//******************************************************************************
239	//TODO: Assumes entire memory range has the same protection flags!
240	//TODO: Check if this works for code aliases...
241	//******************************************************************************
242	DWORD OSLibDosAliasMem(LPVOID pb, ULONG cb, LPVOID *ppbAlias, ULONG fl)
243	{
244	DWORD rc;
245	DWORD attr;
246	DWORD size = cb;
247
248	cb = (cb-1) & ~0xfff;
249	cb+= PAGE_SIZE;
250
251	rc = DosQueryMem(pb, &size, &attr);
252	if(rc) {
253	dprintf(("OSLibDosAliasMem: DosQueryMem %x %x return %d", pb, size, rc));
254	return rc;
255	}
256	size = (size-1) & ~0xfff;
257	size+= PAGE_SIZE;
258	if(size != cb) {
259	dprintf(("ERROR: OSLibDosAliasMem: size != cb (%x!=%x)!!!!!!!!", size, cb));
260	//ignore this and continue return 5;
261	attr = fl; //just use original protection flags (NOT CORRECT)
262	}
263	attr &= (PAG_READ\|PAG_WRITE\|PAG_EXECUTE\|PAG_GUARD\|PAG_DEFAULT);
264	if(attr != fl) {
265	rc = DosSetMem(pb, size, fl);
266	if(rc) {
267	dprintf(("OSLibDosAliasMem: DosSetMem %x %x return %d", pb, size, rc));
268	attr = fl;
269	//just continue for now
270	//return rc;
271	}
272	}
273	rc = DosAliasMem(pb, cb, ppbAlias, 2);
274	if(rc) {
275	dprintf(("OSLibDosAliasMem: DosAliasMem %x %x returned %d", pb, cb, rc));
276	return rc;
277	}
278	if(attr != fl) {
279	rc = DosSetMem(pb, size, attr);
280	if(rc) {
281	dprintf(("OSLibDosAliasMem: DosSetMem (2) %x %x return %d", pb, size, rc));
282	return rc;
283	}
284	}
285	return 0;
286	}
287	//******************************************************************************
288	//NT returns addresses aligned at 64k, so we do too.
289	//******************************************************************************
290	DWORD OSLibDosAllocMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags)
291	{
292	LPVOID memaddr;
293	DWORD offset;
294	APIRET rc;
295
296	rc = DosAllocMem(&memaddr, size, PAG_READ \| flAllocMem);
297	if(rc) {
298	return rc;
299	}
300	DosEnterCritSec();
301	DosFreeMem(memaddr);
302	offset = (DWORD)memaddr & 0xFFFF;
303	if(offset) {
304	DosAllocMem(&memaddr, 64*1024 - offset, PAG_READ \| flAllocMem);
305	}
306	rc = DosAllocMem(lplpMemAddr, size, flags \| flAllocMem);
307	DosExitCritSec();
308	if((DWORD)*lplpMemAddr & 0xFFFF) {//still not at 64k boundary?
309	DosFreeMem(*lplpMemAddr);
310	rc = OSLibDosAllocMem(lplpMemAddr, size, flags);
311	}
312	if(offset) {
313	DosFreeMem(memaddr);
314	}
315
316	return rc;
317	}
318	//******************************************************************************
319	//******************************************************************************
320	DWORD OSLibDosFreeMem(LPVOID lpMemAddr)
321	{
322	return DosFreeMem(lpMemAddr);
323	}
324	//******************************************************************************
325	//NOTE: If name == NULL, allocated gettable unnamed shared memory
326	//******************************************************************************
327	DWORD OSLibDosAllocSharedMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags, LPSTR name)
328	{
329	APIRET rc;
330	char *sharedmemname = NULL;
331
332	if(name) {
333	sharedmemname = (char *)malloc(strlen(name) + 16);
334	strcpy(sharedmemname, "\\SHAREMEM\\");
335	strcat(sharedmemname, name);
336	}
337	else flags \|= OBJ_GETTABLE;
338
339	rc = DosAllocSharedMem(lplpMemAddr, sharedmemname, size, flags);
340	if(name) {
341	free(sharedmemname);
342	}
343	return rc;
344	}
345	//******************************************************************************
346	//NOTE: If name == NULL, assume gettable unnamed shared memory
347	//******************************************************************************
348	DWORD OSLibDosGetNamedSharedMem(LPVOID *lplpMemAddr, LPSTR name)
349	{
350	APIRET rc;
351	char *sharedmemname = NULL;
352
353	if(name) {
354	sharedmemname = (char *)malloc(strlen(name) + 16);
355	strcpy(sharedmemname, "\\SHAREMEM\\");
356	strcat(sharedmemname, name);
357	rc = DosGetNamedSharedMem(lplpMemAddr, sharedmemname, PAG_READ\|PAG_WRITE);
358	if(name) {
359	free(sharedmemname);
360	}
361	}
362	else rc = DosGetSharedMem((LPVOID)(DWORD )lplpMemAddr, PAG_READ\|PAG_WRITE);
363
364	return rc;
365	}
366	//******************************************************************************
367	//******************************************************************************
368	DWORD OSLibDosQueryMem(LPVOID lpMemAddr, DWORD lpRangeSize, DWORD lpAttr)
369	{
370	return DosQueryMem(lpMemAddr, lpRangeSize, lpAttr);
371	}
372	//******************************************************************************
373	//******************************************************************************
374	DWORD OSLibDosSetMem(LPVOID lpMemAddr, DWORD size, DWORD flags)
375	{
376	APIRET rc;
377
378	rc = DosSetMem(lpMemAddr, size, flags);
379	switch(rc) {
380	case ERROR_INVALID_ADDRESS:
381	return OSLIB_ERROR_INVALID_ADDRESS;
382	case ERROR_ACCESS_DENIED:
383	return OSLIB_ERROR_ACCESS_DENIED;
384	default:
385	return rc;
386	}
387	}
388	//******************************************************************************
389	//******************************************************************************
390	DWORD OSLibDosOpen(char *lpszFileName, DWORD flags)
391	{
392	APIRET rc;
393	HFILE hFile;
394	ULONG ulAction;
395	DWORD os2flags = OPEN_FLAGS_NOINHERIT;
396
397
398	if(flags & OSLIB_ACCESS_READONLY)
399	os2flags \|= OPEN_ACCESS_READONLY;
400	else
401	if(flags & OSLIB_ACCESS_READWRITE)
402	os2flags \|= OPEN_ACCESS_READWRITE;
403
404	if(flags & OSLIB_ACCESS_SHAREDENYNONE)
405	os2flags \|= OPEN_SHARE_DENYNONE;
406	else
407	if(flags & OSLIB_ACCESS_SHAREDENYREAD)
408	os2flags \|= OPEN_SHARE_DENYREAD;
409	else
410	if(flags & OSLIB_ACCESS_SHAREDENYWRITE)
411	os2flags \|= OPEN_SHARE_DENYWRITE;
412
413	tryopen:
414	rc = DosOpen(lpszFileName, /* File path name */
415	&hFile, /* File handle */
416	&ulAction, /* Action taken */
417	0L, /* File primary allocation */
418	0L, /* File attribute */
419	OPEN_ACTION_FAIL_IF_NEW \|
420	OPEN_ACTION_OPEN_IF_EXISTS, /* Open function type */
421	os2flags,
422	0L); /* No extended attribute */
423
424	if(rc) {
425	if(rc == ERROR_TOO_MANY_OPEN_FILES) {
426	ULONG CurMaxFH;
427	LONG ReqCount = 32;
428
429	rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
430	if(rc) {
431	dprintf(("DosSetRelMaxFH returned %d", rc));
432	return 0;
433	}
434	dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
435	goto tryopen;
436	}
437	return 0;
438	}
439	else return hFile;
440	}
441	//******************************************************************************
442	//******************************************************************************
443	BOOL OSLibDosClose(DWORD hFile)
444	{
445	APIRET rc;
446
447	rc = DosClose(hFile);
448	SetLastError(error2WinError(rc));
449	return (rc == NO_ERROR);
450	}
451	//******************************************************************************
452	//******************************************************************************
453	DWORD OSLibDosChangeMaxFileHandles()
454	{
455	ULONG CurMaxFH;
456	LONG ReqCount = 0;
457	APIRET rc;
458
459	rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
460	if(rc) {
461	dprintf(("DosSetRelMaxFH returned %d", rc));
462	return rc;
463	}
464	if(ReqCount + ODIN_INCREMENT_MAX_FILEHANDLES > CurMaxFH) {
465	ReqCount = CurMaxFH + ODIN_INCREMENT_MAX_FILEHANDLES;
466	rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
467	if(rc) {
468	dprintf(("DosSetRelMaxFH returned %d", rc));
469	return rc;
470	}
471	}
472	return 0;
473	}
474	//******************************************************************************
475	//******************************************************************************
476	DWORD OSLibDosSetInitialMaxFileHandles(DWORD maxhandles)
477	{
478	ULONG CurMaxFH;
479	LONG ReqCount = 0;
480	APIRET rc;
481
482	rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
483	if(rc) {
484	dprintf(("DosSetRelMaxFH returned %d", rc));
485	return rc;
486	}
487	if(CurMaxFH < maxhandles) {
488	rc = DosSetMaxFH(maxhandles);
489	if(rc) {
490	dprintf(("DosSetMaxFH returned %d", rc));
491	return rc;
492	}
493	}
494	return 0;
495	}
496	//******************************************************************************
497	//******************************************************************************
498	BOOL OSLibDosRead(DWORD hFile, LPVOID lpBuffer, DWORD size, DWORD *nrBytesRead)
499	{
500	APIRET rc;
501
502	rc = DosRead(hFile, lpBuffer, size, nrBytesRead);
503	SetLastError(error2WinError(rc));
504	return (rc == NO_ERROR);
505	}
506	//******************************************************************************
507	//******************************************************************************
508	BOOL OSLibDosWrite(DWORD hFile, LPVOID lpBuffer, DWORD size, DWORD *nrBytesWritten)
509	{
510	APIRET rc;
511
512	rc = DosWrite(hFile, lpBuffer, size, nrBytesWritten);
513	SetLastError(error2WinError(rc));
514	return (rc == NO_ERROR);
515	}
516	//******************************************************************************
517	//******************************************************************************
518	DWORD OSLibDosSetFilePtr(DWORD hFile, DWORD offset, DWORD method)
519	{
520	DWORD os2method;
521	DWORD newoffset;
522	APIRET rc;
523
524	switch(method)
525	{
526	case OSLIB_SETPTR_FILE_CURRENT:
527	os2method = FILE_CURRENT;
528	break;
529	case OSLIB_SETPTR_FILE_BEGIN:
530	os2method = FILE_BEGIN ;
531	break;
532	case OSLIB_SETPTR_FILE_END:
533	os2method = FILE_END;
534	break;
535	default:
536	return OSLIB_ERROR_INVALID_PARAMETER;
537	}
538
539	rc = DosSetFilePtr(hFile, offset, os2method, &newoffset);
540	if(rc)
541	{
542	SetLastError(error2WinError(rc));
543	return -1;
544	}
545	else return newoffset;
546	}
547	//******************************************************************************
548	//******************************************************************************
549	BOOL OSLibDosDelete(char *lpszFileName)
550	{
551	APIRET rc;
552
553	rc = DosDelete(lpszFileName);
554	if(rc) {
555	SetLastError(error2WinError(rc));
556	return FALSE;
557	}
558	return TRUE;
559	}
560	//******************************************************************************
561	//******************************************************************************
562	BOOL pmDateTimeToFileTime(FDATE pDate,FTIME pTime,FILETIME *pFT)
563	{
564	USHORT dosTime, dosDate;
565
566	dosTime = (USHORT)pTime;
567	dosDate = (USHORT)pDate;
568
569	return DosDateTimeToFileTime(dosDate,dosTime,pFT);
570	}
571	//******************************************************************************
572	//******************************************************************************
573	#define NOT_NORMAL (FILE_ATTRIBUTE_READONLY_W \| \
574	FILE_ATTRIBUTE_HIDDEN_W \| \
575	FILE_ATTRIBUTE_SYSTEM_W \| \
576	FILE_ATTRIBUTE_ARCHIVE_W)
577
578	inline DWORD pm2WinFileAttributes(DWORD attrFile)
579	{
580	DWORD res = 0;
581
582	if (!(attrFile & NOT_NORMAL))
583	res \|= FILE_ATTRIBUTE_NORMAL_W;
584	if (attrFile & FILE_READONLY)
585	res \|= FILE_ATTRIBUTE_READONLY_W;
586	if (attrFile & FILE_HIDDEN)
587	res \|= FILE_ATTRIBUTE_HIDDEN_W;
588	if (attrFile & FILE_SYSTEM)
589	res \|= FILE_ATTRIBUTE_SYSTEM_W;
590	if (attrFile & FILE_DIRECTORY)
591	res \|= FILE_ATTRIBUTE_DIRECTORY_W;
592	if (attrFile & FILE_ARCHIVED)
593	res \|= FILE_ATTRIBUTE_ARCHIVE_W;
594
595	//CB: not used: FILE_ATTRIBUTE_COMPRESSED_W
596
597	return res;
598	}
599	//******************************************************************************
600	//******************************************************************************
601	BOOL OSLibDosGetFileAttributesEx(PSZ pszName,
602	ULONG ulDummy,
603	PVOID pBuffer)
604	{
605	APIRET rc; /* API return code */
606	FILESTATUS3 fs3; /* file information structure */
607	LPWIN32_FILE_ATTRIBUTE_DATA lpFad = (LPWIN32_FILE_ATTRIBUTE_DATA) pBuffer;
608
609	// Note: we only handle standard "GetFileExInfoStandard" requests
610	rc = DosQueryPathInfo(pszName, /* query the file information */
611	FIL_STANDARD,
612	&fs3,
613	sizeof(fs3));
614	if (rc != NO_ERROR) /* check for errors */
615	return FALSE; /* raise error condition */
616
617	// convert structure
618	lpFad->dwFileAttributes = pm2WinFileAttributes(fs3.attrFile);
619	pmDateTimeToFileTime(&fs3.fdateCreation, &fs3.ftimeCreation, &lpFad->ftCreationTime);
620	pmDateTimeToFileTime(&fs3.fdateLastAccess, &fs3.ftimeLastAccess, &lpFad->ftLastAccessTime);
621	pmDateTimeToFileTime(&fs3.fdateLastWrite, &fs3.ftimeLastWrite, &lpFad->ftLastWriteTime);
622
623	/* @@@PH we might add Aurora support ...
624	lpFad->nFileSizeHigh = info.nFileSizeHigh;
625	*/
626	lpFad->nFileSizeHigh = 0;
627	lpFad->nFileSizeLow = fs3.cbFile;
628
629	return TRUE;
630	}
631	//******************************************************************************
632	DWORD WIN32API GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD );
633	//******************************************************************************
634	DWORD OSLibDosSearchPath(DWORD cmd, char path, char name, char *full_name,
635	DWORD length_fullname)
636	{
637	switch(cmd) {
638	case OSLIB_SEARCHDIR:
639	if(DosSearchPath(SEARCH_IGNORENETERRS, path,
640	name, full_name, length_fullname) != 0) {
641	return 0;
642	}
643	return strlen(full_name);
644
645
646	case OSLIB_SEARCHCURDIR:
647	if(DosSearchPath(SEARCH_IGNORENETERRS \| SEARCH_CUR_DIRECTORY, path,
648	name, full_name, length_fullname) != 0) {
649	return 0;
650	}
651	return strlen(full_name);
652
653	case OSLIB_SEARCHFILE:
654	{
655	FILESTATUS3 fileinfo;
656
657	if(DosQueryPathInfo(name, FIL_STANDARD, &fileinfo, sizeof(fileinfo)) != 0) {
658	return 0;
659	}
660	strncpy(full_name, name, length_fullname);
661	return strlen(full_name);
662	}
663
664	case OSLIB_SEARCHENV:
665	{
666	LPSTR envstring;
667	int envsize;
668	CHAR szResult[CCHMAXPATH];
669
670	envsize = GetEnvironmentVariableA(path, NULL, 0);
671	envstring = (LPSTR)malloc(envsize+1);
672	GetEnvironmentVariableA(path, envstring, envsize);
673	if(DosSearchPath(SEARCH_IGNORENETERRS, envstring,
674	name, szResult, sizeof(szResult)) != 0) {
675	free(envstring);
676	return 0;
677	}
678	free(envstring);
679	strcpy(full_name, szResult);
680	return strlen(full_name);
681	}
682	}
683	return 0;
684	}
685	//******************************************************************************
686	//******************************************************************************
687	APIRET OSLibDosQueryPathInfo(PSZ pszPathName,
688	ULONG ulInfoLevel,
689	PVOID pInfoBuf,
690	ULONG cbInfoBuf)
691	{
692	APIRET rc = DosQueryPathInfo( pszPathName, ulInfoLevel,
693	pInfoBuf, cbInfoBuf );
694
695	if(rc == ERROR_TOO_MANY_OPEN_FILES)
696	{
697	LONG reqCount = 2;
698	ULONG maxFiles;
699
700	if(DosSetRelMaxFH(&reqCount, &maxFiles) == NO_ERROR)
701	rc = DosQueryPathInfo(pszPathName, ulInfoLevel,
702	pInfoBuf, cbInfoBuf );
703	}
704	return rc;
705	}
706	//******************************************************************************
707	//******************************************************************************
708	DWORD OSLibDosCreateFile(CHAR *lpszFile,
709	DWORD fuAccess,
710	DWORD fuShare,
711	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
712	DWORD fuCreate,
713	DWORD fuAttrFlags,
714	HANDLE hTemplateFile)
715	{
716	HFILE hFile;
717	ULONG actionTaken = 0;
718	ULONG fileSize = 0;
719	ULONG fileAttr = FILE_NORMAL;
720	ULONG openFlag = 0;
721	ULONG openMode = 0;
722	APIRET rc = ERROR_NOT_ENOUGH_MEMORY;;
723
724	//TODO: lpSecurityAttributes (inheritance)
725
726	if(fuAttrFlags & FILE_ATTRIBUTE_ARCHIVE_W)
727	fileAttr \|= FILE_ARCHIVED;
728	if(fuAttrFlags & FILE_ATTRIBUTE_HIDDEN_W)
729	fileAttr \|= FILE_HIDDEN;
730	if(fuAttrFlags & FILE_ATTRIBUTE_SYSTEM_W)
731	fileAttr \|= FILE_SYSTEM;
732	if(fuAttrFlags & FILE_ATTRIBUTE_READONLY_W)
733	fileAttr \|= FILE_READONLY;
734	// TODO: FILE_ATTRIBUTE_TEMPORARY_W
735
736	switch(fuCreate)
737	{
738	case CREATE_NEW_W:
739	openFlag \|= OPEN_ACTION_CREATE_IF_NEW \| OPEN_ACTION_FAIL_IF_EXISTS;
740	break;
741	case CREATE_ALWAYS_W:
742	openFlag \|= OPEN_ACTION_CREATE_IF_NEW \| OPEN_ACTION_REPLACE_IF_EXISTS;
743	break;
744	case OPEN_EXISTING_W:
745	openFlag \|= OPEN_ACTION_FAIL_IF_NEW \| OPEN_ACTION_OPEN_IF_EXISTS;
746	break;
747	case OPEN_ALWAYS_W:
748	openFlag \|= OPEN_ACTION_CREATE_IF_NEW \| OPEN_ACTION_OPEN_IF_EXISTS;
749	break;
750	case TRUNCATE_EXISTING_W:
751	openFlag \|= OPEN_ACTION_FAIL_IF_NEW \| OPEN_ACTION_REPLACE_IF_EXISTS;
752	break;
753	}
754
755	if(fuAttrFlags & FILE_FLAG_WRITE_THROUGH_W) openMode \|= OPEN_FLAGS_WRITE_THROUGH;
756	if(fuAttrFlags & FILE_FLAG_NO_BUFFERING_W) openMode \|= OPEN_FLAGS_NO_CACHE;
757	if(fuAttrFlags & FILE_FLAG_RANDOM_ACCESS_W) openMode \|= OPEN_FLAGS_RANDOM;
758	if(fuAttrFlags & FILE_FLAG_SEQUENTIAL_SCAN_W) openMode \|= OPEN_FLAGS_SEQUENTIAL;
759	// TODO: FILE_FLAG_BACKUP_SEMANTICS_W
760	// FILE_FLAG_POSIX_SEMANTICS_W are not supported
761
762	if(fuShare == 0)
763	openMode \|= OPEN_SHARE_DENYREADWRITE;
764	else
765	if(fuShare == (FILE_SHARE_READ_W \| FILE_SHARE_WRITE_W))
766	openMode \|= OPEN_SHARE_DENYNONE;
767	else
768	if(fuShare & FILE_SHARE_READ_W)
769	openMode \|= OPEN_SHARE_DENYWRITE;
770	else
771	if(fuShare & FILE_SHARE_WRITE_W)
772	openMode \|= OPEN_SHARE_DENYREAD;
773
774	if(fuAccess == (GENERIC_READ_W \| GENERIC_WRITE_W))
775	openMode \|= OPEN_ACCESS_READWRITE;
776	else
777	if(fuAccess & GENERIC_READ_W)
778	openMode \|= OPEN_ACCESS_READONLY;
779	else
780	if(fuAccess & GENERIC_WRITE_W)
781	openMode \|= OPEN_ACCESS_WRITEONLY;
782
783	/* if creating a file, access cannot be readonly! */
784	if (openFlag & OPEN_ACTION_CREATE_IF_NEW &&
785	(!(openMode & OPEN_ACCESS_READWRITE) &&
786	!(openMode & OPEN_ACCESS_WRITEONLY))) {
787	openMode \|= OPEN_ACCESS_READWRITE;
788	}
789
790	int retry = 0;
791	while(retry < 2)
792	{
793	rc = DosOpen((PSZ)lpszFile,
794	&hFile,
795	&actionTaken,
796	fileSize,
797	fileAttr,
798	openFlag,
799	openMode,
800	NULL);
801	if(rc == ERROR_TOO_MANY_OPEN_FILES)
802	{
803	ULONG CurMaxFH;
804	LONG ReqCount = 32;
805
806	rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
807	if(rc) {
808	dprintf(("DosSetRelMaxFH returned %d", rc));
809	SetLastError(ERROR_TOO_MANY_OPEN_FILES_W);
810	return INVALID_HANDLE_VALUE_W;
811	}
812	dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
813	}
814	else break;
815	retry++;
816	}
817
818	if(rc)
819	{
820	SetLastError(error2WinError(rc));
821	return INVALID_HANDLE_VALUE_W;
822	}
823	SetLastError(ERROR_SUCCESS_W);
824	return hFile;
825	}
826	//******************************************************************************
827	//******************************************************************************
828	DWORD OSLibDosOpenFile(CHAR *lpszFile, UINT fuMode)
829	{
830	ULONG actionTaken = 0;
831	ULONG fileSize = 0;
832	ULONG fileAttr = FILE_NORMAL;
833	ULONG openFlag = 0;
834	ULONG openMode = 0;
835	APIRET rc = ERROR_NOT_ENOUGH_MEMORY;
836	HFILE hFile;
837
838	if(!(fuMode & (OF_CREATE_W \| OF_READWRITE_W \| OF_WRITE_W)))
839	{
840	openMode \|= OPEN_ACCESS_READONLY;
841	openFlag \|= OPEN_ACTION_OPEN_IF_EXISTS;
842	}
843	else
844	{
845	if(fuMode & OF_CREATE_W) {
846	openFlag \|= OPEN_ACTION_CREATE_IF_NEW \|
847	OPEN_ACTION_REPLACE_IF_EXISTS;
848	}
849	else openFlag \|= OPEN_ACTION_OPEN_IF_EXISTS; //180575
850
851	if(fuMode & OF_READWRITE_W)
852	openMode \|= OPEN_ACCESS_READWRITE;
853	else
854	if(fuMode & OF_WRITE_W)
855	openMode \|= OPEN_ACCESS_WRITEONLY;
856	else
857	if(fuMode & OF_CREATE_W)
858	openMode \|= OPEN_ACCESS_READWRITE;
859	}
860
861	if((fuMode & OF_SHARE_DENY_WRITE_W) \|\|
862	!(fuMode & (OF_SHARE_DENY_READ_W \| OF_SHARE_DENY_NONE_W \| OF_SHARE_EXCLUSIVE_W)))
863	openMode \|= OPEN_SHARE_DENYWRITE;
864	else
865	if (fuMode & OF_SHARE_DENY_NONE_W)
866	openMode \|= OPEN_SHARE_DENYNONE;
867	else
868	if (fuMode & OF_SHARE_DENY_READ_W)
869	openMode \|= OPEN_SHARE_DENYREAD;
870	else
871	if (fuMode & OF_SHARE_EXCLUSIVE_W)
872	openMode \|= OPEN_SHARE_DENYREADWRITE;
873
874	rc = DosOpen((PSZ)lpszFile,
875	&hFile,
876	&actionTaken,
877	fileSize,
878	fileAttr,
879	openFlag,
880	openMode,
881	NULL);
882
883	if(rc != NO_ERROR)
884	{
885	if(fuMode & OF_EXIST_W)
886	{
887	if(rc == ERROR_OPEN_FAILED \|\| rc == ERROR_FILE_NOT_FOUND)
888	{
889	SetLastError(ERROR_FILE_NOT_FOUND_W);
890	return HFILE_ERROR_W;
891	}
892	}
893	if((rc == ERROR_OPEN_FAILED) && (openFlag & OPEN_ACTION_OPEN_IF_EXISTS))
894	{
895	SetLastError(ERROR_FILE_NOT_FOUND_W);
896	}
897	else SetLastError(error2WinError(rc));
898
899	return HFILE_ERROR_W;
900	}
901	SetLastError(ERROR_SUCCESS_W);
902	return hFile;
903	}
904	//******************************************************************************
905	//******************************************************************************
906	BOOL OSLibDosLockFile(DWORD hFile, DWORD dwFlags,
907	DWORD OffsetLow, DWORD OffsetHigh,
908	DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
909	LPOVERLAPPED lpOverlapped)
910	{
911	APIRET rc;
912
913	// Set 5 secs timeout for locking file and no other can access this
914	// file region
915
916	if(lpOverlapped) {//TODO:
917	dprintf(("OSLibDosLockFile: overlapped lock not yet implemented!!"));
918	}
919	//TODO: Locking region crossing end of file is permitted. Works in OS/2??
920	if(f64BitIO)
921	{
922	FILELOCKL lockRangeL;
923
924	lockRangeL.lOffset.ulLo = OffsetLow;
925	lockRangeL.lOffset.ulHi = OffsetHigh;
926	lockRangeL.lRange.ulLo = nNumberOfBytesToLockLow;
927	lockRangeL.lRange.ulHi = nNumberOfBytesToLockHigh;
928
929	rc = OdinDosSetFileLocksL(hFile, NULL, &lockRangeL,
930	(dwFlags & LOCKFILE_FAIL_IMMEDIATELY_W) ? 0 : 5000, 0);
931	}
932	else
933	{
934	FILELOCK lockRange = { OffsetLow, nNumberOfBytesToLockLow };
935
936	rc = DosSetFileLocks(hFile, NULL, &lockRange,
937	(dwFlags & LOCKFILE_FAIL_IMMEDIATELY_W) ? 0 : 5000, 0);
938	}
939	if(rc) {
940	SetLastError(error2WinError(rc));
941	return FALSE;
942	}
943	SetLastError(ERROR_SUCCESS_W);
944	return TRUE;
945	}
946	//******************************************************************************
947	//******************************************************************************
948	BOOL OSLibDosUnlockFile(DWORD hFile, DWORD OffsetLow, DWORD OffsetHigh,
949	DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
950	LPOVERLAPPED lpOverlapped)
951	{
952	APIRET rc;
953
954	// Set 5 secs timeout for unlocking file and no other can access this
955	// file region
956
957	if(lpOverlapped) {//TODO:
958	dprintf(("OSLibDosUnlockFile: overlapped unlock not yet implemented!!"));
959	}
960	if(f64BitIO)
961	{
962	FILELOCKL unlockRangeL;
963
964	unlockRangeL.lOffset.ulLo = OffsetLow;
965	unlockRangeL.lOffset.ulHi = OffsetHigh;
966	unlockRangeL.lRange.ulLo = nNumberOfBytesToLockLow;
967	unlockRangeL.lRange.ulHi = nNumberOfBytesToLockHigh;
968
969	rc = OdinDosSetFileLocksL(hFile, &unlockRangeL, NULL, 5000, 0);
970	}
971	else
972	{
973	FILELOCK unlockRange = { OffsetLow, nNumberOfBytesToLockLow };
974
975	rc = DosSetFileLocks(hFile, &unlockRange, NULL, 5000, 0);
976	}
977	if(rc) {
978	SetLastError(error2WinError(rc));
979	return FALSE;
980	}
981	SetLastError(ERROR_SUCCESS_W);
982	return TRUE;
983	}
984	//******************************************************************************
985	//******************************************************************************
986	BOOL OSLibDosFlushFileBuffers(DWORD hFile)
987	{
988	APIRET rc;
989
990	rc = DosResetBuffer(hFile);
991	SetLastError(error2WinError(rc));
992	return (rc == NO_ERROR);
993	}
994	//******************************************************************************
995	//******************************************************************************
996	DWORD OSLibDosGetFileSize(DWORD hFile, LPDWORD lpdwFileSizeHigh)
997	{
998	APIRET rc;
999	ULONG sizeLow;
1000
1001	if(f64BitIO)
1002	{
1003	FILESTATUS3L fsts3ConfigInfoL = {{0}};
1004	ULONG ulBufSize = sizeof(FILESTATUS3L);
1005
1006	rc = DosQueryFileInfo(hFile, FIL_STANDARDL, &fsts3ConfigInfoL, ulBufSize);
1007	if(lpdwFileSizeHigh) {
1008	*lpdwFileSizeHigh = fsts3ConfigInfoL.cbFile.ulHi;
1009	}
1010	sizeLow = fsts3ConfigInfoL.cbFile.ulLo;
1011	}
1012	else
1013	{
1014	FILESTATUS3 fsts3ConfigInfo = {{0}};
1015	ULONG ulBufSize = sizeof(FILESTATUS3);
1016
1017	if(lpdwFileSizeHigh) {
1018	*lpdwFileSizeHigh = 0;
1019	}
1020	rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
1021	sizeLow = fsts3ConfigInfo.cbFile;
1022	}
1023	if(rc) {
1024	SetLastError(error2WinError(rc));
1025	return -1;
1026	}
1027	SetLastError(ERROR_SUCCESS_W);
1028	return sizeLow;
1029	}
1030	//******************************************************************************
1031	//******************************************************************************
1032	DWORD OSLibDosSetFilePointer(DWORD hFile, DWORD OffsetLow, DWORD *OffsetHigh, DWORD method)
1033	{
1034	LONGLONG offsetL;
1035	LONGLONG newoffsetL;
1036	APIRET rc;
1037	DWORD newoffset;
1038
1039	switch(method)
1040	{
1041	case FILE_BEGIN_W:
1042	method = FILE_BEGIN;
1043	break;
1044
1045	case FILE_CURRENT_W:
1046	method = FILE_CURRENT;
1047	break;
1048
1049	case FILE_END_W:
1050	method = FILE_END;
1051	break;
1052	}
1053
1054	// PH Note: for a negative 32-bit seek, the OS/2 64-bit version
1055	// needs to be skipped.
1056	if( (f64BitIO) && (OffsetHigh) )
1057	{
1058	offsetL.ulLo = OffsetLow;
1059	offsetL.ulHi = (OffsetHigh) ? *OffsetHigh : 0;
1060	rc = OdinDosSetFilePtrL(hFile, offsetL, method, &newoffsetL);
1061	if(OffsetHigh) {
1062	*OffsetHigh = newoffsetL.ulHi;
1063	}
1064	newoffset = newoffsetL.ulLo;
1065	}
1066	else
1067	rc = DosSetFilePtr(hFile, OffsetLow, method, &newoffset);
1068
1069	if(rc)
1070	{
1071	SetLastError(error2WinError(rc));
1072	return -1;
1073	}
1074	SetLastError(ERROR_SUCCESS_W);
1075	return newoffset;
1076	}
1077	//******************************************************************************
1078	//******************************************************************************
1079	BOOL OSLibDosSetEndOfFile(DWORD hFile)
1080	{
1081	ULONG newFilePos;
1082	LONGLONG FilePosL = {0,0};
1083	LONGLONG newFilePosL;
1084	APIRET rc;
1085
1086	if(f64BitIO) {
1087	rc = OdinDosSetFilePtrL(hFile, FilePosL, FILE_CURRENT, &newFilePosL);
1088	if(rc == 0) {
1089	rc = OdinDosSetFileSizeL(hFile, newFilePosL);
1090	}
1091	}
1092	else {
1093	rc = DosSetFilePtr(hFile, 0, FILE_CURRENT, &newFilePos);
1094	if(rc == 0) {
1095	rc = DosSetFileSize(hFile, newFilePos);
1096	}
1097	}
1098	if(rc) {
1099	SetLastError(error2WinError(rc));
1100	return FALSE;
1101	}
1102	SetLastError(ERROR_SUCCESS_W);
1103	return TRUE;
1104	}
1105	//******************************************************************************
1106	//******************************************************************************
1107	BOOL OSLibDosGetFileInformationByHandle(DWORD hFile, BY_HANDLE_FILE_INFORMATION* pInfo)
1108	{
1109	APIRET rc;
1110
1111	if(f64BitIO)
1112	{
1113	FILESTATUS4L statusL = { 0 };
1114
1115	rc = DosQueryFileInfo(hFile,
1116	FIL_QUERYEASIZEL,
1117	&statusL,
1118	sizeof(statusL));
1119	if(rc == NO_ERROR)
1120	{
1121	pInfo->dwFileAttributes = 0;
1122	if(!(statusL.attrFile & NOT_NORMAL))
1123	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_NORMAL_W;
1124	if(statusL.attrFile & FILE_READONLY)
1125	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_READONLY_W;
1126	if(statusL.attrFile & FILE_HIDDEN)
1127	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_HIDDEN_W;
1128	if(statusL.attrFile & FILE_SYSTEM)
1129	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_SYSTEM_W;
1130	if(statusL.attrFile & FILE_DIRECTORY)
1131	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_DIRECTORY_W;
1132	if(statusL.attrFile & FILE_ARCHIVED)
1133	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_ARCHIVE_W;
1134
1135	pmDateTimeToFileTime(&statusL.fdateCreation,
1136	&statusL.ftimeCreation,
1137	&pInfo->ftCreationTime);
1138	pmDateTimeToFileTime(&statusL.fdateLastAccess,
1139	&statusL.ftimeLastAccess,
1140	&pInfo->ftLastAccessTime);
1141	pmDateTimeToFileTime(&statusL.fdateLastWrite,
1142	&statusL.ftimeLastWrite,
1143	&pInfo->ftLastWriteTime);
1144
1145	pInfo->nFileSizeHigh = statusL.cbFile.ulHi;
1146	pInfo->nFileSizeLow = statusL.cbFile.ulLo;
1147	pInfo->dwVolumeSerialNumber = 0; //todo
1148	pInfo->nNumberOfLinks = 1;
1149	pInfo->nFileIndexHigh = 0;
1150	pInfo->nFileIndexLow = 0;
1151	}
1152	}
1153	else
1154	{
1155	FILESTATUS4 status = { 0 };
1156
1157	rc = DosQueryFileInfo(hFile,
1158	FIL_QUERYEASIZE,
1159	&status,
1160	sizeof(status));
1161	if(rc == NO_ERROR)
1162	{
1163	pInfo->dwFileAttributes = 0;
1164	if(!(status.attrFile & NOT_NORMAL))
1165	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_NORMAL_W;
1166	if(status.attrFile & FILE_READONLY)
1167	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_READONLY_W;
1168	if(status.attrFile & FILE_HIDDEN)
1169	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_HIDDEN_W;
1170	if(status.attrFile & FILE_SYSTEM)
1171	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_SYSTEM_W;
1172	if(status.attrFile & FILE_DIRECTORY)
1173	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_DIRECTORY_W;
1174	if(status.attrFile & FILE_ARCHIVED)
1175	pInfo->dwFileAttributes \|= FILE_ATTRIBUTE_ARCHIVE_W;
1176
1177	pmDateTimeToFileTime(&status.fdateCreation,
1178	&status.ftimeCreation,
1179	&pInfo->ftCreationTime);
1180	pmDateTimeToFileTime(&status.fdateLastAccess,
1181	&status.ftimeLastAccess,
1182	&pInfo->ftLastAccessTime);
1183	pmDateTimeToFileTime(&status.fdateLastWrite,
1184	&status.ftimeLastWrite,
1185	&pInfo->ftLastWriteTime);
1186
1187	pInfo->nFileSizeHigh = 0;
1188	pInfo->nFileSizeLow = status.cbFile;
1189	pInfo->dwVolumeSerialNumber = 0; //todo
1190	pInfo->nNumberOfLinks = 1;
1191	pInfo->nFileIndexHigh = 0;
1192	pInfo->nFileIndexLow = 0;
1193	}
1194	}
1195	if(rc) {
1196	SetLastError(error2WinError(rc));
1197	return FALSE;
1198	}
1199	SetLastError(ERROR_SUCCESS_W);
1200	return TRUE;
1201	}
1202	//******************************************************************************
1203	//******************************************************************************
1204	BOOL OSLibDosSetFileTime(DWORD hFile, WORD creationdate, WORD creationtime,
1205	WORD lastaccessdate, WORD lastaccesstime,
1206	WORD lastwritedate, WORD lastwritetime)
1207	{
1208	FILESTATUS3 fileInfo;
1209	APIRET rc;
1210
1211	rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fileInfo, sizeof(fileInfo));
1212
1213	if(rc == NO_ERROR)
1214	{
1215	if(creationdate && creationtime) {
1216	fileInfo.fdateCreation = (FDATE )&creationdate;
1217	fileInfo.ftimeCreation = (FTIME )&creationtime;
1218	}
1219	if(lastaccessdate && lastaccesstime) {
1220	fileInfo.fdateLastAccess = (FDATE )&lastaccessdate;
1221	fileInfo.ftimeLastAccess = (FTIME )&lastaccesstime;
1222	}
1223	if(lastwritedate && lastwritetime) {
1224	fileInfo.fdateLastWrite = (FDATE )&lastwritedate;
1225	fileInfo.ftimeLastWrite = (FTIME )&lastwritetime;
1226	}
1227
1228	rc = DosSetFileInfo(hFile, FIL_STANDARD, &fileInfo, sizeof(fileInfo));
1229	}
1230
1231	if(rc)
1232	{
1233	SetLastError(error2WinError(rc));
1234	return FALSE;
1235	}
1236	SetLastError(ERROR_SUCCESS_W);
1237	return TRUE;
1238	}
1239	//******************************************************************************
1240	//******************************************************************************
1241	BOOL OSLibDosGetFileTime(DWORD hFile, WORD creationdate, WORD creationtime,
1242	WORD lastaccessdate, WORD lastaccesstime,
1243	WORD lastwritedate, WORD lastwritetime)
1244	{
1245	FILESTATUS3 fileInfo;
1246	APIRET rc;
1247
1248	rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fileInfo, sizeof(fileInfo));
1249
1250	if(rc == NO_ERROR)
1251	{
1252	creationdate = (WORD *)&fileInfo.fdateCreation;
1253	creationtime = (WORD *)&fileInfo.ftimeCreation;
1254	lastaccessdate = (WORD *)&fileInfo.fdateLastAccess;
1255	lastaccesstime = (WORD *)&fileInfo.ftimeLastAccess;
1256	lastwritedate = (WORD *)&fileInfo.fdateLastWrite;
1257	lastwritetime = (WORD *)&fileInfo.ftimeLastWrite;
1258	}
1259
1260	if(rc)
1261	{
1262	SetLastError(error2WinError(rc));
1263	return FALSE;
1264	}
1265	SetLastError(ERROR_SUCCESS_W);
1266	return TRUE;
1267	}
1268	//******************************************************************************
1269	//******************************************************************************
1270	DWORD OSLibDosSetFilePtr2(DWORD hFile, DWORD offset, DWORD method)
1271	{
1272	DWORD newoffset;
1273	APIRET rc;
1274
1275
1276	rc = DosSetFilePtr(hFile, offset, method, &newoffset);
1277	if(rc) {
1278	dprintf(("DosSetFilePtr Error rc:%d", rc));
1279	return -1;
1280	}
1281	else return newoffset;
1282	}
1283	//******************************************************************************
1284	//******************************************************************************
1285	DWORD OSLibDosDupHandle(DWORD hFile, DWORD *hNew)
1286	{
1287	*hNew = -1;
1288	return DosDupHandle(hFile, hNew);
1289	}
1290	//******************************************************************************
1291	//******************************************************************************
1292	void OSLibDosDisableHardError(BOOL fTurnOff)
1293	{
1294	DosError((fTurnOff) ? FERR_DISABLEHARDERR : FERR_ENABLEHARDERR);
1295	}
1296	//******************************************************************************
1297	//Returns time spent in kernel & user mode in milliseconds
1298	//******************************************************************************
1299	BOOL OSLibDosQueryProcTimes(DWORD procid, ULONG kerneltime, ULONG usertime)
1300	{
1301	APIRET rc;
1302	char *buf;
1303	ULONG size;
1304	ULONG nrthreads = 4;
1305
1306	tryagain:
1307	size = sizeof(QTOPLEVEL)+sizeof(QGLOBAL)+sizeof(QPROCESS) + nrthreads*sizeof(QTHREAD);
1308	buf = (char *)malloc(size);
1309	rc = DosQuerySysState(0x1, RESERVED, procid, RESERVED, (PCHAR)buf, size);
1310
1311	if(rc) {
1312	free(buf);
1313	if(rc == ERROR_BUFFER_OVERFLOW) {
1314	nrthreads += 4;
1315	goto tryagain;
1316	}
1317	return FALSE;
1318	}
1319	PQTOPLEVEL top = (PQTOPLEVEL)buf;
1320
1321	*kerneltime = 0;
1322	*usertime = 0;
1323	for(int i=0;i<top->procdata->threadcnt;i++) {
1324	*kerneltime += top->procdata->threads[i].systime;
1325	*usertime += top->procdata->threads[i].usertime;
1326	}
1327	free(buf);
1328	return TRUE;
1329	}
1330	//******************************************************************************
1331	//******************************************************************************
1332	// TODO: implement SecurityAttributes parameter
1333	DWORD OSLibDosCreateNamedPipe(LPCTSTR lpName,
1334	DWORD dwOpenMode,
1335	DWORD dwPipeMode,
1336	DWORD nMaxInstances,
1337	DWORD nOutBufferSize,
1338	DWORD nInBufferSize,
1339	DWORD nDefaultTimeOut,
1340	void* lpSecurityAttributes)
1341	{ DWORD dwOS2Mode = 0;
1342	DWORD dwOS2PipeMode = 0;
1343	LPSTR lpOS2Name;
1344	DWORD hPipe;
1345	DWORD rc;
1346
1347	if (dwOpenMode & PIPE_ACCESS_DUPLEX_W)
1348	dwOS2Mode \|= NP_ACCESS_DUPLEX;
1349	else
1350	if (dwOpenMode & PIPE_ACCESS_INBOUND_W)
1351	dwOS2Mode \|= NP_ACCESS_INBOUND;
1352	else
1353	if (dwOpenMode & PIPE_ACCESS_OUTBOUND_W)
1354	dwOS2Mode \|= NP_ACCESS_OUTBOUND;
1355	// TODO:
1356	// if(dwOpenMode & FILE_FLAG_OVERLAPPED)
1357	// if(dwOpenMode & WRITE_DAC)
1358	// if(dwOpenMode & WRITE_OWNER)
1359	// if(dwOpenMode & ACCESS_SYSTEM_SECURITY)
1360	if(dwOpenMode & FILE_FLAG_WRITE_THROUGH_W)
1361	dwOS2Mode \|= NP_WRITEBEHIND; // FIXME: I'm not sure!
1362
1363	if (dwPipeMode & PIPE_WAIT_W)
1364	dwOS2PipeMode \|= NP_WAIT;
1365	if (dwPipeMode & PIPE_NOWAIT_W)
1366	dwOS2PipeMode \|= NP_NOWAIT;
1367	if (dwPipeMode & PIPE_READMODE_BYTE_W)
1368	dwOS2PipeMode \|= NP_READMODE_BYTE;
1369	if (dwPipeMode & PIPE_READMODE_MESSAGE_W)
1370	dwOS2PipeMode \|= NP_READMODE_MESSAGE;
1371	if (dwPipeMode & PIPE_TYPE_BYTE_W)
1372	dwOS2PipeMode \|= NP_TYPE_BYTE;
1373	if (dwPipeMode & PIPE_TYPE_MESSAGE_W)
1374	dwOS2PipeMode \|= NP_TYPE_MESSAGE;
1375
1376	if (nMaxInstances>0xff)
1377	{
1378	SetLastError(ERROR_INVALID_PARAMETER_W); // ERROR_INVALID_PARAMETER
1379	return -1; // INVALID_HANDLE_VALUE
1380	}
1381	dwOS2PipeMode \|= nMaxInstances;
1382
1383	if (strstr(lpName,"\\\\."))
1384	{
1385	// If pipe is created on the local machine
1386	// we must delete string \\. because
1387	// in Windows named pipes scheme is a \\.\PIPE\pipename
1388	// but in OS/2 only \PIPE\pipename
1389	lpOS2Name = (LPSTR)lpName + 3;
1390	}
1391	else lpOS2Name = (LPSTR)lpName;
1392
1393	dprintf(("DosCreateNPipe(%s,%x,%x,%x,%x,%x)",lpOS2Name,dwOS2Mode,dwOS2PipeMode,nInBufferSize,nOutBufferSize,nDefaultTimeOut));
1394	rc=DosCreateNPipe(lpOS2Name,
1395	&hPipe,
1396	dwOS2Mode,
1397	dwOS2PipeMode,
1398	nInBufferSize,
1399	nInBufferSize,
1400	nDefaultTimeOut); // Timeouts must be tested!
1401
1402	dprintf(("DosCreateNPipe rc=%d",rc));
1403	if (rc)
1404	{
1405	SetLastError(error2WinError(rc,ERROR_INVALID_PARAMETER_W));
1406	return -1; // INVALID_HANDLE_VALUE
1407	}
1408	return hPipe;
1409	}
1410
1411	//******************************************************************************
1412	//******************************************************************************
1413	// TODO: implement lpOverlapped parameter!
1414	BOOL OSLibDosConnectNamedPipe(DWORD hNamedPipe, LPOVERLAPPED lpOverlapped)
1415	{
1416	DWORD rc;
1417
1418	rc=DosConnectNPipe(hNamedPipe);
1419	dprintf(("DosConnectNPipe rc=%d",rc));
1420
1421	if (!rc) return (TRUE);
1422	SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1423
1424	return (FALSE);
1425	}
1426
1427	//******************************************************************************
1428	//******************************************************************************
1429	BOOL OSLibDosCallNamedPipe( LPCTSTR lpNamedPipeName,
1430	LPVOID lpInBuffer,
1431	DWORD nInBufferSize,
1432	LPVOID lpOutBuffer,
1433	DWORD nOutBufferSize,
1434	LPDWORD lpBytesRead,
1435	DWORD nTimeOut )
1436	{
1437	LPSTR lpOS2Name;
1438	DWORD rc;
1439
1440	if (strstr(lpNamedPipeName,"\\\\."))
1441	{
1442	// If pipe is created on the local machine
1443	// we must delete string \\. because
1444	// in Windows named pipes scheme is a \\.\PIPE\pipename
1445	// but in OS/2 only \PIPE\pipename
1446	lpOS2Name = (LPSTR)lpNamedPipeName + 3;
1447	}
1448	else lpOS2Name = (LPSTR)lpNamedPipeName;
1449
1450	rc=DosCallNPipe(lpOS2Name,
1451	lpInBuffer,
1452	nInBufferSize,
1453	lpOutBuffer,
1454	nOutBufferSize,
1455	lpBytesRead,
1456	nTimeOut );
1457
1458
1459	if (!rc) return (TRUE);
1460	SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1461
1462	return (FALSE);
1463	}
1464
1465	//******************************************************************************
1466	//******************************************************************************
1467	BOOL OSLibDosTransactNamedPipe( DWORD hNamedPipe,
1468	LPVOID lpInBuffer,
1469	DWORD nInBufferSize,
1470	LPVOID lpOutBuffer,
1471	DWORD nOutBufferSize,
1472	LPDWORD lpBytesRead,
1473	LPOVERLAPPED lpOverlapped)
1474	{
1475	DWORD rc;
1476
1477	rc=DosTransactNPipe(hNamedPipe,
1478	lpOutBuffer,
1479	nOutBufferSize,
1480	lpInBuffer,
1481	nInBufferSize,
1482	lpBytesRead);
1483
1484	dprintf(("DosTransactNPipe returned rc=%d");)
1485	if (!rc) return (TRUE);
1486	SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1487
1488	return (FALSE);
1489	}
1490
1491	//******************************************************************************
1492	//******************************************************************************
1493	BOOL OSLibDosPeekNamedPipe(DWORD hPipe,
1494	LPVOID lpvBuffer,
1495	DWORD cbBuffer,
1496	LPDWORD lpcbRead,
1497	LPDWORD lpcbAvail,
1498	LPDWORD lpcbMessage)
1499	{
1500	DWORD rc;
1501	AVAILDATA availData ={0};
1502	ULONG ulDummy;
1503
1504	rc=DosPeekNPipe(hPipe,lpvBuffer,cbBuffer,lpcbRead,&availData,&ulDummy);
1505
1506	dprintf(("DosPeekNPipe returned rc=%d",rc));
1507
1508	if (!rc)
1509	{
1510	*lpcbAvail = availData.cbpipe;
1511	*lpcbMessage = availData.cbmessage;
1512	return (TRUE);
1513	}
1514	SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1515
1516	return (FALSE);
1517	}
1518	//******************************************************************************
1519	//******************************************************************************
1520	BOOL OSLibDosDisconnectNamedPipe(DWORD hPipe)
1521	{
1522	DWORD rc;
1523
1524	rc=DosDisConnectNPipe(hPipe);
1525
1526	dprintf(("DosDisConnectNPipe returned rc=%d",rc));
1527
1528	if (!rc) return TRUE;
1529	SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1530
1531	return (FALSE);
1532	}
1533	//******************************************************************************
1534	//******************************************************************************
1535	BOOL OSLibDosWaitNamedPipe(LPCSTR lpszNamedPipeName,
1536	DWORD dwTimeout)
1537	{
1538	LPSTR lpOS2Name;
1539	DWORD rc;
1540
1541	if (strstr(lpszNamedPipeName,"\\\\."))
1542	{
1543	// If pipe is created on the local machine
1544	// we must delete string \\. because
1545	// in Windows named pipes scheme is a \\.\PIPE\pipename
1546	// but in OS/2 only \PIPE\pipename
1547	lpOS2Name = (LPSTR)lpszNamedPipeName + 3;
1548	}
1549	else lpOS2Name = (LPSTR)lpszNamedPipeName;
1550
1551	rc=DosWaitNPipe(lpOS2Name,dwTimeout);
1552
1553	dprintf(("DosWaitNPipe returned rc=%d",rc));
1554
1555	if (!rc) return TRUE;
1556	SetLastError(error2WinError(rc,ERROR_PIPE_NOT_CONNECTED_W));
1557
1558	return (FALSE);
1559	}
1560	//******************************************************************************
1561	//******************************************************************************
1562	BOOL isRoot(CHAR* name)
1563	{
1564	if (name[1] == ':')
1565	{
1566	//local name (x:\)
1567	return (name[2] == 0) \|\| !strchr(&name[3],'\\');
1568	} else if (name[0] == '\\')
1569	{
1570	//UNC name (\\resource\drive\)
1571	CHAR drive,dir;
1572
1573	drive = strchr(&name[2],'\\');
1574	if (!drive) return FALSE;
1575	dir = strchr(&drive[1],'\\');
1576	if (!dir) return TRUE;
1577	return !strchr(&dir[1],'\\');
1578	} else return FALSE; //unknown
1579	}
1580	//******************************************************************************
1581	//******************************************************************************
1582	inline CHAR system2DOSCharacter(CHAR ch)
1583	{
1584	switch(ch)
1585	{
1586	case ' ':
1587	case '.':
1588	case '~':
1589	return '_';
1590
1591	default:
1592	return toupper(ch);
1593	}
1594	}
1595
1596	VOID long2ShortName(CHAR* longName,CHAR* shortName)
1597	{
1598	INT x;
1599	CHAR source = longName,dest = shortName,*ext = strrchr(longName,'.');
1600
1601	if ((strcmp(longName,".") == 0) \|\| (strcmp(longName,"..") == 0))
1602	{
1603	strcpy(shortName,longName);
1604	return;
1605	}
1606
1607	//CB: quick and dirty, real FILE~12.EXT is too slow
1608
1609	//8 character file name
1610	for (x = 0;x < 8;x++)
1611	{
1612	if ((source == ext) \|\| (source[0] == 0)) break;
1613	dest[0] = system2DOSCharacter(source[0]);
1614	source++;
1615	dest++;
1616	}
1617
1618	if (source[0] == 0)
1619	{
1620	dest[0] = 0;
1621	return;
1622	}
1623
1624	if (source != ext)
1625	{
1626	//longName > 8 characters, insert ~1
1627	shortName[6] = '~';
1628	shortName[7] = '1';
1629	}
1630
1631	if (ext)
1632	{
1633	//add extension, 3 characters
1634	dest[0] = ext[0];
1635	dest++;
1636	ext++;
1637	for (x = 0;x < 3;x++)
1638	{
1639	if (ext[0] == 0) break;
1640	dest[0] = system2DOSCharacter(ext[0]);
1641	ext++;
1642	dest++;
1643	}
1644	}
1645	dest[0] = 0;
1646	}
1647	//******************************************************************************
1648	//******************************************************************************
1649	VOID translateFileResults(FILESTATUS3 pResult,LPWIN32_FIND_DATAA pFind,CHAR achName)
1650	{
1651	CHAR* name;
1652
1653	pFind->dwFileAttributes = pm2WinFileAttributes(pResult->attrFile);
1654
1655	pmDateTimeToFileTime(&pResult->fdateCreation,&pResult->ftimeCreation,&pFind->ftCreationTime);
1656	pmDateTimeToFileTime(&pResult->fdateLastAccess,&pResult->ftimeLastAccess,&pFind->ftLastAccessTime);
1657	pmDateTimeToFileTime(&pResult->fdateLastWrite,&pResult->ftimeLastWrite,&pFind->ftLastWriteTime);
1658
1659	pFind->nFileSizeHigh = 0; //CB: fixme
1660	pFind->nFileSizeLow = pResult->cbFile;
1661	name = strrchr(achName,'\\');
1662	if (name)
1663	{
1664	name++;
1665	strcpy(pFind->cFileName,name);
1666	} else pFind->cFileName[0] = 0;
1667	long2ShortName(pFind->cFileName,pFind->cAlternateFileName);
1668	}
1669
1670	VOID translateFindResults(FILEFINDBUF3 *pResult,LPWIN32_FIND_DATAA pFind)
1671	{
1672	pFind->dwFileAttributes = pm2WinFileAttributes(pResult->attrFile);
1673
1674	pmDateTimeToFileTime(&pResult->fdateCreation,&pResult->ftimeCreation,&pFind->ftCreationTime);
1675	pmDateTimeToFileTime(&pResult->fdateLastAccess,&pResult->ftimeLastAccess,&pFind->ftLastAccessTime);
1676	pmDateTimeToFileTime(&pResult->fdateLastWrite,&pResult->ftimeLastWrite,&pFind->ftLastWriteTime);
1677
1678	pFind->nFileSizeHigh = 0; //CB: fixme
1679	pFind->nFileSizeLow = pResult->cbFile;
1680	strcpy(pFind->cFileName,pResult->achName);
1681	long2ShortName(pFind->cFileName,pFind->cAlternateFileName);
1682	}
1683	//******************************************************************************
1684	//******************************************************************************
1685	DWORD OSLibDosFindFirst(LPCSTR lpFileName,WIN32_FIND_DATAA* lpFindFileData)
1686	{
1687	HDIR hDir = -1;
1688	ULONG attrs;
1689	FILEFINDBUF3 result;
1690	ULONG searchCount = 1;
1691
1692	attrs = FILE_READONLY \| FILE_HIDDEN \| FILE_SYSTEM \| FILE_DIRECTORY \| FILE_ARCHIVED;
1693	result.achName[0] = 0;
1694
1695	DosError(FERR_DISABLEHARDERR \| FERR_DISABLEEXCEPTION);
1696	APIRET rc = DosFindFirst((PSZ)lpFileName,&hDir,attrs,&result,sizeof(result),&searchCount,FIL_STANDARD);
1697	DosError(FERR_ENABLEHARDERR \| FERR_ENABLEEXCEPTION);
1698
1699	//check root: skip "." and ".." (HPFS, not on FAT)
1700	//check in OSLibDosFindNext not necessary: "." and ".." are the first two entries
1701	if ((rc == 0) && isRoot((LPSTR)lpFileName))
1702	{
1703	while ((strcmp(result.achName,".") == 0) \|\| (strcmp(result.achName,"..") == 0))
1704	{
1705	result.achName[0] = 0;
1706	DosError(FERR_DISABLEHARDERR \| FERR_DISABLEEXCEPTION);
1707	searchCount = 1;
1708	APIRET rc = DosFindNext(hDir,&result,sizeof(result),&searchCount);
1709	DosError(FERR_ENABLEHARDERR \| FERR_ENABLEEXCEPTION);
1710	if (rc)
1711	{
1712	DosFindClose(hDir);
1713	SetLastError(error2WinError(rc));
1714
1715	return INVALID_HANDLE_VALUE_W;
1716	}
1717	}
1718	}
1719	if(rc) {
1720	DosFindClose(hDir);
1721	SetLastError(error2WinError(rc));
1722	return INVALID_HANDLE_VALUE_W;
1723	}
1724	translateFindResults(&result,lpFindFileData);
1725	return hDir;
1726	}
1727	//******************************************************************************
1728	// NOTE: returns "." and ".." in root
1729	//******************************************************************************
1730	DWORD OSLibDosFindFirstMulti(LPCSTR lpFileName,WIN32_FIND_DATAA lpFindFileData,DWORD count)
1731	{
1732	HDIR hDir = -1;
1733	ULONG attrs;
1734	FILEFINDBUF3 result,data;
1735	ULONG searchCount = *count;
1736
1737	attrs = FILE_READONLY \| FILE_HIDDEN \| FILE_SYSTEM \| FILE_DIRECTORY \| FILE_ARCHIVED;
1738	result = (FILEFINDBUF3)malloc(searchCountsizeof(FILEFINDBUF3));
1739
1740	DosError(FERR_DISABLEHARDERR \| FERR_DISABLEEXCEPTION);
1741	APIRET rc = DosFindFirst((PSZ)lpFileName,&hDir,attrs,result,searchCount*sizeof(FILEFINDBUF3),&searchCount,FIL_STANDARD);
1742	DosError(FERR_ENABLEHARDERR \| FERR_ENABLEEXCEPTION);
1743	if (rc)
1744	{
1745	free(result);
1746	*count = 0;
1747	SetLastError(error2WinError(rc));
1748
1749	return INVALID_HANDLE_VALUE_W;
1750	}
1751
1752	data = result;
1753	for (int x = 0;x < searchCount;x++)
1754	{
1755	translateFindResults(data,&lpFindFileData[x]);
1756	data = (FILEFINDBUF3*)(((DWORD)data)+data->oNextEntryOffset);
1757	}
1758	free(result);
1759	*count = searchCount;
1760
1761	return hDir;
1762	}
1763	//******************************************************************************
1764	//******************************************************************************
1765	BOOL OSLibDosFindNext(DWORD hFindFile,WIN32_FIND_DATAA *lpFindFileData)
1766	{
1767	FILEFINDBUF3 result;
1768	ULONG searchCount = 1;
1769
1770	APIRET rc = DosFindNext((HDIR)hFindFile,&result,sizeof(result),&searchCount);
1771	if (rc)
1772	{
1773	SetLastError(error2WinError(rc));
1774
1775	return FALSE;
1776	}
1777
1778	translateFindResults(&result,lpFindFileData);
1779
1780	return TRUE;
1781	}
1782	//******************************************************************************
1783	//******************************************************************************
1784	BOOL OSLibDosFindNextMulti(DWORD hFindFile,WIN32_FIND_DATAA lpFindFileData,DWORD count)
1785	{
1786	FILEFINDBUF3 result,data;
1787	ULONG searchCount = *count;
1788
1789	result = (FILEFINDBUF3)malloc(searchCountsizeof(FILEFINDBUF3));
1790	APIRET rc = DosFindNext((HDIR)hFindFile,result,searchCount*sizeof(FILEFINDBUF3),&searchCount);
1791	if (rc)
1792	{
1793	free(result);
1794	*count = 0;
1795	SetLastError(error2WinError(rc));
1796
1797	return FALSE;
1798	}
1799
1800	data = result;
1801	for (int x = 0;x < searchCount;x++)
1802	{
1803	translateFindResults(data,&lpFindFileData[x]);
1804	data = (FILEFINDBUF3*)(((DWORD)data)+data->oNextEntryOffset);
1805	}
1806	free(result);
1807	*count = searchCount;
1808
1809	return TRUE;
1810	}
1811	//******************************************************************************
1812	//******************************************************************************
1813	BOOL OSLibDosFindClose(DWORD hFindFile)
1814	{
1815	APIRET rc = DosFindClose((HDIR)hFindFile);
1816	if (rc)
1817	{
1818	SetLastError(error2WinError(rc));
1819
1820	return FALSE;
1821	}
1822
1823	return TRUE;
1824	}
1825	//******************************************************************************
1826	#define FSATTACH_SIZE 256
1827	//******************************************************************************
1828	DWORD OSLibDosQueryVolumeFS(int drive, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize)
1829	{
1830	PFSQBUFFER2 fsinfo = (PFSQBUFFER2) alloca(FSATTACH_SIZE);
1831	ULONG cb = FSATTACH_SIZE;
1832	char drv[3] = "A:";
1833	char *fsname;
1834	APIRET rc;
1835
1836	if(lpFileSystemNameBuffer == NULL) {
1837	DebugInt3();
1838	return ERROR_INVALID_PARAMETER_W;
1839	}
1840	drv[0] = (char)('A' + drive - 1);
1841
1842	DosError(FERR_DISABLEHARDERR);
1843	rc = DosQueryFSAttach(drv, 1, FSAIL_QUERYNAME, fsinfo, &cb);
1844	DosError(FERR_ENABLEHARDERR);
1845
1846	switch(rc) {
1847	case ERROR_INVALID_DRIVE:
1848	return ERROR_INVALID_DRIVE_W;
1849	case ERROR_NO_VOLUME_LABEL:
1850	return ERROR_NO_VOLUME_LABEL_W;
1851	case NO_ERROR:
1852	break;
1853	default:
1854	return ERROR_NOT_ENOUGH_MEMORY; //whatever
1855	}
1856
1857	fsname = (char *)&fsinfo->szName[0] + fsinfo->cbName + 1;
1858	if(strlen(fsname) < nFileSystemNameSize) {
1859	strcpy(lpFileSystemNameBuffer, fsname);
1860	}
1861	else return ERROR_BUFFER_OVERFLOW_W;
1862	return 0;
1863	}
1864	//******************************************************************************
1865	typedef struct _FSINFOBUF
1866	{
1867	ULONG ulVolser; /* Volume serial number */
1868	VOLUMELABEL vol; /* Volume lable */
1869	} FSINFOBUF;
1870	//******************************************************************************
1871	DWORD OSLibDosQueryVolumeSerialAndName(int drive, LPDWORD lpVolumeSerialNumber,
1872	LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize)
1873	{
1874	FSINFOBUF fsi;
1875	APIRET rc;
1876
1877	DosError(FERR_DISABLEHARDERR);
1878	rc = DosQueryFSInfo(drive, FSIL_VOLSER, &fsi, sizeof(fsi));
1879	DosError(FERR_ENABLEHARDERR);
1880
1881	switch(rc) {
1882	case ERROR_INVALID_DRIVE:
1883	return ERROR_INVALID_DRIVE_W;
1884	case ERROR_NO_VOLUME_LABEL:
1885	return ERROR_NO_VOLUME_LABEL_W;
1886	case NO_ERROR:
1887	break;
1888	default:
1889	return ERROR_NOT_ENOUGH_MEMORY; //whatever
1890	}
1891
1892	if(lpVolumeSerialNumber) {
1893	*lpVolumeSerialNumber = fsi.ulVolser;
1894	}
1895	if(lpVolumeNameBuffer)
1896	{
1897	if(nVolumeNameSize > fsi.vol.cch) {
1898	strcpy(lpVolumeNameBuffer, (PCHAR)fsi.vol.szVolLabel);
1899	}
1900	else return ERROR_BUFFER_OVERFLOW_W;
1901	}
1902
1903	return ERROR_SUCCESS_W;
1904	}
1905	//******************************************************************************
1906	//******************************************************************************

Note: See TracBrowser for help on using the repository browser.

Download in other formats: