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

Last change on this file since 2652 was 2535, checked in by sandervl, 26 years ago

added fs check export
File size: 28.3 KB
Line 
1/* $Id: oslibdos.cpp,v 1.17 2000-01-27 21:51:17 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 <win32type.h>
23#include <winconst.h>
24#include <misc.h>
25#include "initterm.h"
26#include "oslibdos.h"
27#include "dosqss.h"
28
29/***********************************
30 * PH: fixups for missing os2win.h *
31 ***********************************/
32
33void _System SetLastError(ULONG ulError);
34
35APIRET APIENTRY DosAliasMem(PVOID pb, ULONG cb, PPVOID ppbAlias, ULONG fl);
36
37//******************************************************************************
38//TODO: Assumes entire memory range has the same protection flags!
39//TODO: Check if this works for code aliases...
40//******************************************************************************
41DWORD OSLibDosAliasMem(LPVOID pb, ULONG cb, LPVOID *ppbAlias, ULONG fl)
42{
43 DWORD rc;
44 DWORD attr;
45 DWORD size = cb;
46
47 cb = (cb-1) & ~0xfff;
48 cb+= PAGE_SIZE;
49
50 rc = DosQueryMem(pb, &size, &attr);
51 if(rc) {
52 dprintf(("OSLibDosAliasMem: DosQueryMem %x %x return %d", pb, size, rc));
53 return rc;
54 }
55 size = (size-1) & ~0xfff;
56 size+= PAGE_SIZE;
57 if(size != cb) {
58 dprintf(("ERROR: OSLibDosAliasMem: size != cb (%x!=%x)!!!!!!!!", size, cb));
59 //ignore this and continue return 5;
60 attr = fl; //just use original protection flags (NOT CORRECT)
61 }
62 attr &= (PAG_READ|PAG_WRITE|PAG_EXECUTE|PAG_GUARD|PAG_DEFAULT);
63 if(attr != fl) {
64 rc = DosSetMem(pb, size, fl);
65 if(rc) {
66 dprintf(("OSLibDosAliasMem: DosSetMem %x %x return %d", pb, size, rc));
67 attr = fl;
68 //just continue for now
69 //return rc;
70 }
71 }
72 rc = DosAliasMem(pb, cb, ppbAlias, 2);
73 if(rc) {
74 dprintf(("OSLibDosAliasMem: DosAliasMem %x %x returned %d", pb, cb, rc));
75 return rc;
76 }
77 if(attr != fl) {
78 rc = DosSetMem(pb, size, attr);
79 if(rc) {
80 dprintf(("OSLibDosAliasMem: DosSetMem (2) %x %x return %d", pb, size, rc));
81 return rc;
82 }
83 }
84 return 0;
85}
86//******************************************************************************
87//NT returns addresses aligned at 64k, so we do too.
88//******************************************************************************
89DWORD OSLibDosAllocMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags)
90{
91 LPVOID memaddr;
92 DWORD offset;
93 APIRET rc;
94
95 rc = DosAllocMem(&memaddr, size, PAG_READ | flAllocMem);
96 if(rc) {
97 return rc;
98 }
99 DosEnterCritSec();
100 DosFreeMem(memaddr);
101 offset = (DWORD)memaddr & 0xFFFF;
102 if(offset) {
103 DosAllocMem(&memaddr, 64*1024 - offset, PAG_READ | flAllocMem);
104 }
105 rc = DosAllocMem(lplpMemAddr, size, flags | flAllocMem);
106 DosExitCritSec();
107 if((DWORD)*lplpMemAddr & 0xFFFF) {//still not at 64k boundary?
108 DosFreeMem(*lplpMemAddr);
109 rc = OSLibDosAllocMem(lplpMemAddr, size, flags);
110 }
111 if(offset) {
112 DosFreeMem(memaddr);
113 }
114
115 return rc;
116}
117//******************************************************************************
118//******************************************************************************
119DWORD OSLibDosFreeMem(LPVOID lpMemAddr)
120{
121 return DosFreeMem(lpMemAddr);
122}
123//******************************************************************************
124//NOTE: If name == NULL, allocated gettable unnamed shared memory
125//******************************************************************************
126DWORD OSLibDosAllocSharedMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags, LPSTR name)
127{
128 APIRET rc;
129 char *sharedmemname = NULL;
130
131 if(name) {
132 sharedmemname = (char *)malloc(strlen(name) + 16);
133 strcpy(sharedmemname, "\\SHAREMEM\\");
134 strcat(sharedmemname, name);
135 }
136 else flags |= OBJ_GETTABLE;
137
138 rc = DosAllocSharedMem(lplpMemAddr, sharedmemname, size, flags);
139 if(name) {
140 free(sharedmemname);
141 }
142 return rc;
143}
144//******************************************************************************
145//NOTE: If name == NULL, assume gettable unnamed shared memory
146//******************************************************************************
147DWORD OSLibDosGetNamedSharedMem(LPVOID *lplpMemAddr, LPSTR name)
148{
149 APIRET rc;
150 char *sharedmemname = NULL;
151
152 if(name) {
153 sharedmemname = (char *)malloc(strlen(name) + 16);
154 strcpy(sharedmemname, "\\SHAREMEM\\");
155 strcat(sharedmemname, name);
156 rc = DosGetNamedSharedMem(lplpMemAddr, sharedmemname, PAG_READ|PAG_WRITE);
157 if(name) {
158 free(sharedmemname);
159 }
160 }
161 else rc = DosGetSharedMem((LPVOID)*(DWORD *)lplpMemAddr, PAG_READ|PAG_WRITE);
162
163 return rc;
164}
165//******************************************************************************
166//******************************************************************************
167DWORD OSLibDosQueryMem(LPVOID lpMemAddr, DWORD *lpRangeSize, DWORD *lpAttr)
168{
169 return DosQueryMem(lpMemAddr, lpRangeSize, lpAttr);
170}
171//******************************************************************************
172//******************************************************************************
173DWORD OSLibDosSetMem(LPVOID lpMemAddr, DWORD size, DWORD flags)
174{
175 APIRET rc;
176
177 rc = DosSetMem(lpMemAddr, size, flags);
178 switch(rc) {
179 case ERROR_INVALID_ADDRESS:
180 return OSLIB_ERROR_INVALID_ADDRESS;
181 case ERROR_ACCESS_DENIED:
182 return OSLIB_ERROR_ACCESS_DENIED;
183 default:
184 return rc;
185 }
186}
187//******************************************************************************
188//******************************************************************************
189DWORD OSLibDosOpen(char *lpszFileName, DWORD flags)
190{
191 APIRET rc;
192 HFILE hFile;
193 ULONG ulAction;
194 DWORD os2flags = OPEN_FLAGS_NOINHERIT;
195
196
197 if(flags & OSLIB_ACCESS_READONLY)
198 os2flags |= OPEN_ACCESS_READONLY;
199 else
200 if(flags & OSLIB_ACCESS_READWRITE)
201 os2flags |= OPEN_ACCESS_READWRITE;
202
203 if(flags & OSLIB_ACCESS_SHAREDENYNONE)
204 os2flags |= OPEN_SHARE_DENYNONE;
205 else
206 if(flags & OSLIB_ACCESS_SHAREDENYREAD)
207 os2flags |= OPEN_SHARE_DENYREAD;
208 else
209 if(flags & OSLIB_ACCESS_SHAREDENYWRITE)
210 os2flags |= OPEN_SHARE_DENYWRITE;
211
212tryopen:
213 rc = DosOpen(lpszFileName, /* File path name */
214 &hFile, /* File handle */
215 &ulAction, /* Action taken */
216 0L, /* File primary allocation */
217 0L, /* File attribute */
218 OPEN_ACTION_FAIL_IF_NEW |
219 OPEN_ACTION_OPEN_IF_EXISTS, /* Open function type */
220 os2flags,
221 0L); /* No extended attribute */
222
223 if(rc) {
224 if(rc == ERROR_TOO_MANY_OPEN_FILES) {
225 ULONG CurMaxFH;
226 LONG ReqCount = 32;
227
228 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
229 if(rc) {
230 dprintf(("DosSetRelMaxFH returned %d", rc));
231 return 0;
232 }
233 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
234 goto tryopen;
235 }
236 return 0;
237 }
238 else return hFile;
239}
240//******************************************************************************
241//******************************************************************************
242DWORD OSLibDosClose(DWORD hFile)
243{
244 return DosClose(hFile);
245}
246//******************************************************************************
247//******************************************************************************
248DWORD OSLibDosRead(DWORD hFile, LPVOID lpBuffer, DWORD size, DWORD *nrBytesRead)
249{
250 return DosRead(hFile, lpBuffer, size, nrBytesRead);
251}
252//******************************************************************************
253//******************************************************************************
254DWORD OSLibDosWrite(DWORD hFile, LPVOID lpBuffer, DWORD size, DWORD *nrBytesWritten)
255{
256 return DosWrite(hFile, lpBuffer, size, nrBytesWritten);
257}
258//******************************************************************************
259//******************************************************************************
260DWORD OSLibDosSetFilePtr(DWORD hFile, DWORD offset, DWORD method)
261{
262 DWORD os2method;
263 DWORD newoffset;
264 APIRET rc;
265
266 switch(method) {
267 case OSLIB_SETPTR_FILE_CURRENT:
268 os2method = FILE_CURRENT;
269 break;
270 case OSLIB_SETPTR_FILE_BEGIN:
271 os2method = FILE_BEGIN ;
272 break;
273 case OSLIB_SETPTR_FILE_END:
274 os2method = FILE_END;
275 break;
276 default:
277 return OSLIB_ERROR_INVALID_PARAMETER;
278 }
279 rc = DosSetFilePtr(hFile, offset, os2method, &newoffset);
280 if(rc) {
281 return -1;
282 }
283 else return newoffset;
284}
285//******************************************************************************
286//******************************************************************************
287//@@@PH Note: this routine is nothing but a QUICK'N'DIRTY HACK!
288//@@@PH this function should be implemented accordingly to NTDLL's
289// RtlSecondsSince1980ToTime
290// RtlTimeToSecondsSince1980
291static void iFDATEFTIME2FILETIME(FDATE fdOS2, FTIME ftOS2, LPFILETIME pftWin32)
292{
293 float f;
294 #define facSECOND 2 // as encoded in OS/2
295 #define facMINUTE 60
296 #define facHOUR 3600
297 #define facDAY 86400
298 #define facMONTH facDAY * 30 // cough, cough :)
299 #define facYEAR facDAY * 365
300
301 /* pftWin32 is 100ns based from 01.01.1601 00:00:00 */
302 f = (fdOS2.year + 379) * facYEAR // 1980 - 1601
303 + (fdOS2.month - 0 ) * facMONTH
304 + (fdOS2.day - 1 ) * facDAY
305 + (ftOS2.hours ) * facHOUR
306 + (ftOS2.minutes ) * facMINUTE
307 + (ftOS2.twosecs ) * facSECOND;
308
309 f *= 10000; // convert to 100ns base
310 pftWin32->dwHighDateTime = (f / (float)(0xffffffff) );
311 pftWin32->dwLowDateTime = (f - (float)((float)pftWin32->dwHighDateTime *
312 (float)0xffffffff) );
313}
314
315BOOL OSLibDosGetFileAttributesEx(PSZ pszName,
316 ULONG ulDummy,
317 PVOID pBuffer)
318{
319 APIRET rc; /* API return code */
320 FILESTATUS3 fs3; /* file information structure */
321 LPWIN32_FILE_ATTRIBUTE_DATA lpFad = (LPWIN32_FILE_ATTRIBUTE_DATA) pBuffer;
322
323 // Note: we only handle standard "GetFileExInfoStandard" requests
324 rc = DosQueryPathInfo(pszName, /* query the file information */
325 FIL_STANDARD,
326 &fs3,
327 sizeof(fs3));
328 if (rc != NO_ERROR) /* check for errors */
329 return FALSE; /* raise error condition */
330
331 // convert structure
332 lpFad->dwFileAttributes = fs3.attrFile; // directly interchangeable
333 iFDATEFTIME2FILETIME(fs3.fdateCreation, fs3.ftimeCreation, &lpFad->ftCreationTime);
334 iFDATEFTIME2FILETIME(fs3.fdateLastAccess, fs3.ftimeLastAccess, &lpFad->ftLastAccessTime);
335 iFDATEFTIME2FILETIME(fs3.fdateLastWrite, fs3.ftimeLastWrite, &lpFad->ftLastWriteTime);
336
337 /* @@@PH we might add Aurora support ...
338 lpFad->nFileSizeHigh = info.nFileSizeHigh;
339 */
340 lpFad->nFileSizeHigh = 0;
341 lpFad->nFileSizeLow = fs3.cbFile;
342
343 return TRUE;
344}
345//******************************************************************************
346//******************************************************************************
347DWORD OSLibDosSearchPath(DWORD cmd, char *path, char *name, char *full_name,
348 DWORD length_fullname)
349{
350 switch(cmd) {
351 case OSLIB_SEARCHDIR:
352 if(DosSearchPath(SEARCH_IGNORENETERRS, path,
353 name, full_name, length_fullname) != 0) {
354 return 0;
355 }
356 return strlen(full_name);
357
358
359 case OSLIB_SEARCHCURDIR:
360 if(DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_CUR_DIRECTORY, path,
361 name, full_name, length_fullname) != 0) {
362 return 0;
363 }
364 return strlen(full_name);
365
366 case OSLIB_SEARCHFILE:
367 {
368 FILESTATUS3 fileinfo;
369
370 if(DosQueryPathInfo(name, FIL_STANDARD, &fileinfo, sizeof(fileinfo)) != 0) {
371 return 0;
372 }
373 strncpy(full_name, name, length_fullname);
374 return strlen(full_name);
375 }
376
377 case OSLIB_SEARCHENV:
378 {
379 if(DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_ENVIRONMENT, path,
380 name, full_name, length_fullname) != 0) {
381 return 0;
382 }
383 return strlen(full_name);
384 }
385 }
386 return 0;
387}
388//******************************************************************************
389//******************************************************************************
390DWORD OSLibDosCreate(CHAR *lpFileName,
391 DWORD dwAccess,
392 DWORD dwShare,
393 LPSECURITY_ATTRIBUTES lpSecurityAttributes,
394 DWORD dwCreation,
395 DWORD dwFlags,
396 HANDLE hTemplate,
397 DWORD *dwFile)
398{
399 APIRET rc;
400 HFILE hFile;
401 ULONG ulAction=0;
402 DWORD os2Attrib=0;
403 DWORD os2Flags = 0; //OPEN_FLAGS_NOINHERIT;
404 DWORD os2Open=0;
405
406 if(dwAccess == (GENERIC_READ_W | GENERIC_WRITE_W))
407 os2Flags |= OPEN_ACCESS_READWRITE;
408 else if(dwAccess & GENERIC_WRITE_W)
409 os2Flags |= OPEN_ACCESS_WRITEONLY;
410 else if(dwAccess & GENERIC_READ_W)
411 os2Flags |= OPEN_ACCESS_READONLY;
412
413 if(dwShare == 0)
414 os2Flags |= OPEN_SHARE_DENYREADWRITE;
415 else if(dwShare == (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W))
416 os2Flags |= OPEN_SHARE_DENYNONE;
417 else if(dwShare & FILE_SHARE_READ_W)
418 os2Flags |= OPEN_SHARE_DENYWRITE;
419 else if(dwShare & FILE_SHARE_WRITE_W)
420 os2Flags |= OPEN_SHARE_DENYREAD;
421
422 if(dwCreation == CREATE_NEW_W)
423 os2Open = OPEN_ACTION_FAIL_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
424 else if(dwCreation == CREATE_ALWAYS_W)
425 os2Open = OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
426 else if(dwCreation == OPEN_EXISTING_W)
427 os2Open = OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW;
428 else if(dwCreation == OPEN_ALWAYS_W)
429 os2Open = OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
430 else if(dwCreation == TRUNCATE_EXISTING_W)
431 os2Open = OPEN_ACTION_REPLACE_IF_EXISTS;// |OPEN_ACTION_FAIL_IF_NEW;
432
433 if(dwFlags & FILE_ATTRIBUTE_READONLY_W)
434 os2Attrib |= FILE_READONLY;
435 if(dwFlags & FILE_ATTRIBUTE_HIDDEN_W)
436 os2Attrib |= FILE_HIDDEN;
437 if(dwFlags & FILE_ATTRIBUTE_SYSTEM_W)
438 os2Attrib |= FILE_SYSTEM;
439 if(dwFlags & FILE_ATTRIBUTE_DIRECTORY_W)
440 os2Attrib |= FILE_DIRECTORY;
441 if(dwFlags & FILE_ATTRIBUTE_ARCHIVE_W)
442 os2Attrib |= FILE_ARCHIVED;
443 if(dwFlags & FILE_ATTRIBUTE_NORMAL_W)
444 os2Attrib |= FILE_NORMAL;
445
446 if(dwFlags & FILE_FLAG_WRITE_THROUGH_W)
447 os2Flags |= OPEN_FLAGS_WRITE_THROUGH;
448 if(dwFlags & FILE_FLAG_NO_BUFFERING_W)
449 os2Flags |= OPEN_FLAGS_NO_CACHE;
450 if(dwFlags & FILE_FLAG_RANDOM_ACCESS_W)
451 os2Flags |= OPEN_FLAGS_RANDOM;
452 if(dwFlags & FILE_FLAG_SEQUENTIAL_SCAN_W)
453 os2Flags |= OPEN_FLAGS_SEQUENTIAL;
454
455 // TODO:
456 // if(dwFlags & FILE_FLAG_OVERLAPPED_W)
457 // if(dwFlags & FILE_FLAG_DELETE_ON_CLOSE_W
458
459 rc = DosOpen(lpFileName, &hFile, &ulAction, 0,
460 os2Attrib, os2Open, os2Flags, 0);
461
462 if(rc)
463 {
464 // TODO: TEST TEST
465 dprintf(("DosOpen Error rc:%d, try without GENERIC_WRITE_W", rc));
466 if(dwAccess & GENERIC_WRITE_W)
467 os2Flags &= ~(OPEN_ACCESS_READWRITE | OPEN_ACCESS_WRITEONLY);
468 rc = DosOpen(lpFileName, &hFile, &ulAction, 0,
469 os2Attrib, os2Open, os2Flags, 0);
470 if(rc)
471 {
472 dprintf(("DosOpen Error rc:%d os2Attrib:%X os2Open:%X os2Flags:%X",
473 rc, os2Attrib, os2Open, os2Flags));
474 hFile = -1;
475 }
476 }
477
478 *dwFile = hFile;
479 return rc;
480}
481//******************************************************************************
482//(without changing file pointer)
483//******************************************************************************
484DWORD OSLibDosGetFileSize(DWORD hFile)
485{
486 FILESTATUS3 fsts3ConfigInfo = {{0}};
487 ULONG ulBufSize = sizeof(FILESTATUS3);
488
489 DosQueryFileInfo(hFile, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
490 return fsts3ConfigInfo.cbFile;
491}
492//******************************************************************************
493//******************************************************************************
494DWORD OSLibDosSetFilePtr2(DWORD hFile, DWORD offset, DWORD method)
495{
496 DWORD newoffset;
497 APIRET rc;
498
499
500 rc = DosSetFilePtr(hFile, offset, method, &newoffset);
501 if(rc) {
502 dprintf(("DosSetFilePtr Error rc:%d", rc));
503 return -1;
504 }
505 else return newoffset;
506}
507//******************************************************************************
508//(FlushBuffer)
509//******************************************************************************
510DWORD OSLibDosResetBuffer(DWORD hFile)
511{
512 return DosResetBuffer(hFile);
513}
514//******************************************************************************
515//******************************************************************************
516DWORD OSLibDosDupHandle(DWORD hFile, DWORD *hNew)
517{
518 *hNew = -1;
519 return DosDupHandle(hFile, hNew);
520}
521//******************************************************************************
522//******************************************************************************
523void OSLibDosDisableHardError(BOOL fTurnOff)
524{
525 DosError((fTurnOff) ? FERR_DISABLEHARDERR : FERR_ENABLEHARDERR);
526}
527//******************************************************************************
528//Returns time spent in kernel & user mode in milliseconds
529//******************************************************************************
530BOOL OSLibDosQueryProcTimes(DWORD procid, ULONG *kerneltime, ULONG *usertime)
531{
532 APIRET rc;
533 char *buf;
534 ULONG size;
535 ULONG nrthreads = 4;
536
537tryagain:
538 size = sizeof(QTOPLEVEL)+sizeof(QGLOBAL)+sizeof(QPROCESS) + nrthreads*sizeof(QTHREAD);
539 buf = (char *)malloc(size);
540 rc = DosQuerySysState(0x1, RESERVED, procid, RESERVED, (PCHAR)buf, size);
541
542 if(rc) {
543 free(buf);
544 if(rc == ERROR_BUFFER_OVERFLOW) {
545 nrthreads += 4;
546 goto tryagain;
547 }
548 return FALSE;
549 }
550 PQTOPLEVEL top = (PQTOPLEVEL)buf;
551
552 *kerneltime = 0;
553 *usertime = 0;
554 for(int i=0;i<top->procdata->threadcnt;i++) {
555 *kerneltime += top->procdata->threads[i].systime;
556 *usertime += top->procdata->threads[i].usertime;
557 }
558 free(buf);
559 return TRUE;
560}
561//******************************************************************************
562//******************************************************************************
563// TODO: implement SecurityAttributes parameter
564DWORD OSLibDosCreateNamedPipe(LPCTSTR lpName,
565 DWORD dwOpenMode,
566 DWORD dwPipeMode,
567 DWORD nMaxInstances,
568 DWORD nOutBufferSize,
569 DWORD nInBufferSize,
570 DWORD nDefaultTimeOut,
571 void* lpSecurityAttributes)
572{ DWORD dwOS2Mode = 0;
573 DWORD dwOS2PipeMode = 0;
574 LPSTR lpOS2Name;
575 DWORD hPipe;
576 DWORD rc;
577
578 if (dwOpenMode & PIPE_ACCESS_DUPLEX_W)
579 dwOS2Mode |= NP_ACCESS_DUPLEX;
580 else
581 if (dwOpenMode & PIPE_ACCESS_INBOUND_W)
582 dwOS2Mode |= NP_ACCESS_INBOUND;
583 else
584 if (dwOpenMode & PIPE_ACCESS_OUTBOUND_W)
585 dwOS2Mode |= NP_ACCESS_OUTBOUND;
586 // TODO:
587 // if(dwOpenMode & FILE_FLAG_OVERLAPPED)
588 // if(dwOpenMode & WRITE_DAC)
589 // if(dwOpenMode & WRITE_OWNER)
590 // if(dwOpenMode & ACCESS_SYSTEM_SECURITY)
591 if(dwOpenMode & FILE_FLAG_WRITE_THROUGH_W)
592 dwOS2Mode |= NP_WRITEBEHIND; // FIXME: I'm not sure!
593
594 if (dwPipeMode & PIPE_WAIT_W)
595 dwOS2PipeMode |= NP_WAIT;
596 if (dwPipeMode & PIPE_NOWAIT_W)
597 dwOS2PipeMode |= NP_NOWAIT;
598 if (dwPipeMode & PIPE_READMODE_BYTE_W)
599 dwOS2PipeMode |= NP_READMODE_BYTE;
600 if (dwPipeMode & PIPE_READMODE_MESSAGE_W)
601 dwOS2PipeMode |= NP_READMODE_MESSAGE;
602 if (dwPipeMode & PIPE_TYPE_BYTE_W)
603 dwOS2PipeMode |= NP_TYPE_BYTE;
604 if (dwPipeMode & PIPE_TYPE_MESSAGE_W)
605 dwOS2PipeMode |= NP_TYPE_MESSAGE;
606
607 if (nMaxInstances>0xff)
608 {
609 SetLastError(87); // ERROR_INVALID_PARAMETER
610 return -1; // INVALID_HANDLE_VALUE
611 }
612 dwOS2PipeMode |= nMaxInstances;
613
614 if (strstr(lpName,"\\\\."))
615 {
616 // If pipe is created on the local machine
617 // we must delete string \\. because
618 // in Windows named pipes scheme is a \\.\PIPE\pipename
619 // but in OS/2 only \PIPE\pipename
620 lpOS2Name = (LPSTR)lpName + 3;
621 }
622 else lpOS2Name = (LPSTR)lpName;
623
624 dprintf(("DosCreateNPipe(%s,%x,%x,%x,%x,%x)",lpOS2Name,dwOS2Mode,dwOS2PipeMode,nInBufferSize,nOutBufferSize,nDefaultTimeOut));
625 rc=DosCreateNPipe(lpOS2Name,
626 &hPipe,
627 dwOS2Mode,
628 dwOS2PipeMode,
629 nInBufferSize,
630 nInBufferSize,
631 nDefaultTimeOut); // Timeouts must be tested!
632
633 dprintf(("DosCreateNPipe rc=%d",rc));
634 if (rc)
635 {
636 if ( rc == ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
637 else
638 if ( rc == ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
639 else
640 if ( rc == ERROR_NOT_ENOUGH_MEMORY ) SetLastError(ERROR_NOT_ENOUGH_MEMORY_W);
641 else
642 if ( rc == ERROR_INVALID_PARAMETER ) SetLastError(ERROR_INVALID_PARAMETER_W);
643 else
644 if ( rc == ERROR_OUT_OF_STRUCTURES ) SetLastError(ERROR_OUT_OF_STRUCTURES_W);
645 else
646 // Unknown error
647 SetLastError(ERROR_INVALID_PARAMETER_W); // fixme!
648 return -1; // INVALID_HANDLE_VALUE
649 }
650 return hPipe;
651}
652
653//******************************************************************************
654//******************************************************************************
655// TODO: implement lpOverlapped parameter!
656BOOL OSLibDosConnectNamedPipe(DWORD hNamedPipe, LPOVERLAPPED lpOverlapped)
657{
658 DWORD rc;
659
660 rc=DosConnectNPipe(hNamedPipe);
661 dprintf(("DosConnectNPipe rc=%d",rc));
662
663 if (!rc) return (TRUE);
664 else
665 if (rc==ERROR_BROKEN_PIPE) SetLastError(ERROR_BROKEN_PIPE_W);
666 else
667 if (rc==ERROR_BAD_PIPE) SetLastError(ERROR_BAD_PIPE_W);
668 else
669 if (rc==ERROR_PIPE_NOT_CONNECTED) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
670 else
671 // TODO: Implemnt this using Windows Errors
672 // if (rc==ERROR_INTERRUPT)
673 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
674
675 return (FALSE);
676}
677
678//******************************************************************************
679//******************************************************************************
680BOOL OSLibDosCallNamedPipe( LPCTSTR lpNamedPipeName,
681 LPVOID lpInBuffer,
682 DWORD nInBufferSize,
683 LPVOID lpOutBuffer,
684 DWORD nOutBufferSize,
685 LPDWORD lpBytesRead,
686 DWORD nTimeOut )
687{
688 LPSTR lpOS2Name;
689 DWORD rc;
690
691 if (strstr(lpNamedPipeName,"\\\\."))
692 {
693 // If pipe is created on the local machine
694 // we must delete string \\. because
695 // in Windows named pipes scheme is a \\.\PIPE\pipename
696 // but in OS/2 only \PIPE\pipename
697 lpOS2Name = (LPSTR)lpNamedPipeName + 3;
698 }
699 else lpOS2Name = (LPSTR)lpNamedPipeName;
700
701 rc=DosCallNPipe(lpOS2Name,
702 lpInBuffer,
703 nInBufferSize,
704 lpOutBuffer,
705 nOutBufferSize,
706 lpBytesRead,
707 nTimeOut );
708
709
710 if (!rc) return (TRUE);
711 else
712 if ( rc==ERROR_FILE_NOT_FOUND ) SetLastError(ERROR_FILE_NOT_FOUND_W);
713 else
714 if ( rc==ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
715 else
716 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
717 else
718 if ( rc==ERROR_MORE_DATA ) SetLastError(ERROR_MORE_DATA_W);
719 else
720 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
721 else
722 if ( rc==ERROR_BAD_FORMAT ) SetLastError(ERROR_BAD_FORMAT_W);
723 else
724 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
725 else
726 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
727 else
728 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
729 else
730 // TODO: Implemnt this using Windows Errors
731 // if (rc==ERROR_INTERRUPT)
732 SetLastError(233);
733
734 return (FALSE);
735}
736
737//******************************************************************************
738//******************************************************************************
739BOOL OSLibDosTransactNamedPipe( DWORD hNamedPipe,
740 LPVOID lpInBuffer,
741 DWORD nInBufferSize,
742 LPVOID lpOutBuffer,
743 DWORD nOutBufferSize,
744 LPDWORD lpBytesRead,
745 LPOVERLAPPED lpOverlapped)
746{
747 DWORD rc;
748
749 rc=DosTransactNPipe(hNamedPipe,
750 lpOutBuffer,
751 nOutBufferSize,
752 lpInBuffer,
753 nInBufferSize,
754 lpBytesRead);
755
756 dprintf(("DosTransactNPipe returned rc=%d");)
757 if (!rc) return (TRUE);
758 else
759 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
760 else
761 if ( rc==ERROR_MORE_DATA ) SetLastError(ERROR_MORE_DATA_W);
762 else
763 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
764 else
765 if ( rc==ERROR_BAD_FORMAT ) SetLastError(ERROR_BAD_FORMAT_W);
766 else
767 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
768 else
769 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
770 else
771 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
772 else
773 // Unknown error
774 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
775
776 return (FALSE);
777}
778
779//******************************************************************************
780//******************************************************************************
781BOOL OSLibDosPeekNamedPipe(DWORD hPipe,
782 LPVOID lpvBuffer,
783 DWORD cbBuffer,
784 LPDWORD lpcbRead,
785 LPDWORD lpcbAvail,
786 LPDWORD lpcbMessage)
787{
788 DWORD rc;
789 AVAILDATA availData ={0};
790 ULONG ulDummy;
791
792 rc=DosPeekNPipe(hPipe,lpvBuffer,cbBuffer,lpcbRead,&availData,&ulDummy);
793
794 dprintf(("DosPeekNPipe returned rc=%d",rc));
795
796 if (!rc)
797 {
798 *lpcbAvail = availData.cbpipe;
799 *lpcbMessage = availData.cbmessage;
800 return (TRUE);
801 }
802 else
803 if ( rc==ERROR_ACCESS_DENIED ) SetLastError(ERROR_ACCESS_DENIED_W);
804 else
805 if ( rc==ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
806 else
807 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
808 else
809 if ( rc==ERROR_PIPE_NOT_CONNECTED ) SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
810 else
811 // Unknown error
812 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
813
814 return (FALSE);
815}
816//******************************************************************************
817//******************************************************************************
818BOOL OSLibDosDisconnectNamedPipe(DWORD hPipe)
819{
820 DWORD rc;
821
822 rc=DosDisConnectNPipe(hPipe);
823
824 dprintf(("DosDisConnectNPipe returned rc=%d",rc));
825
826 if (!rc) return TRUE;
827 else
828 if ( rc==ERROR_BROKEN_PIPE ) SetLastError(ERROR_BROKEN_PIPE_W);
829 else
830 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
831 else
832 // Unknown error
833 SetLastError(ERROR_PIPE_NOT_CONNECTED_W); // Maybe another?
834
835 return (FALSE);
836}
837//******************************************************************************
838//******************************************************************************
839BOOL OSLibDosWaitNamedPipe(LPCSTR lpszNamedPipeName,
840 DWORD dwTimeout)
841{
842 LPSTR lpOS2Name;
843 DWORD rc;
844
845 if (strstr(lpszNamedPipeName,"\\\\."))
846 {
847 // If pipe is created on the local machine
848 // we must delete string \\. because
849 // in Windows named pipes scheme is a \\.\PIPE\pipename
850 // but in OS/2 only \PIPE\pipename
851 lpOS2Name = (LPSTR)lpszNamedPipeName + 3;
852 }
853 else lpOS2Name = (LPSTR)lpszNamedPipeName;
854
855 rc=DosWaitNPipe(lpOS2Name,dwTimeout);
856
857 dprintf(("DosWaitNPipe returned rc=%d",rc));
858
859 if (!rc) return TRUE;
860 else
861 if ( rc == ERROR_PATH_NOT_FOUND ) SetLastError(ERROR_PATH_NOT_FOUND_W);
862 else
863 if ( rc==ERROR_BAD_PIPE ) SetLastError(ERROR_BAD_PIPE_W);
864 else
865 if ( rc == ERROR_PIPE_BUSY ) SetLastError(ERROR_PIPE_BUSY_W);
866 else
867 if ( rc == ERROR_SEM_TIMEOUT_W ) SetLastError(ERROR_SEM_TIMEOUT_W);
868 else
869 // TODO: Implemnt this using Windows Errors
870 // if (rc==ERROR_INTERRUPT)
871 SetLastError(ERROR_PIPE_NOT_CONNECTED_W);
872
873 return (FALSE);
874}
Note: See TracBrowser for help on using the repository browser.