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

Last change on this file since 3074 was 3074, checked in by sandervl, 25 years ago

file handle + registry changes
File size: 29.6 KB
Line 
1/* $Id: oslibdos.cpp,v 1.22 2000-03-10 16:12:00 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 *
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//******************************************************************************
327//@@@PH Note: this routine is nothing but a QUICK'N'DIRTY HACK!
328//@@@PH this function should be implemented accordingly to NTDLL's
329// RtlSecondsSince1980ToTime
330// RtlTimeToSecondsSince1980
331static void iFDATEFTIME2FILETIME(FDATE fdOS2, FTIME ftOS2, LPFILETIME pftWin32)
332{
333 float f;
334 #define facSECOND 2 // as encoded in OS/2
335 #define facMINUTE 60
336 #define facHOUR 3600
337 #define facDAY 86400
338 #define facMONTH facDAY * 30 // cough, cough :)
339 #define facYEAR facDAY * 365
340
341 /* pftWin32 is 100ns based from 01.01.1601 00:00:00 */
342 f = (fdOS2.year + 379) * facYEAR // 1980 - 1601
343 + (fdOS2.month - 0 ) * facMONTH
344 + (fdOS2.day - 1 ) * facDAY
345 + (ftOS2.hours ) * facHOUR
346 + (ftOS2.minutes ) * facMINUTE
347 + (ftOS2.twosecs ) * facSECOND;
348
349 f *= 10000; // convert to 100ns base
350 pftWin32->dwHighDateTime = (f / (float)(0xffffffff) );
351 pftWin32->dwLowDateTime = (f - (float)((float)pftWin32->dwHighDateTime *
352 (float)0xffffffff) );
353}
354
355BOOL OSLibDosGetFileAttributesEx(PSZ pszName,
356 ULONG ulDummy,
357 PVOID pBuffer)
358{
359 APIRET rc; /* API return code */
360 FILESTATUS3 fs3; /* file information structure */
361 LPWIN32_FILE_ATTRIBUTE_DATA lpFad = (LPWIN32_FILE_ATTRIBUTE_DATA) pBuffer;
362
363 // Note: we only handle standard "GetFileExInfoStandard" requests
364 rc = DosQueryPathInfo(pszName, /* query the file information */
365 FIL_STANDARD,
366 &fs3,
367 sizeof(fs3));
368 if (rc != NO_ERROR) /* check for errors */
369 return FALSE; /* raise error condition */
370
371 // convert structure
372 lpFad->dwFileAttributes = fs3.attrFile; // directly interchangeable
373 iFDATEFTIME2FILETIME(fs3.fdateCreation, fs3.ftimeCreation, &lpFad->ftCreationTime);
374 iFDATEFTIME2FILETIME(fs3.fdateLastAccess, fs3.ftimeLastAccess, &lpFad->ftLastAccessTime);
375 iFDATEFTIME2FILETIME(fs3.fdateLastWrite, fs3.ftimeLastWrite, &lpFad->ftLastWriteTime);
376
377 /* @@@PH we might add Aurora support ...
378 lpFad->nFileSizeHigh = info.nFileSizeHigh;
379 */
380 lpFad->nFileSizeHigh = 0;
381 lpFad->nFileSizeLow = fs3.cbFile;
382
383 return TRUE;
384}
385//******************************************************************************
386DWORD WIN32API GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD );
387//******************************************************************************
388DWORD OSLibDosSearchPath(DWORD cmd, char *path, char *name, char *full_name,
389 DWORD length_fullname)
390{
391 switch(cmd) {
392 case OSLIB_SEARCHDIR:
393 if(DosSearchPath(SEARCH_IGNORENETERRS, path,
394 name, full_name, length_fullname) != 0) {
395 return 0;
396 }
397 return strlen(full_name);
398
399
400 case OSLIB_SEARCHCURDIR:
401 if(DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_CUR_DIRECTORY, path,
402 name, full_name, length_fullname) != 0) {
403 return 0;
404 }
405 return strlen(full_name);
406
407 case OSLIB_SEARCHFILE:
408 {
409 FILESTATUS3 fileinfo;
410
411 if(DosQueryPathInfo(name, FIL_STANDARD, &fileinfo, sizeof(fileinfo)) != 0) {
412 return 0;
413 }
414 strncpy(full_name, name, length_fullname);
415 return strlen(full_name);
416 }
417
418 case OSLIB_SEARCHENV:
419 {
420 LPSTR envstring;
421 int envsize;
422 CHAR szResult[CCHMAXPATH];
423
424 envsize = GetEnvironmentVariableA(path, NULL, 0);
425 envstring = (LPSTR)malloc(envsize+1);
426 GetEnvironmentVariableA(path, envstring, envsize);
427 if(DosSearchPath(SEARCH_IGNORENETERRS, envstring,
428 name, szResult, sizeof(szResult)) != 0) {
429 free(envstring);
430 return 0;
431 }
432 free(envstring);
433 strcpy(full_name, szResult);
434 return strlen(full_name);
435 }
436 }
437 return 0;
438}
439//******************************************************************************
440//******************************************************************************
441DWORD OSLibDosCreate(CHAR *lpFileName,
442 DWORD dwAccess,
443 DWORD dwShare,
444 LPSECURITY_ATTRIBUTES lpSecurityAttributes,
445 DWORD dwCreation,
446 DWORD dwFlags,
447 HANDLE hTemplate,
448 DWORD *dwFile)
449{
450 APIRET rc;
451 HFILE hFile;
452 ULONG ulAction=0;
453 DWORD os2Attrib=0;
454 DWORD os2Flags = 0; //OPEN_FLAGS_NOINHERIT;
455 DWORD os2Open=0;
456
457 if(dwAccess == (GENERIC_READ_W | GENERIC_WRITE_W))
458 os2Flags |= OPEN_ACCESS_READWRITE;
459 else if(dwAccess & GENERIC_WRITE_W)
460 os2Flags |= OPEN_ACCESS_WRITEONLY;
461 else if(dwAccess & GENERIC_READ_W)
462 os2Flags |= OPEN_ACCESS_READONLY;
463
464 if(dwShare == 0)
465 os2Flags |= OPEN_SHARE_DENYREADWRITE;
466 else if(dwShare == (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W))
467 os2Flags |= OPEN_SHARE_DENYNONE;
468 else if(dwShare & FILE_SHARE_READ_W)
469 os2Flags |= OPEN_SHARE_DENYWRITE;
470 else if(dwShare & FILE_SHARE_WRITE_W)
471 os2Flags |= OPEN_SHARE_DENYREAD;
472
473 if(dwCreation == CREATE_NEW_W)
474 os2Open = OPEN_ACTION_FAIL_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
475 else if(dwCreation == CREATE_ALWAYS_W)
476 os2Open = OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
477 else if(dwCreation == OPEN_EXISTING_W)
478 os2Open = OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW;
479 else if(dwCreation == OPEN_ALWAYS_W)
480 os2Open = OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
481 else if(dwCreation == TRUNCATE_EXISTING_W)
482 os2Open = OPEN_ACTION_REPLACE_IF_EXISTS;// |OPEN_ACTION_FAIL_IF_NEW;
483
484 if(dwFlags & FILE_ATTRIBUTE_READONLY_W)
485 os2Attrib |= FILE_READONLY;
486 if(dwFlags & FILE_ATTRIBUTE_HIDDEN_W)
487 os2Attrib |= FILE_HIDDEN;
488 if(dwFlags & FILE_ATTRIBUTE_SYSTEM_W)
489 os2Attrib |= FILE_SYSTEM;
490 if(dwFlags & FILE_ATTRIBUTE_DIRECTORY_W)
491 os2Attrib |= FILE_DIRECTORY;
492 if(dwFlags & FILE_ATTRIBUTE_ARCHIVE_W)
493 os2Attrib |= FILE_ARCHIVED;
494 if(dwFlags & FILE_ATTRIBUTE_NORMAL_W)
495 os2Attrib |= FILE_NORMAL;
496
497 if(dwFlags & FILE_FLAG_WRITE_THROUGH_W)
498 os2Flags |= OPEN_FLAGS_WRITE_THROUGH;
499 if(dwFlags & FILE_FLAG_NO_BUFFERING_W)
500 os2Flags |= OPEN_FLAGS_NO_CACHE;
501 if(dwFlags & FILE_FLAG_RANDOM_ACCESS_W)
502 os2Flags |= OPEN_FLAGS_RANDOM;
503 if(dwFlags & FILE_FLAG_SEQUENTIAL_SCAN_W)
504 os2Flags |= OPEN_FLAGS_SEQUENTIAL;
505
506 // TODO:
507 // if(dwFlags & FILE_FLAG_OVERLAPPED_W)
508 // if(dwFlags & FILE_FLAG_DELETE_ON_CLOSE_W
509
510 rc = DosOpen(lpFileName, &hFile, &ulAction, 0,
511 os2Attrib, os2Open, os2Flags, 0);
512
513 if(rc)
514 {
515 // TODO: TEST TEST
516 dprintf(("DosOpen Error rc:%d, try without GENERIC_WRITE_W", rc));
517 if(dwAccess & GENERIC_WRITE_W)
518 os2Flags &= ~(OPEN_ACCESS_READWRITE | OPEN_ACCESS_WRITEONLY);
519 rc = DosOpen(lpFileName, &hFile, &ulAction, 0,
520 os2Attrib, os2Open, os2Flags, 0);
521 if(rc)
522 {
523 dprintf(("DosOpen Error rc:%d os2Attrib:%X os2Open:%X os2Flags:%X",
524 rc, os2Attrib, os2Open, os2Flags));
525 hFile = -1;
526 }
527 }
528
529 *dwFile = hFile;
530 return rc;
531}
532//******************************************************************************
533//(without changing file pointer)
534//******************************************************************************
535DWORD OSLibDosGetFileSize(DWORD hFile)
536{
537 FILESTATUS3 fsts3ConfigInfo = {{0}};
538 ULONG ulBufSize = sizeof(FILESTATUS3);
539
540 DosQueryFileInfo(hFile, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
541 return fsts3ConfigInfo.cbFile;
542}
543//******************************************************************************
544//******************************************************************************
545DWORD OSLibDosSetFilePtr2(DWORD hFile, DWORD offset, DWORD method)
546{
547 DWORD newoffset;
548 APIRET rc;
549
550
551 rc = DosSetFilePtr(hFile, offset, method, &newoffset);
552 if(rc) {
553 dprintf(("DosSetFilePtr Error rc:%d", rc));
554 return -1;
555 }
556 else return newoffset;
557}
558//******************************************************************************
559//(FlushBuffer)
560//******************************************************************************
561DWORD OSLibDosResetBuffer(DWORD hFile)
562{
563 return DosResetBuffer(hFile);
564}
565//******************************************************************************
566//******************************************************************************
567DWORD OSLibDosDupHandle(DWORD hFile, DWORD *hNew)
568{
569 *hNew = -1;
570 return DosDupHandle(hFile, hNew);
571}
572//******************************************************************************
573//******************************************************************************
574void OSLibDosDisableHardError(BOOL fTurnOff)
575{
576 DosError((fTurnOff) ? FERR_DISABLEHARDERR : FERR_ENABLEHARDERR);
577}
578//******************************************************************************
579//Returns time spent in kernel & user mode in milliseconds
580//******************************************************************************
581BOOL OSLibDosQueryProcTimes(DWORD procid, ULONG *kerneltime, ULONG *usertime)
582{
583 APIRET rc;
584 char *buf;
585 ULONG size;
586 ULONG nrthreads = 4;
587
588tryagain:
589 size = sizeof(QTOPLEVEL)+sizeof(QGLOBAL)+sizeof(QPROCESS) + nrthreads*sizeof(QTHREAD);
590 buf = (char *)malloc(size);
591 rc = DosQuerySysState(0x1, RESERVED, procid, RESERVED, (PCHAR)buf, size);
592
593 if(rc) {
594 free(buf);
595 if(rc == ERROR_BUFFER_OVERFLOW) {
596 nrthreads += 4;
597 goto tryagain;
598 }
599 return FALSE;
600 }
601 PQTOPLEVEL top = (PQTOPLEVEL)buf;
602
603 *kerneltime = 0;
604 *usertime = 0;
605 for(int i=0;i<top->procdata->threadcnt;i++) {
606 *kerneltime += top->procdata->threads[i].systime;
607 *usertime += top->procdata->threads[i].usertime;
608 }
609 free(buf);
610 return TRUE;
611}
612//******************************************************************************
613//******************************************************************************
614// TODO: implement SecurityAttributes parameter
615DWORD OSLibDosCreateNamedPipe(LPCTSTR lpName,
616 DWORD dwOpenMode,
617 DWORD dwPipeMode,
618 DWORD nMaxInstances,
619 DWORD nOutBufferSize,
620 DWORD nInBufferSize,
621 DWORD nDefaultTimeOut,
622 void* lpSecurityAttributes)
623{ DWORD dwOS2Mode = 0;
624 DWORD dwOS2PipeMode = 0;
625 LPSTR lpOS2Name;
626 DWORD hPipe;
627 DWORD rc;
628
629 if (dwOpenMode & PIPE_ACCESS_DUPLEX_W)
630 dwOS2Mode |= NP_ACCESS_DUPLEX;
631 else
632 if (dwOpenMode & PIPE_ACCESS_INBOUND_W)
633 dwOS2Mode |= NP_ACCESS_INBOUND;
634 else
635 if (dwOpenMode & PIPE_ACCESS_OUTBOUND_W)
636 dwOS2Mode |= NP_ACCESS_OUTBOUND;
637 // TODO:
638 // if(dwOpenMode & FILE_FLAG_OVERLAPPED)
639 // if(dwOpenMode & WRITE_DAC)
640 // if(dwOpenMode & WRITE_OWNER)
641 // if(dwOpenMode & ACCESS_SYSTEM_SECURITY)
642 if(dwOpenMode & FILE_FLAG_WRITE_THROUGH_W)
643 dwOS2Mode |= NP_WRITEBEHIND; // FIXME: I'm not sure!
644
645 if (dwPipeMode & PIPE_WAIT_W)
646 dwOS2PipeMode |= NP_WAIT;
647 if (dwPipeMode & PIPE_NOWAIT_W)
648 dwOS2PipeMode |= NP_NOWAIT;
649 if (dwPipeMode & PIPE_READMODE_BYTE_W)
650 dwOS2PipeMode |= NP_READMODE_BYTE;
651 if (dwPipeMode & PIPE_READMODE_MESSAGE_W)
652 dwOS2PipeMode |= NP_READMODE_MESSAGE;
653 if (dwPipeMode & PIPE_TYPE_BYTE_W)
654 dwOS2PipeMode |= NP_TYPE_BYTE;
655 if (dwPipeMode & PIPE_TYPE_MESSAGE_W)
656 dwOS2PipeMode |= NP_TYPE_MESSAGE;
657
658 if (nMaxInstances>0xff)
659 {
660 SetLastError(ERROR_INVALID_PARAMETER_W); // ERROR_INVALID_PARAMETER
661 return -1; // INVALID_HANDLE_VALUE
662 }
663 dwOS2PipeMode |= nMaxInstances;
664
665 if (strstr(lpName,"\\\\."))
666 {
667 // If pipe is created on the local machine
668 // we must delete string \\. because
669 // in Windows named pipes scheme is a \\.\PIPE\pipename
670 // but in OS/2 only \PIPE\pipename
671 lpOS2Name = (LPSTR)lpName + 3;
672 }
673 else lpOS2Name = (LPSTR)lpName;
674
675 dprintf(("DosCreateNPipe(%s,%x,%x,%x,%x,%x)",lpOS2Name,dwOS2Mode,dwOS2PipeMode,nInBufferSize,nOutBufferSize,nDefaultTimeOut));
676 rc=DosCreateNPipe(lpOS2Name,
677 &hPipe,
678 dwOS2Mode,
679 dwOS2PipeMode,
680 nInBufferSize,
681 nInBufferSize,
682 nDefaultTimeOut); // Timeouts must be tested!
683
684 dprintf(("DosCreateNPipe rc=%d",rc));
685 if (rc)
686 {
687 if ( rc == ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
688 else
689 if ( rc == ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
690 else
691 if ( rc == ERROR_NOT_ENOUGH_MEMORY ) SetLastError(ERROR_NOT_ENOUGH_MEMORY_W);
692 else
693 if ( rc == ERROR_INVALID_PARAMETER ) SetLastError(ERROR_INVALID_PARAMETER_W);
694 else
695 if ( rc == ERROR_OUT_OF_STRUCTURES ) SetLastError(ERROR_OUT_OF_STRUCTURES_W);
696 else
697 // Unknown error
698 SetLastError(ERROR_INVALID_PARAMETER_W); // fixme!
699 return -1; // INVALID_HANDLE_VALUE
700 }
701 return hPipe;
702}
703
704//******************************************************************************
705//******************************************************************************
706// TODO: implement lpOverlapped parameter!
707BOOL OSLibDosConnectNamedPipe(DWORD hNamedPipe, LPOVERLAPPED lpOverlapped)
708{
709 DWORD rc;
710
711 rc=DosConnectNPipe(hNamedPipe);
712 dprintf(("DosConnectNPipe rc=%d",rc));
713
714 if (!rc) return (TRUE);
715 else
716 if (rc==ERROR_BROKEN_PIPE) SetLastError(ERROR_BROKEN_PIPE_W);
717 else
718 if (rc==ERROR_BAD_PIPE) SetLastError(ERROR_BAD_PIPE_W);
719 else
720 if (rc==ERROR_PIPE_NOT_CONNECTED) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
721 else
722 // TODO: Implemnt this using Windows Errors
723 // if (rc==ERROR_INTERRUPT)
724 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
725
726 return (FALSE);
727}
728
729//******************************************************************************
730//******************************************************************************
731BOOL OSLibDosCallNamedPipe( LPCTSTR lpNamedPipeName,
732 LPVOID lpInBuffer,
733 DWORD nInBufferSize,
734 LPVOID lpOutBuffer,
735 DWORD nOutBufferSize,
736 LPDWORD lpBytesRead,
737 DWORD nTimeOut )
738{
739 LPSTR lpOS2Name;
740 DWORD rc;
741
742 if (strstr(lpNamedPipeName,"\\\\."))
743 {
744 // If pipe is created on the local machine
745 // we must delete string \\. because
746 // in Windows named pipes scheme is a \\.\PIPE\pipename
747 // but in OS/2 only \PIPE\pipename
748 lpOS2Name = (LPSTR)lpNamedPipeName + 3;
749 }
750 else lpOS2Name = (LPSTR)lpNamedPipeName;
751
752 rc=DosCallNPipe(lpOS2Name,
753 lpInBuffer,
754 nInBufferSize,
755 lpOutBuffer,
756 nOutBufferSize,
757 lpBytesRead,
758 nTimeOut );
759
760
761 if (!rc) return (TRUE);
762 else
763 if ( rc==ERROR_FILE_NOT_FOUND ) SetLastError(ERROR_FILE_NOT_FOUND_W);
764 else
765 if ( rc==ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
766 else
767 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
768 else
769 if ( rc==ERROR_MORE_DATA ) SetLastError(ERROR_MORE_DATA_W);
770 else
771 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
772 else
773 if ( rc==ERROR_BAD_FORMAT ) SetLastError(ERROR_BAD_FORMAT_W);
774 else
775 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
776 else
777 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
778 else
779 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
780 else
781 // TODO: Implemnt this using Windows Errors
782 // if (rc==ERROR_INTERRUPT)
783 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
784
785 return (FALSE);
786}
787
788//******************************************************************************
789//******************************************************************************
790BOOL OSLibDosTransactNamedPipe( DWORD hNamedPipe,
791 LPVOID lpInBuffer,
792 DWORD nInBufferSize,
793 LPVOID lpOutBuffer,
794 DWORD nOutBufferSize,
795 LPDWORD lpBytesRead,
796 LPOVERLAPPED lpOverlapped)
797{
798 DWORD rc;
799
800 rc=DosTransactNPipe(hNamedPipe,
801 lpOutBuffer,
802 nOutBufferSize,
803 lpInBuffer,
804 nInBufferSize,
805 lpBytesRead);
806
807 dprintf(("DosTransactNPipe returned rc=%d");)
808 if (!rc) return (TRUE);
809 else
810 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
811 else
812 if ( rc==ERROR_MORE_DATA ) SetLastError(ERROR_MORE_DATA_W);
813 else
814 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
815 else
816 if ( rc==ERROR_BAD_FORMAT ) SetLastError(ERROR_BAD_FORMAT_W);
817 else
818 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
819 else
820 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
821 else
822 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
823 else
824 // Unknown error
825 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
826
827 return (FALSE);
828}
829
830//******************************************************************************
831//******************************************************************************
832BOOL OSLibDosPeekNamedPipe(DWORD hPipe,
833 LPVOID lpvBuffer,
834 DWORD cbBuffer,
835 LPDWORD lpcbRead,
836 LPDWORD lpcbAvail,
837 LPDWORD lpcbMessage)
838{
839 DWORD rc;
840 AVAILDATA availData ={0};
841 ULONG ulDummy;
842
843 rc=DosPeekNPipe(hPipe,lpvBuffer,cbBuffer,lpcbRead,&availData,&ulDummy);
844
845 dprintf(("DosPeekNPipe returned rc=%d",rc));
846
847 if (!rc)
848 {
849 *lpcbAvail = availData.cbpipe;
850 *lpcbMessage = availData.cbmessage;
851 return (TRUE);
852 }
853 else
854 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
855 else
856 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
857 else
858 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
859 else
860 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
861 else
862 // Unknown error
863 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
864
865 return (FALSE);
866}
867//******************************************************************************
868//******************************************************************************
869BOOL OSLibDosDisconnectNamedPipe(DWORD hPipe)
870{
871 DWORD rc;
872
873 rc=DosDisConnectNPipe(hPipe);
874
875 dprintf(("DosDisConnectNPipe returned rc=%d",rc));
876
877 if (!rc) return TRUE;
878 else
879 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
880 else
881 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
882 else
883 // Unknown error
884 SetLastError(ERROR_PIPE_NOT_CONNECTED_W); // Maybe another?
885
886 return (FALSE);
887}
888//******************************************************************************
889//******************************************************************************
890BOOL OSLibDosWaitNamedPipe(LPCSTR lpszNamedPipeName,
891 DWORD dwTimeout)
892{
893 LPSTR lpOS2Name;
894 DWORD rc;
895
896 if (strstr(lpszNamedPipeName,"\\\\."))
897 {
898 // If pipe is created on the local machine
899 // we must delete string \\. because
900 // in Windows named pipes scheme is a \\.\PIPE\pipename
901 // but in OS/2 only \PIPE\pipename
902 lpOS2Name = (LPSTR)lpszNamedPipeName + 3;
903 }
904 else lpOS2Name = (LPSTR)lpszNamedPipeName;
905
906 rc=DosWaitNPipe(lpOS2Name,dwTimeout);
907
908 dprintf(("DosWaitNPipe returned rc=%d",rc));
909
910 if (!rc) return TRUE;
911 else
912 if ( rc == ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
913 else
914 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
915 else
916 if ( rc == ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
917 else
918 if ( rc == ERROR_SEM_TIMEOUT_W ) SetLastError(ERROR_SEM_TIMEOUT_W);
919 else
920 // TODO: Implemnt this using Windows Errors
921 // if (rc==ERROR_INTERRUPT)
922 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
923
924 return (FALSE);
925}
Note: See TracBrowser for help on using the repository browser.