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

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

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