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

Last change on this file since 3269 was 3269, checked in by cbratschi, 25 years ago

FindFirst* changes
File size: 36.3 KB
Line 
1/* $Id: oslibdos.cpp,v 1.23 2000-03-29 15:17:28 cbratschi 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 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12#define INCL_BASE
13#define INCL_DOSEXCEPTIONS
14#define INCL_DOSMEMMGR
15#define INCL_DOSPROCESS
16#define INCL_DOSERRORS
17#define INCL_NPIPES
18#include <os2wrap.h> //Odin32 OS/2 api wrappers
19#include <stdlib.h>
20#include <stdio.h>
21#include <string.h>
22#include <win32api.h>
23#include <winconst.h>
24#include <misc.h>
25#include "initterm.h"
26#include "oslibdos.h"
27#include "dosqss.h"
28
29#define DBG_LOCALLOG DBG_oslibdos
30#include "dbglocal.h"
31
32//******************************************************************************
33//TODO: Assumes entire memory range has the same protection flags!
34//TODO: Check if this works for code aliases...
35//******************************************************************************
36DWORD OSLibDosAliasMem(LPVOID pb, ULONG cb, LPVOID *ppbAlias, ULONG fl)
37{
38 DWORD rc;
39 DWORD attr;
40 DWORD size = cb;
41
42 cb = (cb-1) & ~0xfff;
43 cb+= PAGE_SIZE;
44
45 rc = DosQueryMem(pb, &size, &attr);
46 if(rc) {
47 dprintf(("OSLibDosAliasMem: DosQueryMem %x %x return %d", pb, size, rc));
48 return rc;
49 }
50 size = (size-1) & ~0xfff;
51 size+= PAGE_SIZE;
52 if(size != cb) {
53 dprintf(("ERROR: OSLibDosAliasMem: size != cb (%x!=%x)!!!!!!!!", size, cb));
54 //ignore this and continue return 5;
55 attr = fl; //just use original protection flags (NOT CORRECT)
56 }
57 attr &= (PAG_READ|PAG_WRITE|PAG_EXECUTE|PAG_GUARD|PAG_DEFAULT);
58 if(attr != fl) {
59 rc = DosSetMem(pb, size, fl);
60 if(rc) {
61 dprintf(("OSLibDosAliasMem: DosSetMem %x %x return %d", pb, size, rc));
62 attr = fl;
63 //just continue for now
64 //return rc;
65 }
66 }
67 rc = DosAliasMem(pb, cb, ppbAlias, 2);
68 if(rc) {
69 dprintf(("OSLibDosAliasMem: DosAliasMem %x %x returned %d", pb, cb, rc));
70 return rc;
71 }
72 if(attr != fl) {
73 rc = DosSetMem(pb, size, attr);
74 if(rc) {
75 dprintf(("OSLibDosAliasMem: DosSetMem (2) %x %x return %d", pb, size, rc));
76 return rc;
77 }
78 }
79 return 0;
80}
81//******************************************************************************
82//NT returns addresses aligned at 64k, so we do too.
83//******************************************************************************
84DWORD OSLibDosAllocMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags)
85{
86 LPVOID memaddr;
87 DWORD offset;
88 APIRET rc;
89
90 rc = DosAllocMem(&memaddr, size, PAG_READ | flAllocMem);
91 if(rc) {
92 return rc;
93 }
94 DosEnterCritSec();
95 DosFreeMem(memaddr);
96 offset = (DWORD)memaddr & 0xFFFF;
97 if(offset) {
98 DosAllocMem(&memaddr, 64*1024 - offset, PAG_READ | flAllocMem);
99 }
100 rc = DosAllocMem(lplpMemAddr, size, flags | flAllocMem);
101 DosExitCritSec();
102 if((DWORD)*lplpMemAddr & 0xFFFF) {//still not at 64k boundary?
103 DosFreeMem(*lplpMemAddr);
104 rc = OSLibDosAllocMem(lplpMemAddr, size, flags);
105 }
106 if(offset) {
107 DosFreeMem(memaddr);
108 }
109
110 return rc;
111}
112//******************************************************************************
113//******************************************************************************
114DWORD OSLibDosFreeMem(LPVOID lpMemAddr)
115{
116 return DosFreeMem(lpMemAddr);
117}
118//******************************************************************************
119//NOTE: If name == NULL, allocated gettable unnamed shared memory
120//******************************************************************************
121DWORD OSLibDosAllocSharedMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags, LPSTR name)
122{
123 APIRET rc;
124 char *sharedmemname = NULL;
125
126 if(name) {
127 sharedmemname = (char *)malloc(strlen(name) + 16);
128 strcpy(sharedmemname, "\\SHAREMEM\\");
129 strcat(sharedmemname, name);
130 }
131 else flags |= OBJ_GETTABLE;
132
133 rc = DosAllocSharedMem(lplpMemAddr, sharedmemname, size, flags);
134 if(name) {
135 free(sharedmemname);
136 }
137 return rc;
138}
139//******************************************************************************
140//NOTE: If name == NULL, assume gettable unnamed shared memory
141//******************************************************************************
142DWORD OSLibDosGetNamedSharedMem(LPVOID *lplpMemAddr, LPSTR name)
143{
144 APIRET rc;
145 char *sharedmemname = NULL;
146
147 if(name) {
148 sharedmemname = (char *)malloc(strlen(name) + 16);
149 strcpy(sharedmemname, "\\SHAREMEM\\");
150 strcat(sharedmemname, name);
151 rc = DosGetNamedSharedMem(lplpMemAddr, sharedmemname, PAG_READ|PAG_WRITE);
152 if(name) {
153 free(sharedmemname);
154 }
155 }
156 else rc = DosGetSharedMem((LPVOID)*(DWORD *)lplpMemAddr, PAG_READ|PAG_WRITE);
157
158 return rc;
159}
160//******************************************************************************
161//******************************************************************************
162DWORD OSLibDosQueryMem(LPVOID lpMemAddr, DWORD *lpRangeSize, DWORD *lpAttr)
163{
164 return DosQueryMem(lpMemAddr, lpRangeSize, lpAttr);
165}
166//******************************************************************************
167//******************************************************************************
168DWORD OSLibDosSetMem(LPVOID lpMemAddr, DWORD size, DWORD flags)
169{
170 APIRET rc;
171
172 rc = DosSetMem(lpMemAddr, size, flags);
173 switch(rc) {
174 case ERROR_INVALID_ADDRESS:
175 return OSLIB_ERROR_INVALID_ADDRESS;
176 case ERROR_ACCESS_DENIED:
177 return OSLIB_ERROR_ACCESS_DENIED;
178 default:
179 return rc;
180 }
181}
182//******************************************************************************
183//******************************************************************************
184DWORD OSLibDosOpen(char *lpszFileName, DWORD flags)
185{
186 APIRET rc;
187 HFILE hFile;
188 ULONG ulAction;
189 DWORD os2flags = OPEN_FLAGS_NOINHERIT;
190
191
192 if(flags & OSLIB_ACCESS_READONLY)
193 os2flags |= OPEN_ACCESS_READONLY;
194 else
195 if(flags & OSLIB_ACCESS_READWRITE)
196 os2flags |= OPEN_ACCESS_READWRITE;
197
198 if(flags & OSLIB_ACCESS_SHAREDENYNONE)
199 os2flags |= OPEN_SHARE_DENYNONE;
200 else
201 if(flags & OSLIB_ACCESS_SHAREDENYREAD)
202 os2flags |= OPEN_SHARE_DENYREAD;
203 else
204 if(flags & OSLIB_ACCESS_SHAREDENYWRITE)
205 os2flags |= OPEN_SHARE_DENYWRITE;
206
207tryopen:
208 rc = DosOpen(lpszFileName, /* File path name */
209 &hFile, /* File handle */
210 &ulAction, /* Action taken */
211 0L, /* File primary allocation */
212 0L, /* File attribute */
213 OPEN_ACTION_FAIL_IF_NEW |
214 OPEN_ACTION_OPEN_IF_EXISTS, /* Open function type */
215 os2flags,
216 0L); /* No extended attribute */
217
218 if(rc) {
219 if(rc == ERROR_TOO_MANY_OPEN_FILES) {
220 ULONG CurMaxFH;
221 LONG ReqCount = 32;
222
223 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
224 if(rc) {
225 dprintf(("DosSetRelMaxFH returned %d", rc));
226 return 0;
227 }
228 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
229 goto tryopen;
230 }
231 return 0;
232 }
233 else return hFile;
234}
235//******************************************************************************
236//******************************************************************************
237DWORD OSLibDosClose(DWORD hFile)
238{
239 return DosClose(hFile);
240}
241//******************************************************************************
242//******************************************************************************
243DWORD OSLibDosChangeMaxFileHandles()
244{
245 ULONG CurMaxFH;
246 LONG ReqCount = 0;
247 APIRET rc;
248
249 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
250 if(rc) {
251 dprintf(("DosSetRelMaxFH returned %d", rc));
252 return rc;
253 }
254 if(ReqCount + ODIN_INCREMENT_MAX_FILEHANDLES > CurMaxFH) {
255 ReqCount = CurMaxFH + ODIN_INCREMENT_MAX_FILEHANDLES;
256 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
257 if(rc) {
258 dprintf(("DosSetRelMaxFH returned %d", rc));
259 return rc;
260 }
261 }
262 return 0;
263}
264//******************************************************************************
265//******************************************************************************
266DWORD OSLibDosSetInitialMaxFileHandles(DWORD maxhandles)
267{
268 ULONG CurMaxFH;
269 LONG ReqCount = 0;
270 APIRET rc;
271
272 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
273 if(rc) {
274 dprintf(("DosSetRelMaxFH returned %d", rc));
275 return rc;
276 }
277 if(CurMaxFH < maxhandles) {
278 rc = DosSetMaxFH(maxhandles);
279 if(rc) {
280 dprintf(("DosSetMaxFH returned %d", rc));
281 return rc;
282 }
283 }
284 return 0;
285}
286//******************************************************************************
287//******************************************************************************
288DWORD OSLibDosRead(DWORD hFile, LPVOID lpBuffer, DWORD size, DWORD *nrBytesRead)
289{
290 return DosRead(hFile, lpBuffer, size, nrBytesRead);
291}
292//******************************************************************************
293//******************************************************************************
294DWORD OSLibDosWrite(DWORD hFile, LPVOID lpBuffer, DWORD size, DWORD *nrBytesWritten)
295{
296 return DosWrite(hFile, lpBuffer, size, nrBytesWritten);
297}
298//******************************************************************************
299//******************************************************************************
300DWORD OSLibDosSetFilePtr(DWORD hFile, DWORD offset, DWORD method)
301{
302 DWORD os2method;
303 DWORD newoffset;
304 APIRET rc;
305
306 switch(method) {
307 case OSLIB_SETPTR_FILE_CURRENT:
308 os2method = FILE_CURRENT;
309 break;
310 case OSLIB_SETPTR_FILE_BEGIN:
311 os2method = FILE_BEGIN ;
312 break;
313 case OSLIB_SETPTR_FILE_END:
314 os2method = FILE_END;
315 break;
316 default:
317 return OSLIB_ERROR_INVALID_PARAMETER;
318 }
319 rc = DosSetFilePtr(hFile, offset, os2method, &newoffset);
320 if(rc) {
321 return -1;
322 }
323 else return newoffset;
324}
325//******************************************************************************
326//******************************************************************************
327BOOL pmDateTimeToFileTime(FDATE *pDate,FTIME *pTime,FILETIME *pFT)
328{
329 USHORT dosTime, dosDate;
330
331 dosTime = *(USHORT*)pTime;
332 dosDate = *(USHORT*)pDate;
333
334 return DosDateTimeToFileTime(dosDate,dosTime,pFT);
335}
336//******************************************************************************
337//******************************************************************************
338BOOL OSLibDosGetFileAttributesEx(PSZ pszName,
339 ULONG ulDummy,
340 PVOID pBuffer)
341{
342 APIRET rc; /* API return code */
343 FILESTATUS3 fs3; /* file information structure */
344 LPWIN32_FILE_ATTRIBUTE_DATA lpFad = (LPWIN32_FILE_ATTRIBUTE_DATA) pBuffer;
345
346 // Note: we only handle standard "GetFileExInfoStandard" requests
347 rc = DosQueryPathInfo(pszName, /* query the file information */
348 FIL_STANDARD,
349 &fs3,
350 sizeof(fs3));
351 if (rc != NO_ERROR) /* check for errors */
352 return FALSE; /* raise error condition */
353
354 // convert structure
355 lpFad->dwFileAttributes = fs3.attrFile; // directly interchangeable
356 pmDateTimeToFileTime(&fs3.fdateCreation, &fs3.ftimeCreation, &lpFad->ftCreationTime);
357 pmDateTimeToFileTime(&fs3.fdateLastAccess, &fs3.ftimeLastAccess, &lpFad->ftLastAccessTime);
358 pmDateTimeToFileTime(&fs3.fdateLastWrite, &fs3.ftimeLastWrite, &lpFad->ftLastWriteTime);
359
360 /* @@@PH we might add Aurora support ...
361 lpFad->nFileSizeHigh = info.nFileSizeHigh;
362 */
363 lpFad->nFileSizeHigh = 0;
364 lpFad->nFileSizeLow = fs3.cbFile;
365
366 return TRUE;
367}
368//******************************************************************************
369DWORD WIN32API GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD );
370//******************************************************************************
371DWORD OSLibDosSearchPath(DWORD cmd, char *path, char *name, char *full_name,
372 DWORD length_fullname)
373{
374 switch(cmd) {
375 case OSLIB_SEARCHDIR:
376 if(DosSearchPath(SEARCH_IGNORENETERRS, path,
377 name, full_name, length_fullname) != 0) {
378 return 0;
379 }
380 return strlen(full_name);
381
382
383 case OSLIB_SEARCHCURDIR:
384 if(DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_CUR_DIRECTORY, path,
385 name, full_name, length_fullname) != 0) {
386 return 0;
387 }
388 return strlen(full_name);
389
390 case OSLIB_SEARCHFILE:
391 {
392 FILESTATUS3 fileinfo;
393
394 if(DosQueryPathInfo(name, FIL_STANDARD, &fileinfo, sizeof(fileinfo)) != 0) {
395 return 0;
396 }
397 strncpy(full_name, name, length_fullname);
398 return strlen(full_name);
399 }
400
401 case OSLIB_SEARCHENV:
402 {
403 LPSTR envstring;
404 int envsize;
405 CHAR szResult[CCHMAXPATH];
406
407 envsize = GetEnvironmentVariableA(path, NULL, 0);
408 envstring = (LPSTR)malloc(envsize+1);
409 GetEnvironmentVariableA(path, envstring, envsize);
410 if(DosSearchPath(SEARCH_IGNORENETERRS, envstring,
411 name, szResult, sizeof(szResult)) != 0) {
412 free(envstring);
413 return 0;
414 }
415 free(envstring);
416 strcpy(full_name, szResult);
417 return strlen(full_name);
418 }
419 }
420 return 0;
421}
422//******************************************************************************
423//******************************************************************************
424DWORD OSLibDosCreate(CHAR *lpFileName,
425 DWORD dwAccess,
426 DWORD dwShare,
427 LPSECURITY_ATTRIBUTES lpSecurityAttributes,
428 DWORD dwCreation,
429 DWORD dwFlags,
430 HANDLE hTemplate,
431 DWORD *dwFile)
432{
433 APIRET rc;
434 HFILE hFile;
435 ULONG ulAction=0;
436 DWORD os2Attrib=0;
437 DWORD os2Flags = 0; //OPEN_FLAGS_NOINHERIT;
438 DWORD os2Open=0;
439
440 if(dwAccess == (GENERIC_READ_W | GENERIC_WRITE_W))
441 os2Flags |= OPEN_ACCESS_READWRITE;
442 else if(dwAccess & GENERIC_WRITE_W)
443 os2Flags |= OPEN_ACCESS_WRITEONLY;
444 else if(dwAccess & GENERIC_READ_W)
445 os2Flags |= OPEN_ACCESS_READONLY;
446
447 if(dwShare == 0)
448 os2Flags |= OPEN_SHARE_DENYREADWRITE;
449 else if(dwShare == (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W))
450 os2Flags |= OPEN_SHARE_DENYNONE;
451 else if(dwShare & FILE_SHARE_READ_W)
452 os2Flags |= OPEN_SHARE_DENYWRITE;
453 else if(dwShare & FILE_SHARE_WRITE_W)
454 os2Flags |= OPEN_SHARE_DENYREAD;
455
456 if(dwCreation == CREATE_NEW_W)
457 os2Open = OPEN_ACTION_FAIL_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
458 else if(dwCreation == CREATE_ALWAYS_W)
459 os2Open = OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
460 else if(dwCreation == OPEN_EXISTING_W)
461 os2Open = OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW;
462 else if(dwCreation == OPEN_ALWAYS_W)
463 os2Open = OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
464 else if(dwCreation == TRUNCATE_EXISTING_W)
465 os2Open = OPEN_ACTION_REPLACE_IF_EXISTS;// |OPEN_ACTION_FAIL_IF_NEW;
466
467 if(dwFlags & FILE_ATTRIBUTE_READONLY_W)
468 os2Attrib |= FILE_READONLY;
469 if(dwFlags & FILE_ATTRIBUTE_HIDDEN_W)
470 os2Attrib |= FILE_HIDDEN;
471 if(dwFlags & FILE_ATTRIBUTE_SYSTEM_W)
472 os2Attrib |= FILE_SYSTEM;
473 if(dwFlags & FILE_ATTRIBUTE_DIRECTORY_W)
474 os2Attrib |= FILE_DIRECTORY;
475 if(dwFlags & FILE_ATTRIBUTE_ARCHIVE_W)
476 os2Attrib |= FILE_ARCHIVED;
477 if(dwFlags & FILE_ATTRIBUTE_NORMAL_W)
478 os2Attrib |= FILE_NORMAL;
479
480 if(dwFlags & FILE_FLAG_WRITE_THROUGH_W)
481 os2Flags |= OPEN_FLAGS_WRITE_THROUGH;
482 if(dwFlags & FILE_FLAG_NO_BUFFERING_W)
483 os2Flags |= OPEN_FLAGS_NO_CACHE;
484 if(dwFlags & FILE_FLAG_RANDOM_ACCESS_W)
485 os2Flags |= OPEN_FLAGS_RANDOM;
486 if(dwFlags & FILE_FLAG_SEQUENTIAL_SCAN_W)
487 os2Flags |= OPEN_FLAGS_SEQUENTIAL;
488
489 // TODO:
490 // if(dwFlags & FILE_FLAG_OVERLAPPED_W)
491 // if(dwFlags & FILE_FLAG_DELETE_ON_CLOSE_W
492
493 rc = DosOpen(lpFileName, &hFile, &ulAction, 0,
494 os2Attrib, os2Open, os2Flags, 0);
495
496 if(rc)
497 {
498 // TODO: TEST TEST
499 dprintf(("DosOpen Error rc:%d, try without GENERIC_WRITE_W", rc));
500 if(dwAccess & GENERIC_WRITE_W)
501 os2Flags &= ~(OPEN_ACCESS_READWRITE | OPEN_ACCESS_WRITEONLY);
502 rc = DosOpen(lpFileName, &hFile, &ulAction, 0,
503 os2Attrib, os2Open, os2Flags, 0);
504 if(rc)
505 {
506 dprintf(("DosOpen Error rc:%d os2Attrib:%X os2Open:%X os2Flags:%X",
507 rc, os2Attrib, os2Open, os2Flags));
508 hFile = -1;
509 }
510 }
511
512 *dwFile = hFile;
513 return rc;
514}
515//******************************************************************************
516//(without changing file pointer)
517//******************************************************************************
518DWORD OSLibDosGetFileSize(DWORD hFile)
519{
520 FILESTATUS3 fsts3ConfigInfo = {{0}};
521 ULONG ulBufSize = sizeof(FILESTATUS3);
522
523 DosQueryFileInfo(hFile, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
524 return fsts3ConfigInfo.cbFile;
525}
526//******************************************************************************
527//******************************************************************************
528DWORD OSLibDosSetFilePtr2(DWORD hFile, DWORD offset, DWORD method)
529{
530 DWORD newoffset;
531 APIRET rc;
532
533
534 rc = DosSetFilePtr(hFile, offset, method, &newoffset);
535 if(rc) {
536 dprintf(("DosSetFilePtr Error rc:%d", rc));
537 return -1;
538 }
539 else return newoffset;
540}
541//******************************************************************************
542//(FlushBuffer)
543//******************************************************************************
544DWORD OSLibDosResetBuffer(DWORD hFile)
545{
546 return DosResetBuffer(hFile);
547}
548//******************************************************************************
549//******************************************************************************
550DWORD OSLibDosDupHandle(DWORD hFile, DWORD *hNew)
551{
552 *hNew = -1;
553 return DosDupHandle(hFile, hNew);
554}
555//******************************************************************************
556//******************************************************************************
557void OSLibDosDisableHardError(BOOL fTurnOff)
558{
559 DosError((fTurnOff) ? FERR_DISABLEHARDERR : FERR_ENABLEHARDERR);
560}
561//******************************************************************************
562//Returns time spent in kernel & user mode in milliseconds
563//******************************************************************************
564BOOL OSLibDosQueryProcTimes(DWORD procid, ULONG *kerneltime, ULONG *usertime)
565{
566 APIRET rc;
567 char *buf;
568 ULONG size;
569 ULONG nrthreads = 4;
570
571tryagain:
572 size = sizeof(QTOPLEVEL)+sizeof(QGLOBAL)+sizeof(QPROCESS) + nrthreads*sizeof(QTHREAD);
573 buf = (char *)malloc(size);
574 rc = DosQuerySysState(0x1, RESERVED, procid, RESERVED, (PCHAR)buf, size);
575
576 if(rc) {
577 free(buf);
578 if(rc == ERROR_BUFFER_OVERFLOW) {
579 nrthreads += 4;
580 goto tryagain;
581 }
582 return FALSE;
583 }
584 PQTOPLEVEL top = (PQTOPLEVEL)buf;
585
586 *kerneltime = 0;
587 *usertime = 0;
588 for(int i=0;i<top->procdata->threadcnt;i++) {
589 *kerneltime += top->procdata->threads[i].systime;
590 *usertime += top->procdata->threads[i].usertime;
591 }
592 free(buf);
593 return TRUE;
594}
595//******************************************************************************
596//******************************************************************************
597// TODO: implement SecurityAttributes parameter
598DWORD OSLibDosCreateNamedPipe(LPCTSTR lpName,
599 DWORD dwOpenMode,
600 DWORD dwPipeMode,
601 DWORD nMaxInstances,
602 DWORD nOutBufferSize,
603 DWORD nInBufferSize,
604 DWORD nDefaultTimeOut,
605 void* lpSecurityAttributes)
606{ DWORD dwOS2Mode = 0;
607 DWORD dwOS2PipeMode = 0;
608 LPSTR lpOS2Name;
609 DWORD hPipe;
610 DWORD rc;
611
612 if (dwOpenMode & PIPE_ACCESS_DUPLEX_W)
613 dwOS2Mode |= NP_ACCESS_DUPLEX;
614 else
615 if (dwOpenMode & PIPE_ACCESS_INBOUND_W)
616 dwOS2Mode |= NP_ACCESS_INBOUND;
617 else
618 if (dwOpenMode & PIPE_ACCESS_OUTBOUND_W)
619 dwOS2Mode |= NP_ACCESS_OUTBOUND;
620 // TODO:
621 // if(dwOpenMode & FILE_FLAG_OVERLAPPED)
622 // if(dwOpenMode & WRITE_DAC)
623 // if(dwOpenMode & WRITE_OWNER)
624 // if(dwOpenMode & ACCESS_SYSTEM_SECURITY)
625 if(dwOpenMode & FILE_FLAG_WRITE_THROUGH_W)
626 dwOS2Mode |= NP_WRITEBEHIND; // FIXME: I'm not sure!
627
628 if (dwPipeMode & PIPE_WAIT_W)
629 dwOS2PipeMode |= NP_WAIT;
630 if (dwPipeMode & PIPE_NOWAIT_W)
631 dwOS2PipeMode |= NP_NOWAIT;
632 if (dwPipeMode & PIPE_READMODE_BYTE_W)
633 dwOS2PipeMode |= NP_READMODE_BYTE;
634 if (dwPipeMode & PIPE_READMODE_MESSAGE_W)
635 dwOS2PipeMode |= NP_READMODE_MESSAGE;
636 if (dwPipeMode & PIPE_TYPE_BYTE_W)
637 dwOS2PipeMode |= NP_TYPE_BYTE;
638 if (dwPipeMode & PIPE_TYPE_MESSAGE_W)
639 dwOS2PipeMode |= NP_TYPE_MESSAGE;
640
641 if (nMaxInstances>0xff)
642 {
643 SetLastError(ERROR_INVALID_PARAMETER_W); // ERROR_INVALID_PARAMETER
644 return -1; // INVALID_HANDLE_VALUE
645 }
646 dwOS2PipeMode |= nMaxInstances;
647
648 if (strstr(lpName,"\\\\."))
649 {
650 // If pipe is created on the local machine
651 // we must delete string \\. because
652 // in Windows named pipes scheme is a \\.\PIPE\pipename
653 // but in OS/2 only \PIPE\pipename
654 lpOS2Name = (LPSTR)lpName + 3;
655 }
656 else lpOS2Name = (LPSTR)lpName;
657
658 dprintf(("DosCreateNPipe(%s,%x,%x,%x,%x,%x)",lpOS2Name,dwOS2Mode,dwOS2PipeMode,nInBufferSize,nOutBufferSize,nDefaultTimeOut));
659 rc=DosCreateNPipe(lpOS2Name,
660 &hPipe,
661 dwOS2Mode,
662 dwOS2PipeMode,
663 nInBufferSize,
664 nInBufferSize,
665 nDefaultTimeOut); // Timeouts must be tested!
666
667 dprintf(("DosCreateNPipe rc=%d",rc));
668 if (rc)
669 {
670 if ( rc == ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
671 else
672 if ( rc == ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
673 else
674 if ( rc == ERROR_NOT_ENOUGH_MEMORY ) SetLastError(ERROR_NOT_ENOUGH_MEMORY_W);
675 else
676 if ( rc == ERROR_INVALID_PARAMETER ) SetLastError(ERROR_INVALID_PARAMETER_W);
677 else
678 if ( rc == ERROR_OUT_OF_STRUCTURES ) SetLastError(ERROR_OUT_OF_STRUCTURES_W);
679 else
680 // Unknown error
681 SetLastError(ERROR_INVALID_PARAMETER_W); // fixme!
682 return -1; // INVALID_HANDLE_VALUE
683 }
684 return hPipe;
685}
686
687//******************************************************************************
688//******************************************************************************
689// TODO: implement lpOverlapped parameter!
690BOOL OSLibDosConnectNamedPipe(DWORD hNamedPipe, LPOVERLAPPED lpOverlapped)
691{
692 DWORD rc;
693
694 rc=DosConnectNPipe(hNamedPipe);
695 dprintf(("DosConnectNPipe rc=%d",rc));
696
697 if (!rc) return (TRUE);
698 else
699 if (rc==ERROR_BROKEN_PIPE) SetLastError(ERROR_BROKEN_PIPE_W);
700 else
701 if (rc==ERROR_BAD_PIPE) SetLastError(ERROR_BAD_PIPE_W);
702 else
703 if (rc==ERROR_PIPE_NOT_CONNECTED) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
704 else
705 // TODO: Implemnt this using Windows Errors
706 // if (rc==ERROR_INTERRUPT)
707 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
708
709 return (FALSE);
710}
711
712//******************************************************************************
713//******************************************************************************
714BOOL OSLibDosCallNamedPipe( LPCTSTR lpNamedPipeName,
715 LPVOID lpInBuffer,
716 DWORD nInBufferSize,
717 LPVOID lpOutBuffer,
718 DWORD nOutBufferSize,
719 LPDWORD lpBytesRead,
720 DWORD nTimeOut )
721{
722 LPSTR lpOS2Name;
723 DWORD rc;
724
725 if (strstr(lpNamedPipeName,"\\\\."))
726 {
727 // If pipe is created on the local machine
728 // we must delete string \\. because
729 // in Windows named pipes scheme is a \\.\PIPE\pipename
730 // but in OS/2 only \PIPE\pipename
731 lpOS2Name = (LPSTR)lpNamedPipeName + 3;
732 }
733 else lpOS2Name = (LPSTR)lpNamedPipeName;
734
735 rc=DosCallNPipe(lpOS2Name,
736 lpInBuffer,
737 nInBufferSize,
738 lpOutBuffer,
739 nOutBufferSize,
740 lpBytesRead,
741 nTimeOut );
742
743
744 if (!rc) return (TRUE);
745 else
746 if ( rc==ERROR_FILE_NOT_FOUND ) SetLastError(ERROR_FILE_NOT_FOUND_W);
747 else
748 if ( rc==ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
749 else
750 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
751 else
752 if ( rc==ERROR_MORE_DATA ) SetLastError(ERROR_MORE_DATA_W);
753 else
754 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
755 else
756 if ( rc==ERROR_BAD_FORMAT ) SetLastError(ERROR_BAD_FORMAT_W);
757 else
758 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
759 else
760 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
761 else
762 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
763 else
764 // TODO: Implemnt this using Windows Errors
765 // if (rc==ERROR_INTERRUPT)
766 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
767
768 return (FALSE);
769}
770
771//******************************************************************************
772//******************************************************************************
773BOOL OSLibDosTransactNamedPipe( DWORD hNamedPipe,
774 LPVOID lpInBuffer,
775 DWORD nInBufferSize,
776 LPVOID lpOutBuffer,
777 DWORD nOutBufferSize,
778 LPDWORD lpBytesRead,
779 LPOVERLAPPED lpOverlapped)
780{
781 DWORD rc;
782
783 rc=DosTransactNPipe(hNamedPipe,
784 lpOutBuffer,
785 nOutBufferSize,
786 lpInBuffer,
787 nInBufferSize,
788 lpBytesRead);
789
790 dprintf(("DosTransactNPipe returned rc=%d");)
791 if (!rc) return (TRUE);
792 else
793 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
794 else
795 if ( rc==ERROR_MORE_DATA ) SetLastError(ERROR_MORE_DATA_W);
796 else
797 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
798 else
799 if ( rc==ERROR_BAD_FORMAT ) SetLastError(ERROR_BAD_FORMAT_W);
800 else
801 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
802 else
803 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
804 else
805 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
806 else
807 // Unknown error
808 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
809
810 return (FALSE);
811}
812
813//******************************************************************************
814//******************************************************************************
815BOOL OSLibDosPeekNamedPipe(DWORD hPipe,
816 LPVOID lpvBuffer,
817 DWORD cbBuffer,
818 LPDWORD lpcbRead,
819 LPDWORD lpcbAvail,
820 LPDWORD lpcbMessage)
821{
822 DWORD rc;
823 AVAILDATA availData ={0};
824 ULONG ulDummy;
825
826 rc=DosPeekNPipe(hPipe,lpvBuffer,cbBuffer,lpcbRead,&availData,&ulDummy);
827
828 dprintf(("DosPeekNPipe returned rc=%d",rc));
829
830 if (!rc)
831 {
832 *lpcbAvail = availData.cbpipe;
833 *lpcbMessage = availData.cbmessage;
834 return (TRUE);
835 }
836 else
837 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
838 else
839 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
840 else
841 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
842 else
843 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
844 else
845 // Unknown error
846 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
847
848 return (FALSE);
849}
850//******************************************************************************
851//******************************************************************************
852BOOL OSLibDosDisconnectNamedPipe(DWORD hPipe)
853{
854 DWORD rc;
855
856 rc=DosDisConnectNPipe(hPipe);
857
858 dprintf(("DosDisConnectNPipe returned rc=%d",rc));
859
860 if (!rc) return TRUE;
861 else
862 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
863 else
864 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
865 else
866 // Unknown error
867 SetLastError(ERROR_PIPE_NOT_CONNECTED_W); // Maybe another?
868
869 return (FALSE);
870}
871//******************************************************************************
872//******************************************************************************
873BOOL OSLibDosWaitNamedPipe(LPCSTR lpszNamedPipeName,
874 DWORD dwTimeout)
875{
876 LPSTR lpOS2Name;
877 DWORD rc;
878
879 if (strstr(lpszNamedPipeName,"\\\\."))
880 {
881 // If pipe is created on the local machine
882 // we must delete string \\. because
883 // in Windows named pipes scheme is a \\.\PIPE\pipename
884 // but in OS/2 only \PIPE\pipename
885 lpOS2Name = (LPSTR)lpszNamedPipeName + 3;
886 }
887 else lpOS2Name = (LPSTR)lpszNamedPipeName;
888
889 rc=DosWaitNPipe(lpOS2Name,dwTimeout);
890
891 dprintf(("DosWaitNPipe returned rc=%d",rc));
892
893 if (!rc) return TRUE;
894 else
895 if ( rc == ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
896 else
897 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
898 else
899 if ( rc == ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
900 else
901 if ( rc == ERROR_SEM_TIMEOUT_W ) SetLastError(ERROR_SEM_TIMEOUT_W);
902 else
903 // TODO: Implemnt this using Windows Errors
904 // if (rc==ERROR_INTERRUPT)
905 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
906
907 return (FALSE);
908}
909//******************************************************************************
910//******************************************************************************
911#define NOT_NORMAL (FILE_ATTRIBUTE_READONLY_W | \
912 FILE_ATTRIBUTE_HIDDEN_W | \
913 FILE_ATTRIBUTE_SYSTEM_W | \
914 FILE_ATTRIBUTE_ARCHIVE_W)
915
916VOID translateFileResults(FILESTATUS3 *pResult,LPWIN32_FIND_DATAA pFind,CHAR* achName)
917{
918 pFind->dwFileAttributes = 0;
919 if (!(pResult->attrFile & NOT_NORMAL))
920 pFind->dwFileAttributes |= FILE_ATTRIBUTE_NORMAL_W;
921 if (pResult->attrFile & FILE_READONLY)
922 pFind->dwFileAttributes |= FILE_ATTRIBUTE_READONLY_W;
923 if (pResult->attrFile & FILE_HIDDEN)
924 pFind->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN_W;
925 if (pResult->attrFile & FILE_SYSTEM)
926 pFind->dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM_W;
927 if (pResult->attrFile & FILE_DIRECTORY)
928 pFind->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY_W;
929 if (pResult->attrFile & FILE_ARCHIVED)
930 pFind->dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE_W;
931
932 pmDateTimeToFileTime(&pResult->fdateCreation,&pResult->ftimeCreation,&pFind->ftCreationTime);
933 pmDateTimeToFileTime(&pResult->fdateLastAccess,&pResult->ftimeLastAccess,&pFind->ftLastAccessTime);
934 pmDateTimeToFileTime(&pResult->fdateLastWrite,&pResult->ftimeLastWrite,&pFind->ftLastWriteTime);
935
936 pFind->nFileSizeHigh = 0; //CB: fixme
937 pFind->nFileSizeLow = pResult->cbFile;
938 strcpy(pFind->cFileName,achName);
939 pFind->cAlternateFileName[0] = 0; //CB: fixme: store 8.3 file name
940}
941
942VOID translateFindResults(FILEFINDBUF3 *pResult,LPWIN32_FIND_DATAA pFind)
943{
944 pFind->dwFileAttributes = 0;
945 if (!(pResult->attrFile & NOT_NORMAL))
946 pFind->dwFileAttributes |= FILE_ATTRIBUTE_NORMAL_W;
947 if (pResult->attrFile & FILE_READONLY)
948 pFind->dwFileAttributes |= FILE_ATTRIBUTE_READONLY_W;
949 if (pResult->attrFile & FILE_HIDDEN)
950 pFind->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN_W;
951 if (pResult->attrFile & FILE_SYSTEM)
952 pFind->dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM_W;
953 if (pResult->attrFile & FILE_DIRECTORY)
954 pFind->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY_W;
955 if (pResult->attrFile & FILE_ARCHIVED)
956 pFind->dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE_W;
957
958 pmDateTimeToFileTime(&pResult->fdateCreation,&pResult->ftimeCreation,&pFind->ftCreationTime);
959 pmDateTimeToFileTime(&pResult->fdateLastAccess,&pResult->ftimeLastAccess,&pFind->ftLastAccessTime);
960 pmDateTimeToFileTime(&pResult->fdateLastWrite,&pResult->ftimeLastWrite,&pFind->ftLastWriteTime);
961
962 pFind->nFileSizeHigh = 0; //CB: fixme
963 pFind->nFileSizeLow = pResult->cbFile;
964 strcpy(pFind->cFileName,pResult->achName);
965 pFind->cAlternateFileName[0] = 0; //CB: fixme: store 8.3 file name
966}
967//******************************************************************************
968//******************************************************************************
969DWORD OSLibDosFindFirst(LPCSTR lpFileName,WIN32_FIND_DATAA* lpFindFileData)
970{
971 HDIR hDir = -1;
972 ULONG attrs;
973 FILEFINDBUF3 result;
974 ULONG searchCount = 1;
975
976 attrs = FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY | FILE_ARCHIVED;
977
978 DosError(FERR_DISABLEHARDERR | FERR_DISABLEEXCEPTION);
979 APIRET rc = DosFindFirst((PSZ)lpFileName,&hDir,attrs,&result,sizeof(result),&searchCount,FIL_STANDARD);
980 DosError(FERR_ENABLEHARDERR | FERR_ENABLEEXCEPTION);
981 if (rc)
982 {
983 SetLastError(ERROR_PATH_NOT_FOUND_W); //CB: fixme: better error handling
984
985 return INVALID_HANDLE_VALUE_W;
986 }
987
988 translateFindResults(&result,lpFindFileData);
989
990 return hDir;
991}
992//******************************************************************************
993//******************************************************************************
994DWORD OSLibDosFindFirstMulti(LPCSTR lpFileName,WIN32_FIND_DATAA *lpFindFileData,DWORD *count)
995{
996 HDIR hDir = -1;
997 ULONG attrs;
998 FILEFINDBUF3 *result,*data;
999 ULONG searchCount = *count;
1000
1001 attrs = FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY | FILE_ARCHIVED;
1002 result = (FILEFINDBUF3*)malloc(searchCount*sizeof(FILEFINDBUF3));
1003
1004 DosError(FERR_DISABLEHARDERR | FERR_DISABLEEXCEPTION);
1005 APIRET rc = DosFindFirst((PSZ)lpFileName,&hDir,attrs,result,searchCount*sizeof(FILEFINDBUF3),&searchCount,FIL_STANDARD);
1006 DosError(FERR_ENABLEHARDERR | FERR_ENABLEEXCEPTION);
1007 if (rc)
1008 {
1009 free(result);
1010 *count = 0;
1011 SetLastError(ERROR_PATH_NOT_FOUND_W); //CB: fixme: better error handling
1012
1013 return INVALID_HANDLE_VALUE_W;
1014 }
1015
1016 data = result;
1017 for (int x = 0;x < searchCount;x++)
1018 {
1019 translateFindResults(data,&lpFindFileData[x]);
1020 data = (FILEFINDBUF3*)(((DWORD)data)+data->oNextEntryOffset);
1021 }
1022 free(result);
1023 *count = searchCount;
1024
1025 return hDir;
1026}
1027//******************************************************************************
1028//******************************************************************************
1029BOOL OSLibDosFindNext(DWORD hFindFile,WIN32_FIND_DATAA *lpFindFileData)
1030{
1031 FILEFINDBUF3 result;
1032 ULONG searchCount = 1;
1033
1034 APIRET rc = DosFindNext((HDIR)hFindFile,&result,sizeof(result),&searchCount);
1035 if (rc)
1036 {
1037 SetLastError(ERROR_INVALID_HANDLE_W); //CB: fixme: better error code
1038
1039 return FALSE;
1040 }
1041
1042 translateFindResults(&result,lpFindFileData);
1043
1044 return TRUE;
1045}
1046//******************************************************************************
1047//******************************************************************************
1048BOOL OSLibDosFindNextMulti(DWORD hFindFile,WIN32_FIND_DATAA *lpFindFileData,DWORD *count)
1049{
1050 FILEFINDBUF3 *result,*data;
1051 ULONG searchCount = *count;
1052
1053 result = (FILEFINDBUF3*)malloc(searchCount*sizeof(FILEFINDBUF3));
1054 APIRET rc = DosFindNext((HDIR)hFindFile,result,searchCount*sizeof(FILEFINDBUF3),&searchCount);
1055 if (rc)
1056 {
1057 free(result);
1058 *count = 0;
1059 SetLastError(ERROR_INVALID_HANDLE_W); //CB: fixme: better error code
1060
1061 return FALSE;
1062 }
1063
1064 data = result;
1065 for (int x = 0;x < searchCount;x++)
1066 {
1067 translateFindResults(data,&lpFindFileData[x]);
1068 data = (FILEFINDBUF3*)(((DWORD)data)+data->oNextEntryOffset);
1069 }
1070 free(result);
1071 *count = searchCount;
1072
1073 return TRUE;
1074}
1075//******************************************************************************
1076//******************************************************************************
1077BOOL OSLibDosFindClose(DWORD hFindFile)
1078{
1079 APIRET rc = DosFindClose((HDIR)hFindFile);
1080 if (rc)
1081 {
1082 SetLastError(ERROR_INVALID_HANDLE_W);
1083
1084 return FALSE;
1085 }
1086
1087 return TRUE;
1088}
Note: See TracBrowser for help on using the repository browser.