Changeset 1845


Ignore:
Timestamp:
Aug 12, 2015, 9:54:49 PM (10 years ago)
Author:
John Small
Message:

Ticket #524: Ensure no "highmem-unsafe" functions are called directly
1) New functions have been added
2) Code for unsafe-but-not-yet-used-by-FM/2 has been added in an

"#if 0" block in wrappers.c for quick implementation should FM/2 start to use them.
Among these. xDosOpenL and xWinUpper still need work. The rest are ready for use.

Location:
trunk/dll
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/wrappers.c

    r1839 r1845  
    66  Wrappers with error checking
    77
    8   Copyright (c) 2006, 2015 Steven H.Levine
     8  Copyright (c) 2006, 2008 Steven H.Levine
    99
    1010  22 Jul 06 SHL Baseline
    … …  
    2323  09 Oct 11 GKY Modify xfsopen so it doesn't fail when called with r+ because the file doesn't exist.
    2424                We should be creating the file unless it is set to fail silently.
    25   09 Aug 15 SHL Add xDosGetInfoBlocks
     25  12 Aug 15 JBS Ticket #524: Ensure no "highmem-unsafe" functions are called directly
     26                1) New functions have been added
     27                2) Code for unsafe-but-not-yet-used-by-FM/2 has been added in an
     28                   "#if 0" block for quick implementation should FM/2 start to use them.
     29                   Among these. xDosOpenL and xWinUpper still need work. The rest are ready for use.
    2630
    2731***********************************************************************/
    … …  
    6064BOOL fNoLargeFileSupport;
    6165
    62 APIRET xDosQueryAppType(PCSZ pszName, PULONG pFlags)
     66APIRET xDosDupHandle(HFILE hFile,
     67                     PHFILE phFile)
     68{
     69  APIRET        rc;
     70  HFILE         hFileLow = *phFile;
     71
     72  rc = DosDupHandle(hFile, &hFileLow);
     73  *phFile = hFileLow;
     74  return rc;
     75}
     76
     77APIRET xDosForceDelete(PSZ pszFileName)
     78{
     79  APIRET        rc;
     80  CHAR szFileNameLow[CCHMAXPATH];
     81
     82  strcpy(szFileNameLow, pszFileName);
     83  rc = DosForceDelete(szFileNameLow);
     84  return rc;
     85}
     86
     87APIRET xDosQueryAppType(PCSZ pszName,
     88                        PULONG pFlags)
    6389{
    6490  APIRET rc;
     91  ULONG ulFlagsLow;
    6592  CHAR szPgm[CCHMAXPATH];
    6693
    6794  strcpy(szPgm, pszName);
    68   rc = DosQueryAppType(szPgm, pFlags);
    69   return rc;
    70 }
    71 
     95  rc = DosQueryAppType(szPgm, &ulFlagsLow);
     96  *pFlags = ulFlagsLow;
     97  return rc;
     98}
     99
     100APIRET xDosQueryHType(HFILE hFile,
     101                      PULONG pulType,
     102                      PULONG pulAttr)
     103{
     104  APIRET        rc;
     105  ULONG         ulTypeLow, ulAttrLow;
     106
     107  rc = DosQueryHType(hFile, &ulTypeLow, &ulAttrLow);
     108  *pulType = ulTypeLow;
     109  *pulAttr = ulAttrLow;
     110  return rc;
     111}
     112
     113APIRET xDosStartSession(PSTARTDATA psd,
     114                        PULONG pulSessionID,
     115                        PPID ppid)
     116{
     117  APIRET        rc;
     118  ULONG         ulSessionIDLow;
     119  PID           pidLow;
     120  PSTARTDATA    psdLow;
     121  CHAR          *pbSafe;
     122  size_t        cbSafe = sizeof(STARTDATA);
     123  UINT          ul0, ul1, ul2, ul3, ul4, ul5;
     124
     125  if (HIGH_MEMORY_ADDRESS(psd->PgmTitle))
     126  {
     127    ul0 = strlen((const char *)psd->PgmTitle) + 1;
     128    cbSafe += ul0;
     129  }
     130  else
     131      ul0 = 0;
     132  if (HIGH_MEMORY_ADDRESS(psd->PgmName))
     133  {
     134    ul1 = strlen((const char *)psd->PgmName) + 1;
     135    cbSafe += ul1;
     136  }
     137  else
     138      ul1 = 0;
     139  if (HIGH_MEMORY_ADDRESS(psd->TermQ))
     140  {
     141    ul2 = strlen((const char *)psd->TermQ) + 1;
     142    cbSafe += ul2;
     143  }
     144  else
     145    ul2 = 0;
     146  if (HIGH_MEMORY_ADDRESS(psd->PgmInputs))
     147  {
     148    ul3 = strlen((const char *)psd->PgmInputs) + 1;
     149    cbSafe += ul3;
     150  }
     151  else
     152    ul3= 0;
     153  if (HIGH_MEMORY_ADDRESS(psd->Environment))
     154  {
     155    const char *psz = (const char *)psd->Environment;
     156    while (*psz)
     157        psz = strchr(psz, '\0') + 1;
     158    ul4 = (unsigned int *)psz - (unsigned int *)psd->Environment + 1;
     159    cbSafe += ul4;
     160  }
     161  else
     162    ul4 = 0;
     163  if (HIGH_MEMORY_ADDRESS(psd->IconFile))
     164  {
     165    ul5 = strlen((const char *)psd->IconFile) + 1;
     166    cbSafe += ul5;
     167  }
     168  else
     169    ul5 = 0;
     170  if (HIGH_MEMORY_ADDRESS(psd->ObjectBuffer) && psd->ObjectBuffLen)
     171    cbSafe += psd->ObjectBuffLen;
     172
     173  rc = xDosAllocMemLow((void *)&psdLow,
     174                       cbSafe,
     175                       pszSrcFile,
     176                       __LINE__);
     177  if (rc)
     178    return ERROR_NOT_ENOUGH_MEMORY;
     179
     180  memcpy((PVOID)psdLow, (PVOID)psd, sizeof(STARTDATA));
     181  pbSafe = (CHAR *)psdLow + sizeof(STARTDATA);
     182  if (ul0)
     183  {
     184    memcpy(pbSafe, psd->PgmTitle, ul0);
     185    psdLow->PgmTitle = pbSafe;
     186    pbSafe += ul0;
     187  }
     188  if (ul1)
     189  {
     190    memcpy(pbSafe, psd->PgmName, ul1);
     191    psdLow->PgmName = pbSafe;
     192    pbSafe += ul1;
     193  }
     194  if (ul2)
     195  {
     196    memcpy(pbSafe, psd->TermQ, ul2);
     197    psdLow->TermQ = (UCHAR *)pbSafe;
     198    pbSafe += ul2;
     199  }
     200  if (ul3)
     201  {
     202    memcpy(pbSafe, psd->PgmInputs, ul3);
     203    psdLow->PgmInputs = (UCHAR *)pbSafe;
     204    pbSafe += ul3;
     205  }
     206  if (ul4)
     207  {
     208    memcpy(pbSafe, psd->Environment, ul4);
     209    psdLow->Environment = (UCHAR *)pbSafe;
     210    pbSafe += ul4;
     211  }
     212  if (ul5)
     213  {
     214    memcpy(pbSafe, psd->IconFile, ul5);
     215    psdLow->IconFile = pbSafe;
     216    pbSafe += ul5;
     217  }
     218  if (HIGH_MEMORY_ADDRESS(psd->ObjectBuffer) && psd->ObjectBuffLen)
     219    psdLow->ObjectBuffer = pbSafe;
     220
     221  rc = DosStartSession(psdLow,
     222                       pulSessionID ? &ulSessionIDLow : NULL,
     223                       ppid ? &pidLow : NULL);
     224
     225  /* Set return values */
     226  if (HIGH_MEMORY_ADDRESS(psd->ObjectBuffer) && psd->ObjectBuffLen)
     227    memcpy(psd->ObjectBuffer, psdLow->ObjectBuffer, psd->ObjectBuffLen);
     228  if (pulSessionID)
     229    *pulSessionID = ulSessionIDLow;
     230  if (ppid)
     231    *ppid = pidLow;
     232
     233  /* cleanup and return. */
     234  xfree(psdLow, pszSrcFile, __LINE__);
     235  return rc;
     236}
     237
     238
     239//
     240//      "Other" wrapper functions
     241//
    72242/**
    73243 * xDosAllocSharedMem uses OBJ_ANY on systems that support high memory use
    … …  
    83253                          UINT uiLineNumber)
    84254{
    85   APIRET rc; ;
     255  APIRET rc;
    86256
    87257  rc = DosAllocSharedMem(ppb, pszName, cb,
    … …  
    313483 * that cross a 64K boundary.
    314484 * When this occurs, they return ERROR_INVALID_NAME.
     485 *
    315486 * This code works around the problem because if the passed buffer crosses
    316487 * the boundary the alternate buffer will not because both are on the stack
    317488 * and we don't put enough additional data on the stack for this to occur.
     489 *
    318490 * It is caller's responsitibility to report errors
    319491 * @param pInfoBuf pointer to FILESTATUS3(L) or EAOP2 buffer
    … …  
    328500                       ULONG flOptions)
    329501{
    330     FILESTATUS3 fs3;
    331     FILESTATUS3 fs3_a;
    332     FILESTATUS3L fs3l;
    333     EAOP2 eaop2;
    334     APIRET rc;
    335     BOOL crosses = ((ULONG)pInfoBuf ^
    336                     ((ULONG)pInfoBuf + cbInfoBuf - 1)) & ~0xffff;
    337     BOOL fResetVerify = FALSE;
    338 
    339     if (fVerify && driveflags[toupper(*pszPathName) - 'A'] & DRIVE_WRITEVERIFYOFF) {
    340       DosSetVerify(FALSE);
    341       fResetVerify = TRUE;
    342     }
    343     switch (ulInfoLevel) {
    344       case FIL_STANDARD:
    345         if (crosses) {
    346           fs3 = *(PFILESTATUS3)pInfoBuf;        // Copy to buffer that does not cross 64K boundary
    347           rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3, cbInfoBuf, flOptions);
    348         }
    349         else
    350           rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
    351         break;
    352 
    353       case FIL_STANDARDL:
    354         if (fNoLargeFileSupport) {
    355           ulInfoLevel = FIL_STANDARD;
    356           fs3 = *(PFILESTATUS3)pInfoBuf;        // Copy aligned data
    357           // Check size too big to handle
    358           if (((PFILESTATUS3L)pInfoBuf)->cbFile >= 1LL << 32 ||
    359               ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc >= 2LL << 32)
    360           {
    361             rc = ERROR_INVALID_PARAMETER;
    362           }
    363           else {
    364             fs3.cbFile = ((PFILESTATUS3L)pInfoBuf)->cbFile;     // Copy unaligned data
    365             fs3.cbFileAlloc = ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc;
    366             fs3.attrFile = ((PFILESTATUS3L)pInfoBuf)->attrFile;
    367             rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3, sizeof(fs3), flOptions);
    368           }
    369           if (rc == ERROR_INVALID_NAME) {
    370             // fixme to validate counts?
    371             fs3_a = fs3;                // Copy to buffer that does not cross
    372             rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3_a, sizeof(fs3_a), flOptions);
    373           }
     502  FILESTATUS3 fs3;
     503  FILESTATUS3 fs3_a;
     504  FILESTATUS3L fs3l;
     505  EAOP2 eaop2;
     506  APIRET rc;
     507  BOOL crosses = ((ULONG)pInfoBuf ^
     508                  ((ULONG)pInfoBuf + cbInfoBuf - 1)) & ~0xffff;
     509  BOOL fResetVerify = FALSE;
     510
     511  if (fVerify && driveflags[toupper(*pszPathName) - 'A'] & DRIVE_WRITEVERIFYOFF) {
     512    DosSetVerify(FALSE);
     513    fResetVerify = TRUE;
     514  }
     515  switch (ulInfoLevel) {
     516    case FIL_STANDARD:
     517      if (crosses) {
     518        fs3 = *(PFILESTATUS3)pInfoBuf;  // Copy to buffer that does not cross 64K boundary
     519        rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3, cbInfoBuf, flOptions);
     520      }
     521      else
     522             rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
     523      break;
     524
     525    case FIL_STANDARDL:
     526      if (fNoLargeFileSupport) {
     527        ulInfoLevel = FIL_STANDARD;
     528        fs3 = *(PFILESTATUS3)pInfoBuf;  // Copy aligned data
     529        // Check size too big to handle
     530        if (((PFILESTATUS3L)pInfoBuf)->cbFile >= 1LL << 32 ||
     531            ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc >= 2LL << 32)
     532        {
     533          rc = ERROR_INVALID_PARAMETER;
    374534        }
    375535        else {
    376           rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
    377           if (rc == ERROR_INVALID_NAME) {
    378             fs3l = *(PFILESTATUS3L)pInfoBuf;    // Copy to buffer that does not cross
    379             rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3l, sizeof(fs3l), flOptions);
    380           }
     536          fs3.cbFile = ((PFILESTATUS3L)pInfoBuf)->cbFile;       // Copy unaligned data
     537          fs3.cbFileAlloc = ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc;
     538          fs3.attrFile = ((PFILESTATUS3L)pInfoBuf)->attrFile;
     539          rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3, sizeof(fs3), flOptions);
    381540        }
    382         break;
    383       case FIL_QUERYEASIZE:
     541        if (rc == ERROR_INVALID_NAME) {
     542          // fixme to validate counts?
     543          fs3_a = fs3;          // Copy to buffer that does not cross
     544          rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3_a, sizeof(fs3_a), flOptions);
     545        }
     546      }
     547      else {
    384548        rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
    385549        if (rc == ERROR_INVALID_NAME) {
    386           // fixme to validate counts?
    387           eaop2 = *(PEAOP2)pInfoBuf;    // Copy to buffer that does not cross
    388           rc = DosSetPathInfo(pszPathName, ulInfoLevel, &eaop2, sizeof(eaop2), flOptions);
     550          fs3l = *(PFILESTATUS3L)pInfoBuf;      // Copy to buffer that does not cross
     551          rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3l, sizeof(fs3l), flOptions);
    389552        }
    390         break;
    391       default:
    392         Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
    393         rc = ERROR_INVALID_PARAMETER;
    394     } // switch
    395     if (fResetVerify) {
    396       DosSetVerify(fVerify);
    397       fResetVerify = FALSE;
    398     }
    399     return rc;
     553      }
     554      break;
     555    case FIL_QUERYEASIZE:
     556      rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
     557      if (rc == ERROR_INVALID_NAME) {
     558        // fixme to validate counts?
     559        eaop2 = *(PEAOP2)pInfoBuf;      // Copy to buffer that does not cross
     560        rc = DosSetPathInfo(pszPathName, ulInfoLevel, &eaop2, sizeof(eaop2), flOptions);
     561      }
     562      break;
     563    default:
     564      Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
     565      rc = ERROR_INVALID_PARAMETER;
     566  } // switch
     567  if (fResetVerify) {
     568    DosSetVerify(fVerify);
     569    fResetVerify = FALSE;
     570  }
     571  return rc;
    400572}
    401573
    … …  
    556728}
    557729
     730#if 0
     731/*
     732 * JBS: Wrappers for functions which...
     733 *      - are identified by klibc as "highmem-unsafe"
     734 *      - not yet used by FM/2
     735 */
     736
     737// .H code for these functions
     738// The following are ready to go.
     739APIRET xDosCreatePipe(PHFILE phfReadHandle,
     740                      PHFILE phfWriteHandle,
     741                      ULONG ulPipeSize);
     742
     743APIRET xDosQueryFHState(HFILE hFile,
     744                        PULONG pulMode);
     745
     746#ifdef INCL_DOSNMPIPES
     747APIRET xDosQueryNPHState(HPIPE hpipe,
     748                         PULONG pulState);
     749#endif
     750
     751APIRET xDosSetDateTime(DATETIME *pdt);
     752
     753APIRET xDosSetFilePtr(HFILE hFile,
     754                      LONG lOffset,
     755                      ULONG ulOrigin,
     756                      PULONG pulPos);
     757
     758APIRET xDosSetFilePtrL(HFILE hFile,
     759                       LONGLONG llOffset,
     760                       ULONG ulOrigin,
     761                       PLONGLONG pllPos);
     762
     763#ifdef INCL_DOSPROCESS
     764APIRET xDosWaitChild(ULONG ulAction,
     765                     ULONG ulWait,
     766                     PRESULTCODES pReturnCodes,
     767                     PPID ppidOut,
     768                     PID pidIn);
     769#endif
     770
     771APIRET xDosWaitNPipe(PCSZ pszName,
     772                     ULONG ulTimeout);
     773
     774// The following functions still need work
     775ULONG xWinUpper(HAB hab,
     776                ULONG idcp,
     777                ULONG idcc,
     778                PSZ psz);
     779
     780APIRET xDosOpenL(PCSZ pszFileName,
     781                 PHFILE phFile,
     782                 PULONG pulAction,
     783                 LONGLONG llFileSize,
     784                 ULONG ulAttribute,
     785                 ULONG ulOpenFlags,
     786                 ULONG ulOpenMode,
     787                 PEAOP2 pEABuf);
     788
     789
     790
     791// .C code for the functions above
     792APIRET xDosCreatePipe(PHFILE phfReadHandle,
     793                      PHFILE phfWriteHandle,
     794                      ULONG ulPipeSize)
     795{
     796  APIRET   rc;
     797  HFILE   h1, h2;
     798  PHFILE  ph1 = NULL;
     799  PHFILE  ph2 = NULL;
     800
     801  if (phfReadHandle)
     802  {
     803      h1 = *phfReadHandle;
     804      ph1 = &h1;
     805  }
     806  if (phfWriteHandle)
     807  {
     808      h2 = *phfWriteHandle;
     809      ph2 = &h2;
     810  }
     811
     812  rc = DosCreatePipe(ph1, ph2, ulPipeSize);
     813
     814  if (phfReadHandle)
     815      *phfReadHandle = h1;
     816  if (phfWriteHandle)
     817      *phfWriteHandle = h2;
     818  return rc;
     819}
     820
     821// Code pEABuf
     822APIRET xDosOpenL(PCSZ pszFileName,
     823                 PHFILE phFile,
     824                 PULONG pulAction,
     825                 LONGLONG llFileSize,
     826                 ULONG ulAttribute,
     827                 ULONG ulOpenFlags,
     828                 ULONG ulOpenMode,
     829                 PEAOP2 pEABuf)
     830{
     831  APIRET  rc;
     832  ULONG   ul1;
     833  PULONG  pul1 = NULL;
     834  HFILE   hf1;
     835  PHFILE  phf1 = NULL;
     836  char    szFileNameLow[CCHMAXPATH];
     837
     838  strcpy(szFileNameLow, pszFileName);
     839
     840  if (phFile)
     841  {
     842      hf1 = *phFile;
     843      phf1 = &hf1;
     844  }
     845  if (pulAction)
     846  {
     847      ul1 = *pulAction;
     848      pul1 = &ul1;
     849  }
     850
     851/** @todo pEABuf */
     852
     853  rc = DosOpenL(szFileNameLow, phf1, pul1, llFileSize, ulAttribute,
     854                  ulOpenFlags, ulOpenMode, pEABuf);
     855
     856  if (phFile)
     857      *phFile = hf1;
     858  if (pulAction)
     859      *pulAction = ul1;
     860
     861  return rc;
     862}
     863
     864APIRET xDosQueryNPHState(HPIPE hpipe,
     865                         PULONG pulState)
     866{
     867  APIRET  rc;
     868  ULONG   ul1;
     869  PULONG  pul1 = NULL;
     870
     871  if (pulState)
     872  {
     873      ul1 = *pulState;
     874      pul1 = &ul1;
     875  }
     876
     877  rc = DosQueryNPHState(hpipe, pul1);
     878
     879  if (pulState)
     880      *pulState = ul1;
     881  return rc;
     882}
     883
     884APIRET xDosQueryFHState(HFILE hFile,
     885                        PULONG pulMode)
     886{
     887  APIRET  rc;
     888  ULONG   ul1;
     889  PULONG  pul1 = NULL;
     890
     891  if (pulMode)
     892  {
     893      ul1 = *pulMode;
     894      pul1 = &ul1;
     895  }
     896
     897  rc = DosQueryFHState(hFile, pul1);
     898
     899  if (pulMode)
     900      *pulMode = ul1;
     901
     902  return rc;
     903}
     904
     905APIRET xDosSetDateTime(DATETIME *pdt)
     906{
     907  APIRET      rc;
     908  DATETIME    dt1;
     909  PDATETIME   pdt1 = NULL;
     910
     911  if (pdt)
     912  {
     913      dt1 = *pdt;
     914      pdt1 = &dt1;
     915  }
     916
     917  rc = DosSetDateTime(pdt1);
     918
     919  return rc;
     920}
     921
     922APIRET xDosSetFilePtr(HFILE hFile,
     923                      LONG lOffset,
     924                      ULONG ulOrigin,
     925                      PULONG pulPos)
     926{
     927  APIRET rc;
     928  ULONG  ul1;
     929  PULONG pul1 = NULL;
     930
     931  if (pulPos)
     932  {
     933      ul1 = *pulPos;
     934      pul1 = &ul1;
     935  }
     936
     937  rc = DosSetFilePtr(hFile, lOffset, ulOrigin, pul1);
     938
     939  if (pulPos)
     940      *pulPos = ul1;
     941
     942  return rc;
     943}
     944
     945APIRET xDosSetFilePtrL(HFILE hFile,
     946                       LONGLONG llOffset,
     947                       ULONG ulOrigin,
     948                       PLONGLONG pllPos)
     949{
     950  APIRET rc;
     951  LONGLONG ll1;
     952  PLONGLONG pll1 = NULL;
     953
     954  if (pllPos)
     955  {
     956      ll1 = *pllPos;
     957      pll1 = &ll1;
     958  }
     959
     960  rc = DosSetFilePtrL(hFile, llOffset, ulOrigin, pll1);
     961
     962  if (pllPos)
     963      *pllPos = ll1;
     964
     965  return rc;
     966}
     967
     968APIRET xDosWaitChild(ULONG ulAction,
     969                     ULONG ulWait,
     970                     PRESULTCODES pReturnCodes,
     971                     PPID ppidOut,
     972                     PID pidIn)
     973{
     974  APIRET          rc;
     975  RESULTCODES     res;
     976  PRESULTCODES    pres = NULL;
     977  PID             pid;
     978  PPID            ppid = NULL;
     979
     980  if (pReturnCodes)
     981  {
     982      res = *pReturnCodes;
     983      pres = &res;
     984  }
     985  if (ppidOut)
     986  {
     987      pid = *ppidOut;
     988      ppid = &pid;
     989  }
     990
     991  rc = DosWaitChild(ulAction, ulWait, pres, ppid, pidIn);
     992
     993  if (pReturnCodes)
     994      *pReturnCodes = res;
     995  if (ppidOut)
     996      *ppidOut = pid;
     997
     998  return rc;
     999}
     1000
     1001APIRET xDosWaitNPipe(PCSZ pszName,
     1002                     ULONG ulTimeout)
     1003{
     1004  APIRET rc;
     1005  char szNameLow[CCHMAXPATH];
     1006
     1007  strcpy(szNameLow, pszName);
     1008  rc = DosWaitNPipe(szNameLow, ulTimeout);
     1009  return rc;
     1010}
     1011
     1012ULONG xWinUpper(HAB hab,
     1013                ULONG idcp,
     1014                ULONG idcc,
     1015                PSZ psz)
     1016{
     1017  ULONG rc;
     1018
     1019  if (!HIGH_MEMORY_ADDRESS(psz))
     1020    rc = WinUpper(hab, idcp, idcc, psz);
     1021  else {
     1022    size_t cch = strlen(psz);
     1023    char *pszTmp = xmalloc(cch + 3, pszSrcFile, __LINE__);
     1024    if (pszTmp)
     1025      {
     1026          memcpy(pszTmp, psz, cch + 1);
     1027          pszTmp[cch + 1] = '\0';
     1028          pszTmp[cch + 2] = '\0';
     1029          rc = WinUpper(hab, idcp, idcc, pszTmp);
     1030          if (rc > 0)
     1031            memcpy(psz, pszTmp, rc <= cch ? rc + 1 : rc);
     1032          xfree(pszTmp, pszSrcFile, __LINE__);
     1033      }
     1034      else
     1035      {
     1036          PSZ pszStart = psz;
     1037          PSZ pszNext;
     1038          while (*psz)
     1039          {
     1040              pszNext = (PSZ)WinNextChar(hab, idcp, idcc, psz);
     1041              if (pszNext - psz == 1)
     1042                  *psz = WinUpperChar(hab, idcp, idcc, *psz);
     1043              else if (pszNext - psz == 2)
     1044                  *(PUSHORT)psz = WinUpperChar(hab, idcp, idcc, *(PUSHORT)psz); /* a wild guess. */
     1045              else
     1046                  break;
     1047              psz = (char *)pszNext;
     1048          }
     1049          rc = psz - pszStart;
     1050      }
     1051  }
     1052  return rc;
     1053}
     1054
     1055#endif
     1056
    5581057
    5591058#pragma alloc_text(WRAPPERS1,xfree,xfopen,xfsopen,xmalloc,xrealloc,xstrdup)

  • trunk/dll/wrappers.h

    r1839 r1845  
    77
    88  Copyright (c) 1993-98 M. Kimes
    9   Copyright (c) 2008, 2015 Steven H. Levine
     9  Copyright (c) 2008 Steven H. Levine
    1010
    1111  08 Dec 08 SHL Add missing OS2_INCLUDED check
    … …  
    1313  26 Aug 11 GKY Add a low mem version of xDosAlloc* wrappers; move error checking into all the
    1414                xDosAlloc* wrappers.
    15   09 Aug 15 SHL Add xDosGetInfoBlocks
     15  12 Aug 15 JBS Ticket #524: Ensure no "highmem-unsafe" functions are called directly
     16                1) New functions have been added
     17                2) Code for unsafe-but-not-yet-used-by-FM/2 has been added in an
     18                   "#if 0" block in wrappers.c for quick implementation should FM/2 start to use them.
     19                   Among these. xDosOpenL and xWinUpper still need work. The rest are ready for use.
    1620
    1721***********************************************************************/
    … …  
    2428#endif
    2529
    26 APIRET xDosQueryAppType(PCSZ pszName, PULONG pFlags);
     30// Functions wrapped because they are not safe with high memory addresses
    2731
    28 APIRET xDosAllocSharedMem(PPVOID ppb,
    29                           PSZ pszName,
    30                           ULONG cb,
    31                           PCSZ pszSrcFile,
    32                           UINT uiLineNumber);
     32APIRET xDosDupHandle(HFILE hFile,
     33                     PHFILE phFile);
     34
     35APIRET xDosForceDelete(PSZ pszFileName);
     36
     37APIRET xDosQueryHType(HFILE hFile,
     38                      PULONG pulType,
     39                      PULONG pulAttr);
     40
     41APIRET xDosQueryAppType(PCSZ pszName,
     42                        PULONG pFlags);
     43
     44#ifdef INCL_DOSSESMGR
     45APIRET xDosStartSession(PSTARTDATA psd,
     46                        PULONG pulSessionID,
     47                        PPID ppid);
     48#endif
     49
     50// Functions wrapped for other reasons
    3351
    3452APIRET xDosAllocMem(PPVOID ppb,
    … …  
    4260                       UINT uiLineNumber);
    4361
     62APIRET xDosAllocSharedMem(PPVOID ppb,
     63                          PSZ pszName,
     64                          ULONG cb,
     65                          PCSZ pszSrcFile,
     66                          UINT uiLineNumber);
     67
    4468APIRET xDosFindFirst(PSZ pszFileSpec,
    4569                     PHDIR phdir,
    46                      ULONG flAttribute,
    47                      PVOID pfindbuf,
    48                      ULONG cbBuf,
     70                     ULONG  flAttribute,
     71                     PVOID  pfindbuf,
     72                     ULONG  cbBuf,
    4973                     PULONG pcFileNames,
    50                      ULONG ulInfoLevel);
    51 APIRET xDosFindNext(HDIR hDir,
    52                     PVOID pfindbuf,
    53                     ULONG cbfindbuf,
     74                     ULONG  ulInfoLevel);
     75
     76APIRET xDosFindNext(HDIR   hDir,
     77                    PVOID  pfindbuf,
     78                    ULONG  cbfindbuf,
    5479                    PULONG pcFilenames,
    55                     ULONG ulInfoLevel); // 06 Oct 07 SHL Added
     80                    ULONG  ulInfoLevel);        // 06 Oct 07 SHL Added
    5681
    57 #ifdef INCL_DOSPROCESS  // // PPIB PTIB
     82#ifdef INCL_DOSPROCESS  // // PPIB PTIB
    5883APIRET xDosGetInfoBlocks(PTIB *pptib,
    59                          PPIB *pppib);  // 2015-08-09 SHL added
     84                         PPIB *pppib);  // 2015-08-09 SHL added
    6085#endif
    6186
    62 APIRET xDosSetPathInfo(PSZ pszPathName,
     87APIRET xDosSetPathInfo(PSZ   pszPathName,
    6388                       ULONG ulInfoLevel,
    6489                       PVOID pInfoBuf,
    6590                       ULONG cbInfoBuf,
    6691                       ULONG flOptions);
     92
    6793PSZ xfgets(PSZ pszBuf, size_t cMaxBytes, FILE * fp, PCSZ pszSrcFile,
    6894           UINT uiLineNumber);
    … …  
    79105PVOID xstrdup(PCSZ pszIn, PCSZ pszSrcFile, UINT uiLineNumber);
    80106
     107#define HIGH_MEMORY_ADDRESS(p) (((ULONG)p) >= (512*1024*1024))
     108
    81109// Data declarations
    82110extern BOOL fNoLargeFileSupport;
    83111
     112
    84113#endif // WRAPPERS_H
Note: See TracChangeset for help on using the changeset viewer.