source: trunk/src/win32k/api/api.cpp@ 7027

Last change on this file since 7027 was 5086, checked in by bird, 25 years ago

Moved ldrCalls.h into the OS2Krnl.h tree as OS2KLDR.h.
Also moved the Ldr definitions from OS2Krnl.h and into OS2KLDR.h.
File size: 29.4 KB
Line 
1/* $Id: api.cpp,v 1.5 2001-02-10 11:11:41 bird Exp $
2 *
3 * API Overload Init and Helper Function.
4 *
5 * Copyright (c) 2001 knut st. osmundsen (knut.stange.osmundsen@mynd.no)
6 *
7 * Project Odin Software License can be found in LICENSE.TXT
8 *
9 */
10
11/*******************************************************************************
12* Defined Constants And Macros *
13*******************************************************************************/
14#define INCL_DOSERRORS
15#define INCL_NOPMAPI
16#define INCL_OS2KRNL_ALL
17
18
19/*******************************************************************************
20* Header Files *
21*******************************************************************************/
22#include <os2.h>
23
24#include "devSegDf.h"
25#include "rmalloc.h"
26#include "new.h"
27
28#include <memory.h>
29#include <stdlib.h>
30#include <stddef.h>
31#include <string.h>
32
33#include "log.h"
34#include "OS2Krnl.h"
35#include "ldrCalls.h"
36#include "dev32.h"
37#include "api.h"
38#include "options.h"
39#include "locks.h"
40#include "sprintf.h"
41
42
43/*******************************************************************************
44* Defined Constants And Macros *
45*******************************************************************************/
46#if 1//ndef RING0
47#include <stdio.h>
48#define IOSftClose(hFile) DosClose(hFile)
49#define rmalloc malloc
50#define rrealloc realloc
51#define rfree free
52#undef kprintf
53#define kprintf(a) printf a
54#endif
55
56
57/*******************************************************************************
58* Structures and Typedefs *
59*******************************************************************************/
60typedef struct _MaskArray
61{
62 int cMasks; /* Number of elements in papszMasks. */
63 PSZ * papszMasks; /* Array of module/process masks. */
64} MASKARRAY, *PMASKARRAY;
65
66typedef struct _ApiDataEntry
67{
68 BOOL fEnabled; /* Only enabled if data was found in .INI file! */
69 MASKARRAY ProcessInc; /* Process inclusion rules. */
70 MASKARRAY ProcessExc; /* Process exclusion rules. */
71 MASKARRAY ModuleInc; /* Module inclusion rules. */
72 MASKARRAY ModuleExc; /* Module exclusion rules. */
73} APIDATAENTRY, *PAPIDATAENTRY;
74
75
76/*******************************************************************************
77* Global Variables *
78*******************************************************************************/
79APIDATAENTRY aApiData[API_CENTRIES]; /* Array of api info. */
80PSZ pszFile; /* Pointer to entire file mapping. */
81RWLOCK ApiInfoRWLock; /* Read/Write lock for api data. */
82
83
84/*******************************************************************************
85* Internal Functions *
86*******************************************************************************/
87APIRET apiReadIniFile(PSZ pszIniFile);
88APIRET apiParseIniFile(PSZ pszFile);
89PSZ apiStripIniLine(PSZ pszFile, PSZ * ppszFile);
90int apiInterpretApiNo(PSZ pszSection);
91void apiFreeApiData(PAPIDATAENTRY paNewApiData);
92void apiSortApiData(PAPIDATAENTRY paApiData);
93void apiSortMaskArray(PMASKARRAY pMasks);
94BOOL apiFindNameInMaskArray(PSZ pszName, PMASKARRAY pMasks);
95APIRET apiGetProccessName(PSZ pszName);
96APIRET apiGetModuleName(PSZ pszName, USHORT usCS, ULONG ulEIP);
97#if 1 //ndef RING0
98APIRET apiWriteIniFile(PSZ pszIniFile);
99APIRET apiWriteMasks(SFN sfn, PULONG poff, PMASKARRAY pMasks, PSZ pszType, BOOL fEnabled);
100APIRET apiWriteLine(SFN sfn, PULONG poff, PSZ pszString);
101#endif
102
103
104/**
105 * This function will read the ini file from a give disklocation.
106 * @returns OS/2 return code.
107 * @param pszIniFile Full path to the inifile.
108 * @sketch Open the file.
109 * Determin file size.
110 * Allocate memory for the file.
111 * Read the entire file.
112 * Parse the file
113 * Close the file.
114 * @status completely implemented.
115 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
116 * @remark Must hold the loader semaphore before calling this function!
117 */
118APIRET apiReadIniFile(PSZ pszIniFile)
119{
120 SFN sfn;
121 APIRET rc;
122
123 rc = IOSftOpen(pszIniFile,
124 OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
125 OPEN_SHARE_DENYWRITE | OPEN_ACCESS_READONLY,
126 (PSFN)SSToDS(&sfn),
127 NULL);
128 if (rc == NO_ERROR)
129 {
130 ULONG cbFile = 0;
131
132 rc = SftFileSize(sfn, &cbFile);
133 if (rc == NO_ERROR)
134 {
135 if (cbFile > 256*1024) /* Max size if 256 KB! */
136 {
137 rc = ERROR_NOT_ENOUGH_MEMORY;
138 kprintf(("apiReadIniFile: Files %s is too large (%d).\n", pszIniFile, cbFile));
139 }
140 else
141 {
142 PSZ pszNewFile = (PSZ)rmalloc((size_t) cbFile + 1);
143 if (pszNewFile)
144 {
145 ULONG cbRead = cbFile;
146
147 rc = IOSftReadAt(sfn, &cbRead, pszNewFile, 0UL, 0UL);
148 if (rc == NO_ERROR)
149 {
150 memset(pszNewFile + cbRead, 0, (size_t)(cbFile + 1 - cbRead)); /* terminate the file. */
151 rc = apiParseIniFile(pszNewFile);
152 }
153 else
154 kprintf(("apiReadIniFile: Failed to read %s into memory, rc=%d. (size %d)\n", pszIniFile, rc, cbFile));
155
156 if (rc != NO_ERROR)
157 rfree(pszNewFile);
158 }
159 else
160 {
161 rc = ERROR_NOT_ENOUGH_MEMORY;
162 kprintf(("apiReadIniFile: Failed to allocate %d of resident memory.\n", cbFile));
163 }
164 }
165 }
166 else
167 kprintf(("apiReadIniFile: Failed to determin size of %s, rc=%d\n", pszIniFile, rc));
168
169 IOSftClose(sfn);
170 }
171 else
172 kprintf(("apiReadIniFile: Failed to open file %s, rc=%d\n", pszIniFile, rc));
173
174 return rc;
175}
176
177
178/**
179 * Parse the inifile.
180 * @returns OS/2 return code.
181 * @param pszFile Pointer to file mapping.
182 * @sketch
183 * @status completely implemented.
184 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
185 * @remark
186 */
187APIRET apiParseIniFile(PSZ pszFile)
188{
189 PAPIDATAENTRY paNewApiData;
190 PSZ * ppszFile = (PSZ*)SSToDS(&pszFile);
191 PSZ pszLine;
192 APIRET rc;
193
194 /*
195 * Allocate and zero temporary api data structure.
196 */
197 paNewApiData = (PAPIDATAENTRY)rmalloc(sizeof(aApiData));
198 if (paNewApiData == NULL)
199 {
200 kprintf(("apiParseIniFile: failed to allocate temporary struct.\n"));
201 return ERROR_NOT_ENOUGH_MEMORY;
202 }
203 memset(paNewApiData, 0, sizeof(aApiData));
204
205 /*
206 * We'll loop until end of file.
207 * This is a double loop. Outer loop on section level. Inner loop
208 * on Type level.
209 */
210 rc = NO_ERROR;
211 pszLine = apiStripIniLine(pszFile, ppszFile);
212 while (pszLine != NULL && rc == NO_ERROR)
213 {
214 char ch;
215
216 if ((ch = *pszLine) != '\0')
217 {
218 if (ch == '[')
219 {
220 int iApi = apiInterpretApiNo(pszLine);
221 if (iApi >= 0 && iApi < API_CENTRIES)
222 {
223 PMASKARRAY pMaskArray = &paNewApiData[iApi].ModuleExc;
224
225 /*
226 * Enable api data entry.
227 * Get a line.
228 * Check for end-of-file and new section.
229 * Skip empty lines.
230 * Uppercase the line.
231 * If "Type=" line Then Change type entry.
232 * Else Add line to current type entry (default to module exclude).
233 */
234 paNewApiData[iApi].fEnabled = TRUE;
235 while ((pszLine = apiStripIniLine(pszFile, ppszFile)) != NULL
236 && *pszLine != '[')
237 {
238 if (*pszLine == '\0')
239 continue;
240 strupr(pszLine);
241 if (strcmp("TYPE=", pszLine) == 0)
242 {
243 pszLine += 5;
244 if (strstr(pszLine, "PROC"))
245 pMaskArray = strstr(pszLine, "INC")
246 ? &paNewApiData[iApi].ProcessInc
247 : &paNewApiData[iApi].ProcessExc; /* default */
248 else
249 pMaskArray = strstr(pszLine, "INC")
250 ? &paNewApiData[iApi].ModuleInc
251 : &paNewApiData[iApi].ModuleExc; /* default */
252 if (strstr(pszLine, "DIS"))
253 paNewApiData[iApi].fEnabled = FALSE;
254 }
255 else
256 {
257 if (pMaskArray->cMasks % 8 == 0)
258 {
259 void *pv = rrealloc(pMaskArray->papszMasks, 8 + pMaskArray->cMasks);
260 if (pv == NULL)
261 {
262 rc = ERROR_NOT_ENOUGH_MEMORY;
263 kprintf(("apiParseIniFile: Failed to allocate more mask array memory. %c masks\n", pMaskArray->cMasks));
264 break;
265 }
266 pMaskArray->papszMasks = (PSZ*)pv;
267 }
268 pMaskArray->papszMasks[pMaskArray->cMasks++] = pszLine;
269 }
270 } /* inner loop */
271 }
272 else
273 {
274 kprintf(("apiParseIniFile: bogus api no.%d (%s)\n", iApi, pszLine));
275 pszLine = apiStripIniLine(pszFile, ppszFile);
276 }
277 }
278 else
279 {
280 kprintf(("apiParseIniFile: bogus line encountered: %s\n", pszLine));
281 pszLine = apiStripIniLine(pszFile, ppszFile);
282 }
283 }
284 else
285 pszLine = apiStripIniLine(pszFile, ppszFile);
286 } /* outer loop */
287
288
289 /*
290 * If we were successfull we'll replace the existing api data with
291 * the data we've just read.
292 * If not we'll free any used memory before returning failure.
293 */
294 if (rc == NO_ERROR)
295 {
296 apiSortApiData(paNewApiData);
297 RWLockAcquireWrite(&ApiInfoRWLock);
298 apiFreeApiData(&aApiData[0]);
299 memcpy(&aApiData[0], paNewApiData, sizeof(aApiData));
300 RWLockReleaseWrite(&ApiInfoRWLock);
301 }
302 else
303 apiFreeApiData(paNewApiData);
304 rfree(paNewApiData);
305
306 return rc;
307}
308
309
310
311/**
312 * Strips and extract a line advancing the *ppszFile pointer to
313 * the next line. Comments are also stripped.
314 * @returns Pointer to line. NULL if end of file.
315 * @param pszFile Pointer to line.
316 * @param ppszFile Pointer to pointer variable.
317 * @sketch
318 * @status completly implemented.
319 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
320 */
321PSZ apiStripIniLine(PSZ pszFile, PSZ * ppszFile)
322{
323 PSZ pszComment;
324 PSZ pszLine;
325 char ch;
326
327 /*
328 * If end of file Then return NULL.
329 */
330 if (*pszFile)
331 return NULL;
332
333 /*
334 * Strip start of line.
335 */
336 while ((ch = *pszFile) == ' ' || ch == '\t')
337 pszFile++;
338 pszLine = pszFile;
339
340 /*
341 * Look for the line end and any evt. comment (starts with a ';').
342 */
343 pszComment = NULL;
344 while ((ch = *pszFile) != '\r' && ch != '\n' && ch != '\0')
345 {
346 if (ch == ';')
347 pszComment = pszFile;
348 pszFile++;
349 }
350
351 /*
352 * Update pszComment with the line end if not already set (we'll
353 * use this pointer to right strip the line).
354 * If not last line, then terminate the line.
355 * Skip return and newline characters to position the *ppszFile pointer
356 * at the next line.
357 * Update the next line pointer.
358 */
359 if (pszComment == NULL)
360 pszComment = pszFile;
361 if (ch != '\0')
362 {
363 *pszFile = '\0';
364 while ((ch = *pszFile) == '\r' || ch == '\n')
365 pszFile++;
366 }
367 *ppszFile = pszFile;
368
369 /*
370 * Right strip the line (starts with pszComment).
371 */
372 pszComment--;
373 while ((ch = *pszComment) == ' ' || ch == '\t')
374 pszComment--;
375 pszComment[1] = '\0';
376
377 return pszLine;
378}
379
380
381/**
382 * Reads the section header '[<ApiNbr]' and translates it into an
383 * api index (into aApiData). Range is not checked.
384 * @returns API index. -1 on error. Check range!
385 * @param pszSection Pointer to the section header string.
386 * Assumes that it's pointing to the '['.
387 * @sketch Skip '['.
388 * Skip blanks.
389 * Convert decimal number string and return it.
390 * @status completely implemented.
391 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
392 * @remark Layz, we only read '[n' no checking for the ending ']'.
393 */
394int apiInterpretApiNo(PSZ pszSection)
395{
396 int iApi = 0;
397
398 pszSection++; /* skip '[' */
399 if (*pszSection < '0' || *pszSection > '9')
400 return -1;
401
402 while (*pszSection == ' ' || *pszSection == '\t')
403 pszSection++;
404
405 while (*pszSection >= '0' || *pszSection <= '9')
406 {
407 iApi = (iApi * 10) + *pszSection - '0';
408 pszSection++;
409 }
410
411 return iApi;
412}
413
414
415/**
416 * Sort the entire api data structure.
417 * @param paApiData Pointer to api data to sort.
418 * @sketch Loop thru all entries and sort all four mask arrays.
419 * @status completely implemented.
420 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
421 * @remark See apiSortMaskArray.
422 */
423void apiSortApiData(PAPIDATAENTRY paApiData)
424{
425 int i;
426
427 for (i = 0; i < API_CENTRIES; i++)
428 {
429 apiSortMaskArray(&paApiData[i].ProcessInc);
430 apiSortMaskArray(&paApiData[i].ProcessExc);
431 apiSortMaskArray(&paApiData[i].ModuleInc);
432 apiSortMaskArray(&paApiData[i].ModuleExc);
433 }
434}
435
436
437/**
438 * Sorts the content of an mask array.
439 * Duplicates are removed.
440 * @param pMasks Pointer to a mask array structure.
441 * @sketch Use bouble sort.
442 * @status partially implemented.
443 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
444 * @remark Duplicate submasks aren't tested for.
445 * example: "DOSCALL1.DLL" is equal to "DOS*"
446 */
447void apiSortMaskArray(PMASKARRAY pMasks)
448{
449 int i;
450 PSZ pszTmp;
451
452 do
453 {
454 for (i = 1, pszTmp = NULL; i < pMasks->cMasks; i++)
455 {
456 int iDiff = strcmp(pMasks->papszMasks[i], pMasks->papszMasks[i-1]);
457 if (iDiff == 0)
458 { /* remove entry */
459 memmove(&pMasks->papszMasks[i], &pMasks->papszMasks[i+1],
460 (pMasks->cMasks - i - 1) * sizeof(pMasks->papszMasks[0]));
461 i--;
462 }
463 else if (iDiff < 0)
464 { /* Swap entries. */
465 PSZ pszTmp = pMasks->papszMasks[i];
466 pMasks->papszMasks[i] = pMasks->papszMasks[i-1];
467 pMasks->papszMasks[i-1] = pszTmp;
468 }
469 }
470 } while (pszTmp != NULL);
471}
472
473
474/**
475 * Frees internal data in a api data structure.
476 * @param paApiData Pointer to api data table.
477 * @sketch Loop thru all api entries and free mask array pointers.
478 * @status Completely implemented.
479 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
480 * @remark Any serialization is not my problem.
481 */
482void apiFreeApiData(PAPIDATAENTRY paApiData)
483{
484 int i;
485
486 for (i = 0; i < API_CENTRIES; i++)
487 {
488 if (paApiData[i].ProcessInc.cMasks)
489 rfree(paApiData[i].ProcessInc.papszMasks);
490 if (paApiData[i].ProcessExc.cMasks)
491 rfree(paApiData[i].ProcessExc.papszMasks);
492 if (paApiData[i].ModuleInc.cMasks)
493 rfree(paApiData[i].ModuleInc.papszMasks);
494 if (paApiData[i].ModuleExc.cMasks)
495 rfree(paApiData[i].ModuleExc.papszMasks);
496 }
497}
498
499#if 1 //ndef RING0
500/**
501 * Write the internal data to a fresh ini file.
502 * This is a service routine used by the configuration program.
503 * @returns OS/2 return code.
504 * @param pszIniFile Pointer to the name of the ini file.
505 * @sketch
506 * @status
507 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
508 * @remark
509 */
510APIRET apiWriteIniFile(PSZ pszIniFile)
511{
512 SFN sfn;
513 APIRET rc;
514
515
516 rc = IOSftOpen(pszIniFile,
517 OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
518 OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_WRITEONLY,
519 (PSFN)SSToDS(&sfn),
520 NULL);
521 if (rc == NO_ERROR)
522 {
523 int i;
524 ULONG off = 0;
525 PULONG poff = (PULONG)SSToDS(&off);
526 char sz[80];
527 PSZ psz = (PSZ)SSToDS(&sz[0]);
528
529 for (i = 0; i < API_CENTRIES; i++)
530 {
531 sprintf(psz, "[%d]", i);
532 if ((rc = apiWriteLine(sfn, poff, psz)) != NO_ERROR)
533 break;
534
535 rc = apiWriteMasks(sfn, poff, &aApiData[i].ProcessExc, "Process Exclude", aApiData[i].fEnabled);
536 if (rc != NO_ERROR)
537 break;
538
539 if (aApiData[i].ProcessInc.cMasks)
540 {
541 rc = apiWriteMasks(sfn, poff, &aApiData[i].ProcessInc, "Process Include", TRUE);
542 if (rc != NO_ERROR)
543 break;
544 }
545
546 if (aApiData[i].ModuleExc.cMasks)
547 {
548 rc = apiWriteMasks(sfn, poff, &aApiData[i].ModuleExc, "Module Exclude", TRUE);
549 if (rc != NO_ERROR)
550 break;
551 }
552
553 if (aApiData[i].ModuleInc.cMasks)
554 {
555 rc = apiWriteMasks(sfn, poff, &aApiData[i].ModuleInc, "Module Include", TRUE);
556 if (rc != NO_ERROR)
557 break;
558 }
559 rc = apiWriteLine(sfn, poff, "");
560 }
561
562 IOSftClose(sfn);
563 }
564 else
565 kprintf(("apiWriteIniFile: Failed open %s for write. rc=%d\n", pszIniFile, rc));
566
567 return rc;
568}
569
570
571/**
572 * Writes the content of a mask array to the ini file.
573 * @returns OS/2 return code.
574 * @param sfn File handle. (sfn = System File Number)
575 * @param poff Pointer to the file offset variable.
576 * (We're required to keep track of the current offset due to
577 * the IOSftWriteAt function.)
578 * @param pMasks Pointer to the mask array struct to be written to file.
579 * @param pszType Type string for these masks.
580 * @param fEnabled If the api entry is enabled or not.
581 * @status completely implemented.
582 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
583 */
584APIRET apiWriteMasks(SFN sfn, PULONG poff, PMASKARRAY pMasks, PSZ pszType, BOOL fEnabled)
585{
586 char sz[48];
587 PSZ psz = (PSZ)SSToDS(&sz[0]);
588 APIRET rc = NO_ERROR;
589 int i;
590
591 if (fEnabled)
592 sprintf(psz, "Type=%s", pszType);
593 else
594 sprintf(psz, "Type=%s Disabled", pszType);
595 rc = apiWriteLine(sfn, poff, psz);
596 if (rc != NO_ERROR)
597 return rc;
598
599 for (i = 0, rc = NO_ERROR; rc == NO_ERROR && i < pMasks->cMasks; i++)
600 rc = apiWriteLine(sfn, poff, pMasks->papszMasks[i]);
601
602 return rc;
603}
604
605
606/**
607 * Writes a string to the file and advances to the next line.
608 * @returns OS/2 return code.
609 * @param sfn File handle. (sfn = System File Number)
610 * @param poff Pointer to the file offset variable.
611 * (We're required to keep track of the current offset due to
612 * the IOSftWriteAt function.)
613 * @param pszString String to be written.
614 * @status completely implemented.
615 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
616 */
617APIRET apiWriteLine(SFN sfn, PULONG poff, PSZ pszString)
618{
619 ULONG cb = strlen(pszString);
620 APIRET rc;
621
622 rc = IOSftWriteAt(sfn, &cb, pszString, 0UL, *poff);
623 if (rc == NO_ERROR)
624 {
625 *poff += cb;
626 cb = 2;
627 rc = IOSftWriteAt(sfn, &cb, "\r\n", 0UL, *poff);
628 if (rc == NO_ERROR)
629 *poff += cb;
630 }
631
632 return rc;
633}
634
635
636/**
637 * Opens a given file.
638 * @returns NO_ERROR on success. OS/2 error code on error.
639 * @param pszFilename Pointer to filename.
640 * @param flOpenFlags Open flags. (similar to DosOpen)
641 * @param flOpenMode Open mode flags. (similar to DosOpen)
642 * @param phFile Pointer to filehandle.
643 * @param pulsomething 16-bit near (?) pointer to a variable - unknown. NULL is allowed. EA?
644 */
645APIRET KRNLCALL IOSftOpen(
646 PSZ pszFilename,
647 ULONG flOpenFlags,
648 ULONG flOpenMode,
649 PSFN phFile,
650 PULONG pulsomething
651 )
652{
653 APIRET rc;
654 ULONG ulAction = 0;
655
656 rc = DosOpen(pszFilename, phFile, &ulAction, 0, 0, flOpenFlags, flOpenMode, NULL);
657
658 pulsomething = pulsomething;
659 return rc;
660}
661
662/**
663 * Read at a given offset in the a file.
664 * @returns NO_ERROR on success. OS/2 error code on error.
665 * @param hFile File handle - System File Number.
666 * @param pcbActual Pointer to variable which upon input holds the number
667 * of bytes to read, on output the actual number of bytes read.
668 * @param pvBuffer Pointer to the read buffer.
669 * @param flFlags Read flags?
670 * @param ulOffset File offset to read from. (0=start of file)
671 */
672APIRET KRNLCALL IOSftReadAt(
673 SFN hFile,
674 PULONG pcbActual,
675 PVOID pvBuffer,
676 ULONG flFlags,
677 ULONG ulOffset)
678{
679 APIRET rc;
680 ULONG ul;
681 rc = DosSetFilePtr(hFile, ulOffset, FILE_BEGIN, &ul);
682 if (rc == NO_ERROR)
683 rc = DosRead(hFile, pvBuffer, *pcbActual, pcbActual);
684 flFlags = flFlags;
685 return rc;
686}
687
688
689/**
690 * Write at a given offset in the a file.
691 * @returns NO_ERROR on success. OS/2 error code on error.
692 * @param hFile File handle - System File Number.
693 * @param pcbActual Pointer to variable which upon input holds the number
694 * of bytes to write, on output the actual number of bytes write.
695 * @param pvBuffer Pointer to the write buffer.
696 * @param flFlags Read flags?
697 * @param ulOffset File offset to write from. (0=start of file)
698 */
699APIRET KRNLCALL IOSftWriteAt(
700 SFN hFile,
701 PULONG pcbActual,
702 PVOID pvBuffer,
703 ULONG flFlags,
704 ULONG ulOffset)
705{
706 APIRET rc;
707 ULONG ul;
708 rc = DosSetFilePtr(hFile, ulOffset, FILE_BEGIN, &ul);
709 if (rc == NO_ERROR)
710 rc = DosWrite(hFile, pvBuffer, *pcbActual, pcbActual);
711 flFlags = flFlags;
712 return rc;
713}
714
715/**
716 * Gets the filesize.
717 * @returns NO_ERROR on success; OS/2 error code on error.
718 * @param hFile File handle - System File Number.
719 * @param pcbFile Pointer to ULONG which will hold the file size upon return.
720 */
721APIRET KRNLCALL SftFileSize(
722 SFN hFile,
723 PULONG pcbFile)
724{
725 FILESTATUS3 fsts3;
726 APIRET rc;
727
728 rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fsts3, sizeof(fsts3));
729 if (rc == NO_ERROR)
730 *pcbFile = fsts3.cbFile;
731 return rc;
732}
733
734#endif
735
736/**
737 * Searches a mask array if there is any match for the given name.
738 * @returns TRUE if found.
739 * FALSE if not found.
740 * @param pszName Pointer to name.
741 * @param pMasks Pointer to mask array.
742 * @sketch
743 * @status
744 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
745 * @remark
746 */
747BOOL apiFindNameInMaskArray(PSZ pszName, PMASKARRAY pMasks)
748{
749 return FALSE;
750}
751
752
753#ifdef RING0
754/**
755 * Get the current process executable name.
756 * @returns OS/2 return code.
757 * @param pszName Pointer to output name buffer.
758 * @sketch Get current ptda.
759 * Get module handle (hmte) from current ptda.
760 * Get pmte and smte from the hmte.
761 * Check if there is any path (full filename).
762 * Parse out filename+ext from full filename and copy it to pszName.
763 * return.
764 * @status completely implemented.
765 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
766 */
767APIRET apiGetProccessName(PSZ pszName)
768{
769 PPTDA pPTDA = ptdaGetCur();
770 if (pPTDA)
771 {
772 HMTE hmte = ptdaGet_ptda_module(pPTDA);
773 if (hmte)
774 {
775 PMTE pmte = ldrASMpMTEFromHandle(hmte);
776 PSMTE psmte;
777 if ( pmte
778 && (psmte = pmte->mte_swapmte)
779 && psmte->smte_path
780 && *psmte->smte_path)
781 {
782 /*
783 * Get executable name from swap mte.
784 * We parse out the filename+ext and copies it to the output buffer.
785 */
786 PCHAR psz;
787 PCHAR pszExt;
788 ldrGetFileName2(psmte->smte_path, (PCHAR*)SSToDS(&psz), (PCHAR*)SSToDS(&pszExt));
789 if (!psz) psz = psmte->smte_path;
790 strcpy(pszName, psz);
791 return NO_ERROR;
792 }
793 else
794 kprintf(("apiGetProcessName: failed to get pmte(0x%08x) from hmte(0x%04x) or no path.\n", pmte, hmte));
795 }
796 else
797 kprintf(("apiGetProcessName: This PTDA has no module handle. (pptda=0x%08x, hptda=0x%04)\n", pPTDA, ptdaGet_ptda_handle(pPTDA)));
798 }
799 else
800 kprintf(("apiGetProcessName: No current PTDA!\n"));
801
802 return ERROR_INVALID_PARAMETER;
803}
804
805/**
806 * Gets the module name from a given CS:EIP pair.
807 * @returns OS/2 return code.
808 * @param pszName Output buffer.
809 * @param usCS CS (code segment).
810 * @param ulEIP EIP (Extended Instruction Pointer).
811 * @sketch Get hmte from cs:eip.
812 * Get pmte and smte from the hmte.
813 * Check if there is any path (full filename).
814 * Parse out filename+ext from full filename and copy it to pszName.
815 * return.
816 * @status completely implemented.
817 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
818 */
819APIRET apiGetModuleName(PSZ pszName, USHORT usCS, ULONG ulEIP)
820{
821 HMTE hmte = VMGetOwner(usCS, ulEIP);
822 if (hmte)
823 {
824 PMTE pmte = ldrASMpMTEFromHandle(hmte);
825 PSMTE psmte;
826 if ( pmte
827 && (psmte = pmte->mte_swapmte)
828 && psmte->smte_path
829 && *psmte->smte_path)
830 {
831 /*
832 * Get executable name from swap mte.
833 * We parse out the filename+ext and copies it to the output buffer.
834 */
835 PCHAR psz;
836 PCHAR pszExt;
837 ldrGetFileName2(psmte->smte_path, (PCHAR*)SSToDS(&psz), (PCHAR*)SSToDS(&pszExt));
838 if (!psz) psz = psmte->smte_path;
839 strcpy(pszName, psz);
840 return NO_ERROR;
841 }
842 else
843 kprintf(("apiGetModuleName: failed to get pmte(0x%08x) from hmte(0x%04x) or no path.\n", pmte, hmte));
844 }
845 else
846 kprintf(("apiGetModuleName: failed to get hmte from cs=%04x eip=%08x\n", usCS, ulEIP));
847
848 /*
849 * We failed.
850 */
851 return ERROR_INVALID_PARAMETER;
852}
853
854
855
856/**
857 * Checks if an api enhancement is enabled for this process or/and module.
858 * Exclusion lists rulez over inclusion.
859 * Excluded processes rulez over included modules.
860 * @returns TRUE (!0) if it's enabled.
861 * FALSE (0) if it's disabled.
862 * @param iApi Api data id/index.
863 * @param usCS CS of the API caller.
864 * @param ulEIP EIP of the API caller.
865 * @sketch
866 * @status
867 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
868 * @remark
869 */
870BOOL _Optlink APIQueryEnabled(int iApi, USHORT usCS, LONG ulEIP)
871{
872 PAPIDATAENTRY pEntry;
873
874 /*
875 * Check if these enhancements are switched off globally.
876 */
877 if (isApiEnhDisabled())
878 return FALSE;
879
880 /*
881 * Aquire read lock.
882 */
883 RWLockAcquireRead(&ApiInfoRWLock);
884
885 /*
886 * Get data entry pointer.
887 * Check if entry is enabled.
888 */
889 BOOL fRet = FALSE;
890 pEntry = &aApiData[iApi];
891 if (pEntry->fEnabled)
892 {
893 CHAR szName[CCHMAXPATH];
894 PSZ pszName = (PSZ)SSToDS(&szName[0]);
895
896 if (pEntry->ProcessExc.cMasks > 0 || pEntry->ProcessInc.cMasks > 0)
897 {
898 if (!apiGetProccessName(pszName))
899 { /* TODO - fix this priority - it's probably wrong */
900 if (pEntry->ProcessExc.cMasks)
901 fRet = !apiFindNameInMaskArray(pszName, &pEntry->ProcessExc);
902 else if (pEntry->ProcessInc.cMasks)
903 fRet = apiFindNameInMaskArray(pszName, &pEntry->ProcessInc);
904 }
905 }
906
907 if ( !pEntry->ProcessExc.cMasks
908 && !fRet
909 && (pEntry->ModuleExc.cMasks > 0 || pEntry->ModuleInc.cMasks > 0))
910 {
911 if (!apiGetModuleName(pszName, usCS, ulEIP))
912 { /* TODO - fix this priority - it's probably wrong */
913 if (pEntry->ModuleExc.cMasks)
914 fRet = !apiFindNameInMaskArray(pszName, &pEntry->ModuleExc);
915 else if (pEntry->ProcessInc.cMasks)
916 fRet = apiFindNameInMaskArray(pszName, &pEntry->ModuleInc);
917 }
918 }
919 }
920
921
922 /*
923 * Release read lock.
924 */
925 RWLockReleaseRead(&ApiInfoRWLock);
926
927 return fRet;
928}
929
930
931/**
932 * Init The Api Overloading SubSystem.
933 * @returns OS/2 return code.
934 * @sketch Find Ini file location.
935 * Read the inifile and there by initiate the aApiData strcut.
936 * @status completly implemented.
937 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
938 */
939APIRET _Optlink APIInit(void)
940{
941 APIRET rc;
942
943 rc = apiReadIniFile(&szWin32kIni[0]);
944
945 return rc;
946}
947#endif
948
Note: See TracBrowser for help on using the repository browser.