Changeset 850


Ignore:
Timestamp:
Oct 7, 2007, 4:50:15 AM (18 years ago)
Author:
Steven Levine
Message:

Rework large file support wrappers (ticket #41)
Add code to avoid NTFS driver small file read defect (ticket #159)
Add debug code to try to catch David's drive bar exception
Another attempt to correct newview fast viewer text load failure

Location:
trunk/dll
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/dll/autoview.c

    r846 r850  
    302302            HFILE handle;
    303303            ULONG olen, ibufflen, action, obufflen, l;
    304             CHAR *ibuff, *obuff, *p, buffer[80];
     304            CHAR *ibuff, *obuff, *p;
     305            // 06 Oct 07 SHL Protect against NTFS driver small buffer defect
     306            // CHAR buffer[80];
     307            CHAR buffer[4096];
    305308            ARC_TYPE *info;
    306309
     
    314317                         OPEN_FLAGS_RANDOMSEQUENTIAL | OPEN_SHARE_DENYNONE |
    315318                         OPEN_ACCESS_READONLY, 0)) {
    316               ibufflen = (AutoviewHeight < 96) ? 512 : 3072;
    317               ibuff = xmalloc(ibufflen + 2, pszSrcFile, __LINE__);
     319              ibufflen = AutoviewHeight < 96 ? 512 : 3072;
     320              // 06 Oct 07 SHL protect against NTFS driver small buffer defect
     321              // ibuff = xmalloc(ibufflen + 2, pszSrcFile, __LINE__);
     322              ibuff = xmalloc(min(ibufflen + 2, 4096), pszSrcFile, __LINE__);
    318323              if (ibuff) {
    319324                // Depends on CreateHexDump line width
     
    322327                if (obuff) {
    323328                  *obuff = 0;
    324                   if (!DosRead(handle,
    325                                ibuff, ibufflen, &ibufflen) && ibufflen) {
     329                  if (!DosRead(handle, ibuff, ibufflen, &ibufflen) &&
     330                               ibufflen)
     331                  {
    326332                    ibuff[ibufflen] = 0;
    327333                    p = obuff;
  • trunk/dll/avl.c

    r844 r850  
    162162  ARC_TYPE *info;
    163163  CHAR *p;
    164   CHAR buffer[80];
     164  // CHAR buffer[80];
     165  CHAR buffer[4096];                    // 06 Oct 07 SHL Protect against NTFS defect
    165166
    166167  if (!arcsigsloaded)
  • trunk/dll/comp.c

    r847 r850  
    145145          }
    146146          ulFindCnt = 1;
    147         } while (!xDosFindNext(hdir, pffb, sizeof(FILEFINDBUF4L), &ulFindCnt));
     147        } while (!xDosFindNext(hdir, pffb, sizeof(FILEFINDBUF4L), &ulFindCnt, FIL_QUERYEASIZEL));
    148148        DosFindClose(hdir);
    149149      }
     
    816816      DosError(FERR_DISABLEHARDERR);
    817817      ulFindCnt = FilesToGet;
    818       rc = xDosFindNext(hDir, pffbArray, ulBufBytes, &ulFindCnt);
     818      rc = xDosFindNext(hDir, pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZEL);
    819819    } while (!rc);
    820820
  • trunk/dll/dirsize.c

    r841 r850  
    277277      ulFindCnt = FilesToGet;
    278278      DosError(FERR_DISABLEHARDERR);
    279       rc = xDosFindNext(hdir, pffbArray, ulBufBytes, &ulFindCnt);
     279      rc = xDosFindNext(hdir, pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZEL);
    280280    } // while more found
    281281
  • trunk/dll/filldir.c

    r847 r850  
    892892        DosError(FERR_DISABLEHARDERR);
    893893        ulFindCnt = ulFindMax;
    894         rc = xDosFindNext(hdir, paffbFound, ulBufBytes, &ulFindCnt);
     894        rc = xDosFindNext(hdir, paffbFound, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZEL);
    895895        priority_normal();
    896896        if (rc)
     
    16591659      }
    16601660      while (pci) {
     1661        // 12 Sep 07 SHL dwg drivebar crash testing - ticket# ???
     1662        static PCNRITEM pciLast;                // 12 Sep 07 SHL
     1663        ULONG ulSize = sizeof(*pci);
     1664        ULONG ulAttr;
     1665        APIRET apiret = DosQueryMem((PVOID)pci, &ulSize, &ulAttr);
     1666        if (apiret)
     1667          Dos_Error(MB_ENTER, apiret, HWND_DESKTOP, pszSrcFile, __LINE__,
     1668                    "DosQueryMem failed pci %p pciLast %p", pci, pciLast);
    16611669        FreeCnrItemData(pci);
     1670        pciLast = pci;
    16621671        pci = (PCNRITEM)pci->rc.preccNextRecord;
    16631672        if (remaining && --remaining == 0)
  • trunk/dll/grep.c

    r848 r850  
    462462  PSZ p;
    463463  APIRET rc;
    464   ULONG ulBufBytes = FilesToGet * sizeof(FILEFINDBUF4);
     464  // 06 Oct 07 SHL Correct size for xDosFindFirst
     465  ULONG ulBufBytes = FilesToGet * sizeof(FILEFINDBUF4L);
    465466  static BOOL fDone;
    466467
     
    536537      DosSleep(0); //26 Aug 07 GKY 1
    537538      ulFindCnt = FilesToGet;
    538       rc = xDosFindNext(findHandle, pffbArray, ulBufBytes, &ulFindCnt);
     539      rc = xDosFindNext(findHandle, pffbArray, ulBufBytes, &ulFindCnt, FIL_QUERYEASIZEL);
    539540    } while (!rc);
    540541
  • trunk/dll/info.c

    r846 r850  
    784784          fp = _fsopen(pfs->szFileName, "rb", SH_DENYNO);
    785785          if (fp) {
    786             char buff[512];
     786            // char buff[512];
     787            char buff[4096];            // 06 Oct 07 SHL protect against NTFS defect
    787788            ULONG len;
    788789            APIRET rc;
  • trunk/dll/init.c

    r849 r850  
    9797                      FILE_NORMAL | FILE_ARCHIVED |
    9898                      FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    99                       &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
    100     if (rc && rc != 2 && rc !=3){
     99                      &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
     100    if (rc && rc != ERROR_FILE_NOT_FOUND && rc != ERROR_PATH_NOT_FOUND) {
    101101      FILEFINDBUF3 ffb;
    102102      rc = DosFindFirst(SwapperDat,
    103                         &hdir,
    104                         FILE_NORMAL | FILE_ARCHIVED |
    105                         FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    106                         &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     103                        &hdir,
     104                        FILE_NORMAL | FILE_ARCHIVED |
     105                        FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     106                        &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    107107      fNoLargeFileSupport = TRUE;
    108108    }
     
    167167                                FILE_NORMAL | FILE_ARCHIVED |
    168168                                FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    169                                 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    170               if (rc){
    171                 FILEFINDBUF3 ffb;
    172                 rc = DosFindFirst(SwapperDat,
    173                                   &hdir,
    174                                   FILE_NORMAL | FILE_ARCHIVED |
    175                                   FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    176                                   &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    177                 fNoLargeFileSupport = TRUE;
    178               }
    179               if (!rc) {
     169                                &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     170              if (rc){
     171                FILEFINDBUF3 ffb;
     172                rc = DosFindFirst(SwapperDat,
     173                                  &hdir,
     174                                  FILE_NORMAL | FILE_ARCHIVED |
     175                                  FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     176                                  &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     177                fNoLargeFileSupport = TRUE;
     178              }
     179              if (!rc) {
    180180                DosFindClose(hdir);
    181181                PrfWriteProfileString(fmprof,
     
    923923    fSwitchTreeExpand = fNoSearch = fCustomFileDlg = fOtherHelp =
    924924    fSaveMiniCmds = fUserComboBox = fFM2Deletes = fConfirmTarget =
    925     fShowTarget = fDrivebarHelp = fCheckMM = fNoLargeFileSupport = TRUE;
     925    fShowTarget = fDrivebarHelp = fCheckMM = TRUE;
     926#if 1 // 06 Oct 07 SHL fixme to be gone after wrapper testing finished
     927    fNoLargeFileSupport = TRUE;
     928#endif
    926929  ulCnrType = CCS_EXTENDSEL;
    927930  FilesToGet = FILESTOGET_MIN;
     
    10761079  size = sizeof(BOOL);
    10771080  PrfQueryProfileData(fmprof, FM3Str, "UseQProcStat",
    1078                       &fUseQProcStat, &size);
     1081                      &fUseQProcStat, &size);
    10791082  size = sizeof(BOOL);
    10801083  PrfQueryProfileData(fmprof, FM3Str, "UseQSysState",
  • trunk/dll/newview.c

    r844 r850  
    2424  26 Aug 07 GKY Fixed fast viewer text load failure
    2525  28 Aug 07 GKY Reversed horizontal scrollbar behavior to be present for unwrapped text and absent for wrapped text & hex.
    26 
     26  14 Sep 07 SHL Another attempt to correct the fast viewer text load failure
    2727
    2828***********************************************************************/
     
    10931093      IncrThreadUsage();
    10941094      ad = WinQueryWindowPtr(hwnd, QWL_USER);
    1095       if (ad) {
    1096         if (ad->text && ad->textsize && !ad->hex)
    1097           DosSleep(32);   // 26 Aug 07 GKY Fixes failure to load text file in some cases
    1098         ad->relining = TRUE;
     1095      if (ad)
     1096        Runtime_Error(pszSrcFile, __LINE__, "no data");
     1097      else {
    10991098        if (!DosRequestMutexSem(ad->ScanSem, SEM_INDEFINITE_WAIT)) {
     1099          ad->relining = TRUE;
    11001100          ad->busy++;
    11011101          ad->maxx = 0;
     
    11851185                    for (x = 0; x < ad->numlines; x++) {
    11861186                      if ((LONG) (Rectl.yTop -
    1187                                   (ad->lMaxHeight * (((x + 1) -
    1188                                                       ad->topline) + 1))) < 0)
    1189                         break;
     1187                                  (ad->lMaxHeight * (((x + 1) -
     1188                                                      ad->topline) + 1))) < 0)
     1189                        break;
    11901190                      PaintLine(hwnd, ad->hps, x, 1, &Rectl);
    11911191                    }
     
    12361236          PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    12371237          ad->busy--;
    1238         }
    1239       }
     1238        } // if got sim
     1239      } // if got VIEWDATA
    12401240      WinDestroyMsgQueue(hmq2);
    12411241    }
     
    13141314              }
    13151315              else {
    1316                 ad->text = xmalloc(len + 2, pszSrcFile, __LINE__);
     1316                // 06 Oct 07 SHL Protect against 4096 NFTS driver small buffer defect
     1317                ad->text = xmalloc(min(len + 2, 4096),
     1318                                   pszSrcFile,
     1319                                   __LINE__);
    13171320                if (ad->text) {
    13181321                  *ad->text = 0;
     
    18711874
    18721875      if (ad->wrapon || ad->hex) { // GKY reverse case where hscroll bar is presnt
    1873         if (WinQueryWindow(ad->hhscroll, QW_PARENT) == ad->hwndFrame) {
    1874           invalidate = TRUE;
    1875           WinSetOwner(ad->hhscroll, HWND_OBJECT);
    1876           WinSetParent(ad->hhscroll, HWND_OBJECT, TRUE);
    1877           ad->maxx = 0;
    1878           ad->horzscroll = 0;
    1879         }
     1876        if (WinQueryWindow(ad->hhscroll, QW_PARENT) == ad->hwndFrame) {
     1877          invalidate = TRUE;
     1878          WinSetOwner(ad->hhscroll, HWND_OBJECT);
     1879          WinSetParent(ad->hhscroll, HWND_OBJECT, TRUE);
     1880          ad->maxx = 0;
     1881          ad->horzscroll = 0;
     1882        }
    18801883      }
    18811884      else {
  • trunk/dll/objcnr.c

    r841 r850  
    191191        break;
    192192      ulFindCnt = ulFindMax;
    193       rc = xDosFindNext(hdir, pffbArray, ulBufBytes, &ulFindCnt);
     193      rc = xDosFindNext(hdir, pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
    194194    } // while
    195195    DosFindClose(hdir);
  • trunk/dll/seeall.c

    r847 r850  
    19981998        break;
    19991999      ulFindCnt = ulFindMax;
    2000       rc = xDosFindNext(hdir, pffbArray, sizeof(FILEFINDBUF3L) * ulFindCnt, &ulFindCnt);
     2000      rc = xDosFindNext(hdir,
     2001                        pffbArray,
     2002                        sizeof(FILEFINDBUF3L) * ulFindCnt,
     2003                        &ulFindCnt,
     2004                        FIL_STANDARDL);
    20012005    } while (!rc);
    20022006    DosFindClose(hdir);
  • trunk/dll/valid.c

    r847 r850  
    864864  ULONG len;
    865865  APIRET rc;
    866   CHAR buff[512];
     866  // CHAR buff[512];
     867  CHAR buff[4096];                      // 06 Oct 07 SHL protect against NTFS defect
    867868
    868869  if (filename) {
  • trunk/dll/wrappers.c

    r849 r850  
    1313  20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
    1414  01 Sep 07 GKY Add xDosSetPathInfo to fix case where FS3 buffer crosses 64k boundry
     15  06 Oct 07 SHL Add xDos...() wrappers to support systems wo/large file support (Gregg, Steven)
    1516
    1617***********************************************************************/
     
    3132static PSZ pszSrcFile = __FILE__;
    3233
    33 APIRET xDosFindFirst(PSZ    pszFileSpec,
    34                      PHDIR  phdir,
    35                      ULONG  flAttribute,
    36                      PVOID  pfindbuf,
    37                      ULONG  cbBuf,
    38                      PULONG pcFileNames,
    39                      ULONG  ulInfoLevel)
    40 {
    41     APIRET rc;
    42     if (fNoLargeFileSupport) {
    43         switch (ulInfoLevel) {
    44     case FIL_STANDARDL: {
    45       FILEFINDBUF3 ff3;
    46       ff3 = *(PFILEFINDBUF3)pfindbuf;
    47       ulInfoLevel = FIL_STANDARD;
    48       rc = DosFindFirst(pszFileSpec, phdir, flAttribute, &ff3, cbBuf,
    49                         pcFileNames, ulInfoLevel);
    50       *(PFILEFINDBUF3)pfindbuf = ff3;   // Copy aligned data
    51       ((PFILEFINDBUF3L)pfindbuf) -> cbFile = ff3.cbFile;  // Copy unaligned data
    52       ((PFILEFINDBUF3L)pfindbuf) -> cbFileAlloc = ff3.cbFileAlloc;
    53       ((PFILEFINDBUF3L)pfindbuf) -> attrFile = ff3.attrFile;
    54       ((PFILEFINDBUF3L)pfindbuf) -> cchName = ff3.cchName;
    55       ((PFILEFINDBUF3L)pfindbuf) -> achName[CCHMAXPATHCOMP] = *ff3.achName;
    56       break;
    57     }
    58     case  FIL_QUERYEASIZEL:{
    59       FILEFINDBUF4 ff4;
    60       ff4 = *(PFILEFINDBUF4)pfindbuf;
    61       ulInfoLevel = FIL_QUERYEASIZE;
    62       rc = DosFindFirst(pszFileSpec, phdir, flAttribute, &ff4, cbBuf,
    63                         pcFileNames, ulInfoLevel);
    64       //(PFILEFINDBUF4L)pfindbuf = (PFILEFINDBUF4L)pff4;   // Copy aligned data
    65       ((PFILEFINDBUF4L)pfindbuf) -> oNextEntryOffset = ff4.oNextEntryOffset;
    66       ((PFILEFINDBUF4L)pfindbuf) -> fdateCreation = ff4.fdateCreation;
    67       ((PFILEFINDBUF4L)pfindbuf) -> ftimeCreation = ff4.ftimeCreation;
    68       ((PFILEFINDBUF4L)pfindbuf) -> fdateLastAccess = ff4.fdateLastAccess;
    69       ((PFILEFINDBUF4L)pfindbuf) -> ftimeLastAccess = ff4.ftimeLastAccess;
    70       ((PFILEFINDBUF4L)pfindbuf) -> fdateLastWrite = ff4.fdateLastWrite;
    71       ((PFILEFINDBUF4L)pfindbuf) -> ftimeLastWrite = ff4.ftimeLastWrite;
    72       ((PFILEFINDBUF4L)pfindbuf) -> cbFile = ff4.cbFile;  // Copy unaligned data
    73       ((PFILEFINDBUF4L)pfindbuf) -> cbFileAlloc = ff4.cbFileAlloc;
    74       ((PFILEFINDBUF4L)pfindbuf) -> attrFile = ff4.attrFile;
    75       ((PFILEFINDBUF4L)pfindbuf) -> cbList = ff4.cbList;
    76       ((PFILEFINDBUF4L)pfindbuf) -> cchName = ff4.cchName;
    77       ((PFILEFINDBUF4L)pfindbuf) -> achName[CCHMAXPATHCOMP] = *ff4.achName;
    78       break;
    79     }
    80     default:
    81         Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
    82         rc = ERROR_INVALID_PARAMETER;
    83         }
    84     }
    85     else
    86     rc = DosFindFirst(pszFileSpec, phdir, flAttribute, pfindbuf, cbBuf,
    87                       pcFileNames, ulInfoLevel);
    88     return rc;
    89 }
    90 
    91 APIRET xDosFindNext(HDIR   hDir,
    92                     PVOID  pfindbuf,
    93                     ULONG  cbfindbuf,
    94                     PULONG pcFilenames)
     34APIRET xDosFindFirst(PSZ pszFileSpec,
     35                     PHDIR phdir,
     36                     ULONG flAttribute,
     37                     PVOID pfindbuf,
     38                     ULONG cbBuf,
     39                     PULONG pcFileNames,
     40                     ULONG ulInfoLevel)
    9541{
    9642  APIRET rc;
    9743  if (fNoLargeFileSupport) {
    98     if (((PFILEFINDBUF4L)pfindbuf)->cbList) {
    99       FILEFINDBUF4 ff4;
    100       ff4 = *(PFILEFINDBUF4)pfindbuf;
    101       rc = DosFindNext(hDir, &ff4, cbfindbuf, pcFilenames);
    102       *(PFILEFINDBUF4)pfindbuf = ff4;   // Copy aligned data
    103       ((PFILEFINDBUF4L)pfindbuf) -> cbFile = ff4.cbFile;  // Copy unaligned data
    104       ((PFILEFINDBUF4L)pfindbuf) -> cbFileAlloc = ff4.cbFileAlloc;
    105       ((PFILEFINDBUF4L)pfindbuf) -> attrFile = ff4.attrFile;
    106       ((PFILEFINDBUF4L)pfindbuf) -> cbList = ff4.cbList;
    107       ((PFILEFINDBUF4L)pfindbuf) -> cchName = ff4.cchName;
    108       ((PFILEFINDBUF4L)pfindbuf) -> achName[CCHMAXPATHCOMP] = *ff4.achName;
    109     }
    110     else {
    111       FILEFINDBUF3 ff3;
    112       ff3 = *(PFILEFINDBUF3)pfindbuf;
    113       rc = DosFindNext(hDir, &ff3, cbfindbuf, pcFilenames);
    114       *(PFILEFINDBUF3)pfindbuf = ff3;   // Copy aligned data
    115       ((PFILEFINDBUF3L)pfindbuf) -> cbFile = ff3.cbFile;  // Copy unaligned data
    116       ((PFILEFINDBUF3L)pfindbuf) -> cbFileAlloc = ff3.cbFileAlloc;
    117       ((PFILEFINDBUF3L)pfindbuf) -> attrFile = ff3.attrFile;
    118       ((PFILEFINDBUF3L)pfindbuf) -> cchName = ff3.cchName;
    119       ((PFILEFINDBUF3L)pfindbuf) -> achName[CCHMAXPATHCOMP] = *ff3.achName;
    120     }
     44    switch (ulInfoLevel) {
     45    case FIL_STANDARDL:
     46      {
     47        FILEFINDBUF3 ffb3;
     48        ulInfoLevel = FIL_STANDARD;
     49        *pcFileNames = 1;               // fixme to support larger counts
     50        rc = DosFindFirst(pszFileSpec, phdir, flAttribute, &ffb3, sizeof(ffb3),
     51                          pcFileNames, ulInfoLevel);
     52        if (!rc) {
     53          *(PFILEFINDBUF3)pfindbuf = ffb3;      // Copy aligned data
     54          ((PFILEFINDBUF3L)pfindbuf)->cbFile = ffb3.cbFile;     // Copy unaligned data
     55          ((PFILEFINDBUF3L)pfindbuf)->cbFileAlloc = ffb3.cbFileAlloc;
     56          ((PFILEFINDBUF3L)pfindbuf)->attrFile = ffb3.attrFile;
     57          ((PFILEFINDBUF3L)pfindbuf)->cchName = ffb3.cchName;
     58          memcpy(((PFILEFINDBUF3L)pfindbuf)->achName, ffb3.achName, ffb3.cchName + 1);
     59        }
     60      }
     61      break;
     62    case FIL_QUERYEASIZEL:
     63      {
     64        FILEFINDBUF4 ffb4;
     65        *pcFileNames = 1;               // fixme to support larger counts
     66        ulInfoLevel = FIL_QUERYEASIZE;
     67        rc = DosFindFirst(pszFileSpec, phdir, flAttribute, &ffb4, sizeof(ffb4),
     68                          pcFileNames, ulInfoLevel);
     69        if (!rc) {
     70          *(PFILEFINDBUF4)pfindbuf = ffb4;      // Copy aligned data
     71          ((PFILEFINDBUF4L)pfindbuf)->cbFile = ffb4.cbFile;     // Copy unaligned data
     72          ((PFILEFINDBUF4L)pfindbuf)->cbFileAlloc = ffb4.cbFileAlloc;
     73          ((PFILEFINDBUF4L)pfindbuf)->attrFile = ffb4.attrFile;
     74          ((PFILEFINDBUF4L)pfindbuf)->cbList = ffb4.cbList;
     75          ((PFILEFINDBUF4L)pfindbuf)->cchName = ffb4.cchName;
     76          memcpy(((PFILEFINDBUF4L)pfindbuf)->achName, ffb4.achName, ffb4.cchName + 1);
     77        }
     78      }
     79      break;
     80    default:
     81      Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
     82      rc = ERROR_INVALID_PARAMETER;
     83    } // switch
    12184  }
    12285  else
    123     rc = DosFindNext(hDir, pfindbuf, cbfindbuf, pcFilenames);
    124 
     86    rc = DosFindFirst(pszFileSpec, phdir, flAttribute, pfindbuf, cbBuf,
     87                      pcFileNames, ulInfoLevel);
    12588  return rc;
    12689}
    12790
     91APIRET xDosFindNext(HDIR hDir,
     92                    PVOID pfindbuf,
     93                    ULONG cbfindbuf,
     94                    PULONG pcFileNames,
     95                    ULONG ulInfoLevel)
     96{
     97  APIRET rc;
     98  if (fNoLargeFileSupport) {
     99    switch (ulInfoLevel) {
     100    case FIL_STANDARDL:
     101      {
     102        FILEFINDBUF3 ffb3;
     103        *pcFileNames = 1;               // fixme to support larger counts
     104        rc = DosFindNext(hDir, &ffb3, sizeof(ffb3), pcFileNames);
     105        if (!rc) {
     106          *(PFILEFINDBUF3)pfindbuf = ffb3;      // Copy aligned data
     107          ((PFILEFINDBUF3L)pfindbuf)->cbFile = ffb3.cbFile;     // Copy unaligned data
     108          ((PFILEFINDBUF3L)pfindbuf)->cbFileAlloc = ffb3.cbFileAlloc;
     109          ((PFILEFINDBUF3L)pfindbuf)->attrFile = ffb3.attrFile;
     110          ((PFILEFINDBUF3L)pfindbuf)->cchName = ffb3.cchName;
     111          memcpy(((PFILEFINDBUF3L)pfindbuf)->achName, ffb3.achName, ffb3.cchName + 1);
     112        }
     113      }
     114      break;
     115    case FIL_QUERYEASIZEL:
     116      {
     117        FILEFINDBUF4 ffb4;
     118        *pcFileNames = 1;               // fixme to support larger counts
     119        rc = DosFindNext(hDir, &ffb4, sizeof(ffb4), pcFileNames);
     120        if (!rc) {
     121          *(PFILEFINDBUF4)pfindbuf = ffb4;      // Copy aligned data
     122          ((PFILEFINDBUF4L)pfindbuf)->cbFile = ffb4.cbFile;     // Copy unaligned data
     123          ((PFILEFINDBUF4L)pfindbuf)->cbFileAlloc = ffb4.cbFileAlloc;
     124          ((PFILEFINDBUF4L)pfindbuf)->attrFile = ffb4.attrFile;
     125          ((PFILEFINDBUF4L)pfindbuf)->cbList = ffb4.cbList;
     126          ((PFILEFINDBUF4L)pfindbuf)->cchName = ffb4.cchName;
     127          memcpy(((PFILEFINDBUF4L)pfindbuf)->achName, ffb4.achName, ffb4.cchName + 1);
     128        }
     129      }
     130      break;
     131    default:
     132      Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
     133      rc = ERROR_INVALID_PARAMETER;
     134    } // switch
     135  }
     136  else
     137    rc = DosFindNext(hDir, pfindbuf, cbfindbuf, pcFileNames);
     138
     139  return rc;
     140}
     141
    128142/**
    129  * Wrap DosSetPathInfo to avoid spurious ERROR_INVALID_NAME returns
     143 * DosQueryPathInfo wrapper
     144 * Translate request for systems without large file support
     145 */
     146
     147APIRET xDosQueryPathInfo (PSZ pszPathName, ULONG ulInfoLevel, PVOID pInfoBuf, ULONG cbInfoBuf)
     148{
     149  FILESTATUS3 fs3;
     150  FILESTATUS4 fs4;
     151  APIRET rc;
     152
     153  if (fNoLargeFileSupport) {
     154    switch (ulInfoLevel) {
     155    case FIL_STANDARDL:
     156      rc = DosQueryPathInfo(pszPathName, ulInfoLevel, &fs3, sizeof(fs3));
     157      if (!rc) {
     158        *(PFILESTATUS3)pInfoBuf = fs3;  // Copy aligned data
     159        ((PFILESTATUS3L)pInfoBuf)->cbFile = fs3.cbFile; // Copy unaligned data
     160        ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc = fs3.cbFileAlloc;
     161        ((PFILESTATUS3L)pInfoBuf)->attrFile = fs3.attrFile;
     162      }
     163      break;
     164    case FIL_QUERYEASIZEL:
     165      rc = DosQueryPathInfo(pszPathName, ulInfoLevel, &fs4, sizeof(fs4));
     166      if (!rc) {
     167        *(PFILESTATUS4)pInfoBuf = fs4;  // Copy aligned data
     168        ((PFILESTATUS4L)pInfoBuf)->cbFile = fs4.cbFile; // Copy unaligned data
     169        ((PFILESTATUS4L)pInfoBuf)->cbFileAlloc = fs4.cbFileAlloc;
     170        ((PFILESTATUS4L)pInfoBuf)->attrFile = fs4.attrFile;
     171        ((PFILESTATUS4L)pInfoBuf)->cbList = fs4.cbList;
     172      }
     173      break;
     174    default:
     175      Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
     176      rc = ERROR_INVALID_PARAMETER;
     177    } // switch
     178  }
     179  else
     180    DosQueryPathInfo (pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf);
     181
     182  return rc;
     183}
     184
     185/**
     186 * Wrap DosSetPathInfo to avoid spurious ERROR_INVALID_NAME returns and
     187 * support systems without large file support
     188 *
    130189 * Some kernels to do not correctly handle FILESTATUS3 and PEAOP2 buffers
    131190 * that cross a 64K boundary.
     
    141200
    142201APIRET xDosSetPathInfo(PSZ pszPathName,
    143                        ULONG ulInfoLevel,
     202                       ULONG ulInfoLevel,
    144203                       PVOID pInfoBuf,
    145204                       ULONG cbInfoBuf,
    146                        ULONG flOptions)
    147 {
    148     FILESTATUS3 alt_fs3;
    149     FILESTATUS3L alt_fs3L;
    150     EAOP2 alt_eaop2;
    151     BOOL large = FALSE;
     205                       ULONG flOptions)
     206{
     207    FILESTATUS3 fs3;
     208    FILESTATUS3 fs3_a;
     209    FILESTATUS3L fs3l;
     210    EAOP2 eaop2;
    152211    APIRET rc;
    153     if (fNoLargeFileSupport && ulInfoLevel == FIL_STANDARDL){
    154       large = TRUE;
    155       ulInfoLevel = FIL_STANDARD;
    156     }
    157     rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
    158     if (rc == ERROR_INVALID_NAME) {
    159       switch (ulInfoLevel) {
    160         case FIL_STANDARD:
    161           alt_fs3 = *(PFILESTATUS3)pInfoBuf;    // Copy
    162           rc = DosSetPathInfo(pszPathName, ulInfoLevel, &alt_fs3, cbInfoBuf, flOptions);
    163           if (fNoLargeFileSupport && large) {
    164             *(PFILESTATUS3)pInfoBuf = alt_fs3;   // Copy aligned data
    165             ((PFILESTATUS3L)pInfoBuf) -> cbFile = alt_fs3.cbFile;  // Copy unaligned data
    166             ((PFILESTATUS3L)pInfoBuf) -> cbFileAlloc = alt_fs3.cbFileAlloc;
    167             ((PFILESTATUS3L)pInfoBuf) -> attrFile = alt_fs3.attrFile;
    168           }
    169           break;
    170         case FIL_STANDARDL:
    171           alt_fs3L = *(PFILESTATUS3L)pInfoBuf;  // Copy
    172           rc = DosSetPathInfo(pszPathName, ulInfoLevel, &alt_fs3L, cbInfoBuf, flOptions);
    173           break;
    174         case FIL_QUERYEASIZE:
    175           alt_eaop2 = *(PEAOP2)pInfoBuf;        // Copy
    176           rc = DosSetPathInfo(pszPathName, ulInfoLevel, &alt_eaop2, cbInfoBuf, flOptions);
    177           break;
     212
     213    switch (ulInfoLevel) {
     214      case FIL_STANDARD:
     215        rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
     216        if (rc == ERROR_INVALID_NAME) {
     217          // fixme to validate counts?
     218          fs3 = *(PFILESTATUS3)pInfoBuf;        // Copy to buffer that does not cross
     219          rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3, sizeof(fs3), flOptions);
     220        }
     221        break;
     222
     223      case FIL_STANDARDL:
     224        if (fNoLargeFileSupport) {
     225          ulInfoLevel = FIL_STANDARD;
     226          fs3 = *(PFILESTATUS3)pInfoBuf;        // Copy aligned data
     227          // Check size too big to handle
     228          if (((PFILESTATUS3L)pInfoBuf)->cbFile >= 1LL << 32 ||
     229              ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc >= 2LL << 32)
     230          {
     231            rc = ERROR_INVALID_PARAMETER;
     232          }
     233          else {
     234            fs3.cbFile = ((PFILESTATUS3L)pInfoBuf)->cbFile;     // Copy unaligned data
     235            fs3.cbFileAlloc = ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc;
     236            fs3.attrFile = ((PFILESTATUS3L)pInfoBuf)->attrFile;
     237            rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3, sizeof(fs3), flOptions);
     238          }
     239          if (rc == ERROR_INVALID_NAME) {
     240            // fixme to validate counts?
     241            fs3_a = fs3;                // Copy to buffer that does not cross
     242            rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3_a, sizeof(fs3_a), flOptions);
     243          }
     244        }
     245        else {
     246          rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
     247          if (rc == ERROR_INVALID_NAME) {
     248            fs3l = *(PFILESTATUS3L)pInfoBuf;    // Copy to buffer that does not cross
     249            rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3l, sizeof(fs3l), flOptions);
     250          }
     251        }
     252        break;
     253      case FIL_QUERYEASIZE:
     254        rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
     255        if (rc == ERROR_INVALID_NAME) {
     256          // fixme to validate counts?
     257          eaop2 = *(PEAOP2)pInfoBuf;    // Copy to buffer that does not cross
     258          rc = DosSetPathInfo(pszPathName, ulInfoLevel, &eaop2, sizeof(eaop2), flOptions);
     259        }
    178260      default:
    179261        Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
    180262        rc = ERROR_INVALID_PARAMETER;
    181       } // switch
    182     }
     263    } // switch
     264
    183265    return rc;
    184266}
    185267
    186 APIRET xDosQueryPathInfo (PSZ pszPathName, ULONG ulInfoLevel, PVOID pInfoBuf, ULONG cbInfoBuf)
    187 {
    188   FILESTATUS3 alt_fs3;
    189   FILESTATUS4 alt_fs4;
    190   APIRET rc;
    191   if (fNoLargeFileSupport){
    192   switch (ulInfoLevel) {
    193     case FIL_STANDARDL:
    194           alt_fs3 = *(PFILESTATUS3)pInfoBuf;    // Copy
    195           rc = DosQueryPathInfo(pszPathName, ulInfoLevel, &alt_fs3, cbInfoBuf);
    196           *(PFILESTATUS3)pInfoBuf = alt_fs3;   // Copy aligned data
    197           ((PFILESTATUS3L)pInfoBuf) -> cbFile = alt_fs3.cbFile;  // Copy unaligned data
    198           ((PFILESTATUS3L)pInfoBuf) -> cbFileAlloc = alt_fs3.cbFileAlloc;
    199           ((PFILESTATUS3L)pInfoBuf) -> attrFile = alt_fs3.attrFile;
    200           break;
    201     case FIL_QUERYEASIZEL:
    202           alt_fs4 = *(PFILESTATUS4)pInfoBuf;    // Copy
    203           rc = DosQueryPathInfo(pszPathName, ulInfoLevel, &alt_fs4, cbInfoBuf);
    204           *(PFILESTATUS4)pInfoBuf = alt_fs4;   // Copy aligned data
    205           ((PFILESTATUS4L)pInfoBuf) -> cbFile = alt_fs4.cbFile;  // Copy unaligned data
    206           ((PFILESTATUS4L)pInfoBuf) -> cbFileAlloc = alt_fs4.cbFileAlloc;
    207           ((PFILESTATUS4L)pInfoBuf) -> attrFile = alt_fs4.attrFile;
    208           ((PFILESTATUS4L)pInfoBuf) -> cbList = alt_fs4.cbList;
    209           break;
    210       default:
    211         Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
    212         rc = ERROR_INVALID_PARAMETER;
    213       } // switch
    214   }
    215   else
    216     DosQueryPathInfo (pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf);
    217   return rc;
    218 }
    219268PSZ xfgets(PSZ pszBuf, size_t cMaxBytes, FILE * fp, PCSZ pszSrcFile,
    220269           UINT uiLineNumber)
Note: See TracChangeset for help on using the changeset viewer.