Changeset 303


Ignore:
Timestamp:
Sep 10, 2017, 5:38:22 AM (3 years ago)
Author:
Valery V. Sedletski
Message:

FAT+ support in the IFS and CHKDSK.

Location:
trunk/src
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/ifs/fat32a.c

    r301 r303  
    20442044         // mount dirty disk readonly
    20452045         f32Parms.fReadonly = TRUE;
     2046         }
     2047
     2048      p = strstr(szArguments, "/plus");
     2049      if (!p)
     2050         p = strstr(szArguments, "-plus");
     2051      if (p)
     2052         {
     2053         // enable FAT+ support
     2054         f32Parms.fFatPlus = TRUE;
     2055         // need Large Files support too
     2056         f32Parms.fLargeFiles = TRUE;
    20462057         }
    20472058
     
    30123023      if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    30133024#endif
    3014          pDirEntry->ulFileSize += pVolInfo->ulClusterSize;
     3025         {
     3026         ULONGLONG ullSize;
     3027         FileGetSize(pVolInfo, pDirEntry, pVolInfo->BootSect.bpb.RootDirStrtClus, NULL, szFileName, &ullSize);
     3028         ullSize += pVolInfo->ulClusterSize;
     3029         FileSetSize(pVolInfo, pDirEntry, pVolInfo->BootSect.bpb.RootDirStrtClus, NULL, szFileName, ullSize);
     3030         }
    30153031#ifdef EXFAT
    30163032      else
     
    31303146      return ERROR_FILE_NOT_FOUND;
    31313147   if (!ulCluster)
    3132       pFileSize->ulFileSize = 0L;
    3133 
    3134    ulClustersNeeded = pFileSize->ulFileSize / pVolInfo->ulClusterSize;
    3135    if (pFileSize->ulFileSize % pVolInfo->ulClusterSize)
     3148      pFileSize->ullFileSize = 0L;
     3149
     3150   ulClustersNeeded = pFileSize->ullFileSize / pVolInfo->ulClusterSize;
     3151   if (pFileSize->ullFileSize % pVolInfo->ulClusterSize)
    31363152      ulClustersNeeded++;
    31373153
     
    31433159#endif
    31443160
    3145    if (pFileSize->ulFileSize > 0 )
     3161   if (pFileSize->ullFileSize > 0 )
    31463162      {
    31473163      ulClustersUsed = 1;
     
    31573173         }
    31583174      if (ulCluster == pVolInfo->ulFatEof)
    3159          pFileSize->ulFileSize = ulClustersUsed * pVolInfo->ulClusterSize;
     3175         pFileSize->ullFileSize = ulClustersUsed * pVolInfo->ulClusterSize;
    31603176      else
    31613177         SetNextCluster(pVolInfo, ulCluster, pVolInfo->ulFatEof);
     
    31693185      {
    31703186#endif
    3171       pDirNew->ulFileSize = pFileSize->ulFileSize;
     3187      FileSetSize(pVolInfo, pDirNew, ulDirCluster, pDirSHInfo, pszFile, pFileSize->ullFileSize);
    31723188#ifdef EXFAT
    31733189      }
     
    31753191      {
    31763192#ifdef INCL_LONGLONG
    3177       pDirStreamNew->u.Stream.ullValidDataLen = pFileSize->ulFileSize;
     3193      pDirStreamNew->u.Stream.ullValidDataLen = pFileSize->ullFileSize;
    31783194      pDirStreamNew->u.Stream.ullDataLen =
    3179          (pFileSize->ulFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    3180          ((pFileSize->ulFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
     3195         (pFileSize->ullFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     3196         ((pFileSize->ullFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
    31813197#else
    3182       AssignUL(pDirStreamNew->u.Stream.ullValidDataLen, pFileSize->ulFileSize);
    3183       AssignUL(pDirStreamNew->u.Stream.ullDataLen,
    3184          (pFileSize->ulFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    3185          ((pFileSize->ulFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0));
    3186 #endif
    3187       }
    3188 #endif
    3189 
    3190    if (!pFileSize->ulFileSize)
     3198      Assign(pDirStreamNew->u.Stream.ullValidDataLen, pFileSize->ullFileSize);
     3199      Assign(pDirStreamNew->u.Stream.ullDataLen,
     3200         (pFileSize->ullFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     3201         ((pFileSize->ullFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0));
     3202#endif
     3203      }
     3204#endif
     3205
     3206   if (!pFileSize->ullFileSize)
    31913207      {
    31923208#ifdef EXFAT
  • trunk/src/ifs/fat32b.c

    r301 r303  
    3333USHORT GetBuf3Access(PVOLINFO pVolInfo, PSZ pszName);
    3434VOID   ReleaseBuf3(PVOLINFO pVolInfo);
     35
     36
     37/******************************************************************
     38*
     39******************************************************************/
     40void FileSetSize(PVOLINFO pVolInfo, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, ULONGLONG ullSize)
     41{
     42   pDirEntry->ulFileSize = ullSize & 0xffffffff;
     43
     44   if (f32Parms.fFatPlus)
     45      {
     46      ULONGLONG ullTmp;
     47      ullTmp = (ULONGLONG)(pDirEntry->fEAS);
     48      ullTmp |= ((ullSize >> 32) & FILE_SIZE_MASK);
     49      pDirEntry->fEAS = (BYTE)ullTmp;
     50      pDirEntry->fEAS &= ~FILE_SIZE_EA;
     51      }
     52
     53   if ( f32Parms.fFatPlus && f32Parms.fEAS && (ullSize >> 35) )
     54      {
     55      // write EAs
     56      EAOP eaop;
     57      BYTE pBuf[sizeof(FEALIST) + 8 + 4 + sizeof(ULONGLONG)];
     58      PFEALIST pfealist = (PFEALIST)pBuf;
     59      APIRET rc;
     60
     61      pDirEntry->fEAS |= FILE_SIZE_EA | FILE_HAS_EAS;
     62
     63      memset(&eaop, 0, sizeof(eaop));
     64      memset(pfealist, 0, sizeof(pBuf));
     65      eaop.fpFEAList = pfealist;
     66      pfealist->cbList = sizeof(pBuf);
     67      pfealist->list[0].fEA = FEA_NEEDEA; // critical EA
     68      strcpy((PBYTE)((PFEA)pfealist->list + 1), "FAT+FSZ");
     69      pfealist->list[0].cbName  = 8 - 1;
     70      pfealist->list[0].cbValue = 4 + sizeof(ULONGLONG);
     71      *(PUSHORT)((PBYTE)((PFEA)pfealist->list + 1) + 8) = EAT_BINARY;  // EA type
     72      *(PUSHORT)((PBYTE)((PFEA)pfealist->list + 1) + 10) = 8;          // length
     73      *(PULONGLONG)((PBYTE)((PFEA)pfealist->list + 1) + 12) = ullSize; // value
     74
     75      rc = usModifyEAS(pVolInfo, ulDirCluster, pDirSHInfo, pszFile, &eaop);
     76      }
     77}
     78
     79
     80/******************************************************************
     81*
     82******************************************************************/
     83void FileGetSize(PVOLINFO pVolInfo, PDIRENTRY pDirEntry, ULONG ulDirCluster,
     84                 PSHOPENINFO pDirSHInfo, PSZ pszFile, PULONGLONG pullSize)
     85{
     86   *pullSize = pDirEntry->ulFileSize;
     87
     88   if (f32Parms.fFatPlus)
     89      {
     90      *pullSize |= (((ULONGLONG)(pDirEntry->fEAS) & FILE_SIZE_MASK) << 32);
     91      }
     92
     93   if ( f32Parms.fFatPlus && f32Parms.fEAS && (pDirEntry->fEAS & FILE_SIZE_EA) )
     94      {
     95      // read EAs
     96      EAOP eaop;
     97      BYTE pBuf1[sizeof(GEALIST) + 7];
     98      PGEALIST pgealist = (PGEALIST)pBuf1;
     99      BYTE pBuf2[sizeof(FEALIST) + 8 + 4 + sizeof(ULONGLONG)];
     100      PFEALIST pfealist = (PFEALIST)pBuf2;
     101      APIRET rc;
     102      int i;
     103
     104      memset(&eaop, 0, sizeof(eaop));
     105      memset(pgealist, 0, sizeof(pBuf1));
     106      memset(pfealist, 0, sizeof(pBuf2));
     107      eaop.fpGEAList = pgealist;
     108      eaop.fpFEAList = pfealist;
     109      pgealist->cbList = sizeof(GEALIST) + 7;
     110      pgealist->list[0].cbName = 7;
     111      strcpy(pgealist->list[0].szName, "FAT+FSZ");
     112      pfealist->cbList = sizeof(pBuf2);
     113
     114      rc = usGetEAS(pVolInfo, FIL_QUERYEASFROMLISTL, ulDirCluster, pDirSHInfo, pszFile, &eaop);
     115
     116      if (rc)
     117         return;
     118
     119      *pullSize = *(PULONGLONG)((PBYTE)((PFEA)pfealist->list + 1) + 12);
     120      }
     121}
    35122
    36123
  • trunk/src/ifs/ifsattr.c

    r301 r303  
    490490               if (!(pDirEntry->bAttr & FILE_DIRECTORY))
    491491                  {
     492                  FileGetSize(pVolInfo, pDirEntry, ulDirCluster, pDirSHInfo, pszFile, (PULONGLONG)&pfStatus->cbFile);
    492493#ifdef INCL_LONGLONG
    493                   pfStatus->cbFile = pDirEntry->ulFileSize;
    494494                  pfStatus->cbFileAlloc =
    495495                     (pfStatus->cbFile / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     
    499499                  LONGLONG llRest;
    500500
    501                   iAssignUL(&pfStatus->cbFile, pDirEntry->ulFileSize);
    502501                  pfStatus->cbFileAlloc = iDivUL(pfStatus->cbFile, pVolInfo->ulClusterSize);
    503502                  pfStatus->cbFileAlloc = iMulUL(pfStatus->cbFileAlloc, pVolInfo->ulClusterSize);
     
    638637               if (!(pDirEntry->bAttr & FILE_DIRECTORY))
    639638                  {
     639                  FileGetSize(pVolInfo, pDirEntry, ulDirCluster, pDirSHInfo, pszFile, (PULONGLONG)&pfStatus->cbFile);
    640640#ifdef INCL_LONGLONG
    641                   pfStatus->cbFile = pDirEntry->ulFileSize;
    642641                  pfStatus->cbFileAlloc =
    643642                     (pfStatus->cbFile / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     
    647646                  LONGLONG llRest;
    648647
    649                   iAssignUL(&pfStatus->cbFile, pDirEntry->ulFileSize);
    650648                  pfStatus->cbFileAlloc = iDivUL(pfStatus->cbFile, pVolInfo->ulClusterSize);
    651649                  pfStatus->cbFileAlloc = iMulUL(pfStatus->cbFileAlloc, pVolInfo->ulClusterSize);
  • trunk/src/ifs/ifsea.c

    r301 r303  
    670670#endif
    671671      if( HAS_OLD_EAS( pNewEntry->fEAS ))
    672            pNewEntry->fEAS = FILE_HAS_NO_EAS;
    673       pNewEntry->fEAS = ( BYTE )(( pNewEntry->fEAS & FILE_HAS_WINNT_EXT ) | fEAS );
     672           pNewEntry->fEAS &= FILE_NO_EAS_MASK;
     673      pNewEntry->fEAS = ( BYTE )(( pNewEntry->fEAS & FILE_NO_EAS_MASK ) | fEAS );
     674      //pNewEntry->fEAS = ( BYTE )(( pNewEntry->fEAS & FILE_HAS_WINNT_EXT ) | fEAS );
    674675#ifdef EXFAT
    675676      }
     
    679680      if( HAS_OLD_EAS( pNewEntry1->u.File.fEAS ) )
    680681         {
    681          pNewEntry1->u.File.fEAS = FILE_HAS_NO_EAS;
    682          }
    683       pNewEntry1->u.File.fEAS = ( BYTE )(( pNewEntry1->u.File.fEAS & FILE_HAS_WINNT_EXT ) | fEAS );
     682         pNewEntry1->u.File.fEAS &= FILE_NO_EAS_MASK;
     683         }
     684      pNewEntry1->u.File.fEAS = ( BYTE )(( pNewEntry1->u.File.fEAS & FILE_NO_EAS_MASK ) | fEAS );
     685      //pNewEntry1->u.File.fEAS = ( BYTE )(( pNewEntry1->u.File.fEAS & FILE_HAS_WINNT_EXT ) | fEAS );
    684686      }
    685687#endif
  • trunk/src/ifs/ifsfile.c

    r301 r303  
    346346            if (f32Parms.fLargeFiles)
    347347               {
    348                if (size > (ULONGLONG)ULONG_MAX)
     348               if (size > (ULONGLONG)ULONG_MAX && !f32Parms.fFatPlus)
    349349                  size = (ULONGLONG)ULONG_MAX;
    350350               }
     
    357357            if (f32Parms.fLargeFiles)
    358358               {
    359                if (GreaterUL(size, ULONG_MAX))
     359               if (GreaterUL(size, ULONG_MAX) && !f32Parms.fFatPlus)
    360360                  AssignUL(&size, ULONG_MAX);
    361361               }
     
    420420                  pDirEntry->wCluster = LOUSHORT(ulCluster);
    421421                  pDirEntry->wClusterHigh = HIUSHORT(ulCluster);
    422 #ifdef INCL_LONGLONG
    423                   pDirEntry->ulFileSize = size;
    424 #else
    425                   pDirEntry->ulFileSize = size.ulLo;
    426 #endif
     422                  //Message("006");
     423                  //FileSetSize(pVolInfo, pDirEntry, ulDirCluster, pOpenInfo->pDirSHInfo, pszFile, size);
     424                  //Message("007");
    427425#ifdef EXFAT
    428426                  }
     
    465463               }
    466464            }
     465
     466         FileSetSize(pVolInfo, pDirEntry, ulDirCluster, pOpenInfo->pDirSHInfo, pszFile, size);
    467467
    468468         rc = MakeDirEntry(pVolInfo, ulDirCluster, pDirSHInfo, pDirEntry, pDirEntryStream, pszFile);
     
    596596            pDirEntry->wClusterHigh = 0;
    597597            pDirEntry->ulFileSize   = 0;
    598             pDirEntry->fEAS = FILE_HAS_NO_EAS;
     598            pDirEntry->fEAS &= FILE_NO_EAS_MASK;
    599599#ifdef EXFAT
    600600            }
     
    605605            //pDirEntryStream->bEntryType = ENTRY_TYPE_STREAM_EXT;
    606606            pDirEntry1->u.File.usFileAttr = (BYTE)(usAttr & (FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_ARCHIVED));
    607             pDirEntry1->u.File.fEAS = FILE_HAS_NO_EAS;
     607            pDirEntry1->u.File.fEAS &= FILE_NO_EAS_MASK;
    608608            pDirEntryStream->u.Stream.ulFirstClus = 0;
    609609#ifdef INCL_LONGLONG
     
    632632         if (pVolInfo->bFatType <  FAT_TYPE_EXFAT)
    633633#endif
    634             pDirOld->fEAS = FILE_HAS_NO_EAS;
     634            pDirOld->fEAS &= FILE_NO_EAS_MASK;
    635635#ifdef EXFAT
    636636         else
    637637            {
    638638            PDIRENTRY1 pDirOld1 = (PDIRENTRY1)pDirOld;
    639             pDirOld1->u.File.fEAS = FILE_HAS_NO_EAS;
     639            pDirOld1->u.File.fEAS &= FILE_NO_EAS_MASK;
    640640            }
    641641#endif
     
    654654            if (f32Parms.fLargeFiles)
    655655               {
    656                if (size > (ULONGLONG)ULONG_MAX)
     656               if (size > (ULONGLONG)ULONG_MAX && !f32Parms.fFatPlus)
    657657                  size = (ULONGLONG)ULONG_MAX;
    658658               }
     
    665665            if (f32Parms.fLargeFiles)
    666666               {
    667                if (GreaterUL(size, ULONG_MAX))
     667               if (GreaterUL(size, ULONG_MAX) && !f32Parms.fFatPlus)
    668668                  AssignUL(&size, ULONG_MAX);
    669669               }
     
    711711                  pDirEntry->wCluster = LOUSHORT(ulCluster);
    712712                  pDirEntry->wClusterHigh = HIUSHORT(ulCluster);
    713 #ifdef INCL_LONGLONG
    714                   pDirEntry->ulFileSize = size;
    715 #else
    716                   pDirEntry->ulFileSize = size.ulLo;
    717 #endif
     713                  FileSetSize(pVolInfo, pDirEntry, ulDirCluster, pOpenInfo->pDirSHInfo, pszFile, size);
    718714#ifdef EXFAT
    719715                  }
     
    916912         {
    917913#endif
    918 #ifdef INCL_LONGLONG
    919          size = pDirEntry->ulFileSize;
    920 #else
    921          AssignUL(&size, pDirEntry->ulFileSize);
    922 #endif
     914         FileGetSize(pVolInfo, pDirEntry, pOpenInfo->pSHInfo->ulDirCluster, pOpenInfo->pDirSHInfo, pszFile, &size);
    923915         psffsi->sfi_DOSattr = pDirEntry->bAttr;
    924916#ifdef EXFAT
     
    21452137        if ( (! f32Parms.fLargeFiles && (pos + usBytesToWrite >= (LONGLONG)LONG_MAX   ||
    21462138                                        size + usBytesToWrite >= (LONGLONG)LONG_MAX)) ||
    2147              (f32Parms.fLargeFiles   && (pos + usBytesToWrite >= (LONGLONG)ULONG_MAX  ||
     2139             (f32Parms.fLargeFiles && !f32Parms.fFatPlus && (pos + usBytesToWrite >= (LONGLONG)ULONG_MAX  ||
    21482140                                        size + usBytesToWrite >= (LONGLONG)ULONG_MAX) &&
    21492141#else
     
    21552147        if ( (! f32Parms.fLargeFiles && (iGreaterEUL(llPos, LONG_MAX)   ||
    21562148                                        iGreaterEUL(llSize, LONG_MAX))) ||
    2157              (f32Parms.fLargeFiles   && (iGreaterEUL(llPos, ULONG_MAX)  ||
     2149             (f32Parms.fLargeFiles && !f32Parms.fFatPlus && (iGreaterEUL(llPos, ULONG_MAX)  ||
    21582150                                        iGreaterEUL(llSize, ULONG_MAX)) &&
    21592151#endif
     
    21822174
    21832175#ifdef EXFAT
    2184         if (f32Parms.fLargeFiles && (pVolInfo->bFatType < FAT_TYPE_EXFAT) &&
     2176        if (f32Parms.fLargeFiles && !f32Parms.fFatPlus && (pVolInfo->bFatType < FAT_TYPE_EXFAT) &&
    21852177            (LONGLONG)ULONG_MAX - pos < (LONGLONG)usBytesToWrite)
    21862178#else
    2187         if (f32Parms.fLargeFiles &&
     2179        if (f32Parms.fLargeFiles && !f32Parms.fFatPlus &&
    21882180            (LONGLONG)ULONG_MAX - pos < (LONGLONG)usBytesToWrite)
    21892181#endif
     
    22002192
    22012193#ifdef EXFAT
    2202         if (f32Parms.fLargeFiles && (pVolInfo->bFatType < FAT_TYPE_EXFAT) &&
     2194        if (f32Parms.fLargeFiles && !f32Parms.fFatPlus && (pVolInfo->bFatType < FAT_TYPE_EXFAT) &&
    22032195            iLessUL(llPos, usBytesToWrite))
    22042196#else
    2205         if (f32Parms.fLargeFiles &&
     2197        if (f32Parms.fLargeFiles && !f32Parms.fFatPlus &&
    22062198            iLessUL(llPos, usBytesToWrite))
    22072199#endif
     
    30543046            memcpy(&pDirEntry->wLastWriteDate, &psffsi->sfi_mdate, sizeof (USHORT));
    30553047
    3056 #ifdef INCL_LONGLONG
    3057             pDirEntry->ulFileSize  = (ULONG)size;
    3058 #else
    3059             pDirEntry->ulFileSize  = size.ulLo;
    3060 #endif
     3048            FileSetSize(pVolInfo, pDirEntry, pOpenInfo->pSHInfo->ulDirCluster, pOpenInfo->pDirSHInfo, pszFile, size);
    30613049#ifdef EXFAT
    30623050            }
  • trunk/src/ifs/ifsfind.c

    r299 r303  
    613613USHORT rc;
    614614ULONG  ulBlockIndex;
     615ULONGLONG ullSize;
    615616
    616617   szLongName = (PSZ)malloc((size_t)FAT32MAXPATHCOMP);
     
    780781                     pfFind->fdateLastWrite = pDir->wLastWriteDate;
    781782                     pfFind->ftimeLastWrite = pDir->wLastWriteTime;
     783
     784                     FileGetSize(pVolInfo, pDir, pFindInfo->pInfo->rgClusters[0], pFindInfo->pSHInfo, szLongName, &ullSize);
    782785#ifdef INCL_LONGLONG
    783                      pfFind->cbFile = pDir->ulFileSize;
     786                     pfFind->cbFile = ullSize;
    784787                     pfFind->cbFileAlloc =
    785788                        (pfFind->cbFile / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     
    789792                     LONGLONG llRest;
    790793
    791                      iAssignUL(&pfFind->cbFile, pDir->ulFileSize);
     794                     iAssignUL(&pfFind->cbFile, ullSize);
    792795                     pfFind->cbFileAlloc = iDivUL(pfFind->cbFile, pVolInfo->ulClusterSize);
    793796                     pfFind->cbFileAlloc = iMulUL(pfFind->cbFileAlloc, pVolInfo->ulClusterSize);
     
    881884                     pfFind->fdateLastWrite = pDir->wLastWriteDate;
    882885                     pfFind->ftimeLastWrite = pDir->wLastWriteTime;
     886
     887                     FileGetSize(pVolInfo, pDir, pFindInfo->pInfo->rgClusters[0], pFindInfo->pSHInfo, szLongName, &ullSize);
    883888#ifdef INCL_LONGLONG
    884                      pfFind->cbFile = pDir->ulFileSize;
     889                     pfFind->cbFile = ullSize;
    885890                     pfFind->cbFileAlloc =
    886891                        (pfFind->cbFile / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     
    890895                     LONGLONG llRest;
    891896
    892                      iAssignUL(&pfFind->cbFile, pDir->ulFileSize);
     897                     iAssignUL(&pfFind->cbFile, ullSize);
    893898                     pfFind->cbFileAlloc = iDivUL(pfFind->cbFile, pVolInfo->ulClusterSize);
    894899                     pfFind->cbFileAlloc = iMulUL(pfFind->cbFileAlloc, pVolInfo->ulClusterSize);
     
    10441049                     pfFind->fdateLastWrite = pDir->wLastWriteDate;
    10451050                     pfFind->ftimeLastWrite = pDir->wLastWriteTime;
     1051
     1052                     FileGetSize(pVolInfo, pDir, pFindInfo->pInfo->rgClusters[0], pFindInfo->pSHInfo, szLongName, &ullSize);
    10461053#ifdef INCL_LONGLONG
    1047                      pfFind->cbFile = pDir->ulFileSize;
     1054                     pfFind->cbFile = ullSize;
    10481055                     pfFind->cbFileAlloc =
    10491056                        (pfFind->cbFile / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     
    10531060                     LONGLONG llRest;
    10541061
    1055                      iAssignUL(&pfFind->cbFile, pDir->ulFileSize);
     1062                     iAssignUL(&pfFind->cbFile, ullSize);
    10561063                     pfFind->cbFileAlloc = iDivUL(pfFind->cbFile, pVolInfo->ulClusterSize);
    10571064                     pfFind->cbFileAlloc = iMulUL(pfFind->cbFileAlloc, pVolInfo->ulClusterSize);
  • trunk/src/ifs/libc/makefile.wcc

    r260 r303  
    1414     $(PROJ_BLD)\i8d086.obj &
    1515     $(PROJ_BLD)\i8m086.obj &
     16     $(PROJ_BLD)\i8ls086.obj &
     17     $(PROJ_BLD)\i8rs086.obj &
     18     $(PROJ_BLD)\u8rs086.obj &
    1619     $(PROJ_BLD)\pia.obj &
    1720     $(PROJ_BLD)\pts.obj &
  • trunk/src/include/devhelp.h

    r302 r303  
    369369    "les     bx, [esp+12]" \
    370370    "mov     es:[bx], eax" \
    371     "xor    ax, ax" \
     371    "xor     ax, ax" \
    372372    "error:" \
    373373    value [ax] \
  • trunk/src/include/fat32def.h

    r290 r303  
    168168#define EA_EXTENTION " EA. SF"
    169169#define FILE_HAS_NO_EAS             0x00
    170 #define FILE_HAS_EAS                0x40
     170#define FILE_NO_EAS_MASK            0x3F   // no EAs AND mask
     171#define FILE_SIZE_MASK              7ULL   // FAT+: three lower bits (size)
     172#define FILE_SIZE_EA                0x20   // FAT+: file size in EAs
     173#define FILE_HAS_EAS                0x40   // file EAs in "file .EA SF" file
     174#define FILE_EA_DATA_SF_EAS         0x80   // file EAs in "ea data. sf" file
    171175#define FILE_HAS_CRITICAL_EAS       0x80
    172176#define FILE_HAS_OLD_EAS            0xEA
     
    315319CHAR   fFat;
    316320CHAR   fExFat;
     321CHAR   fFatPlus;
    317322} F32PARMS, *PF32PARMS;
    318323
     
    417422{
    418423BYTE   szFileName[FAT32MAXPATH];
    419 ULONG  ulFileSize;
     424ULONGLONG ullFileSize;
    420425} FILESIZEDATA, *PFILESIZEDATA;
    421426
  • trunk/src/include/fat32ifs.h

    r299 r303  
    349349IMPORT PVOLINFO GetVolInfo(USHORT hVBP);
    350350IMPORT VOID   MakeName(PDIRENTRY pDir, PSZ pszName, USHORT usMax);
     351void FileSetSize(PVOLINFO pVolInfo, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, ULONGLONG ullSize);
     352void FileGetSize(PVOLINFO pVolInfo, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, PULONGLONG pullSize);
    351353IMPORT BOOL   fGetLongName(PDIRENTRY pDir, PSZ pszName, USHORT wMax, PBYTE pbCheck);
    352354IMPORT BOOL   fGetLongName1(PDIRENTRY1 pDir, PSZ pszName, USHORT wMax);
  • trunk/src/include/fsd.h

    r302 r303  
    110110 };
    111111
    112 
    113112 #define IOFL_WRITETHRU     0x10
    114113 #define IOFL_NOCACHE       0x20
     
    709708 );
    710709
    711 #define FOC_NEEDEAS      0x1
     710 #define FOC_NEEDEAS      0x1
    712711
    713712 int far pascal _loadds FS_OPENCREATE(
  • trunk/src/include/portable.h

    r260 r303  
    343343typedef void _far *     PFVOID ;    /* p Far Pointer to near void */
    344344
    345 #endif
     345#ifndef __OS2__
     346
     347#define ERROR_EA_LIST_TOO_LONG          256
     348
     349#define FEA_NEEDEA   0x80
     350#define EAT_BINARY   0xFFFE
     351
     352#define FIL_QUERYEASFROMLIST   3
     353#define FIL_QUERYEASFROMLISTL 13
     354
     355typedef struct _GEA {
     356    BYTE cbName;
     357    CHAR szName[1];
     358} GEA, *PGEA;
     359
     360typedef struct _GEALIST {
     361    ULONG cbList;
     362    GEA list[1];
     363} GEALIST, *PGEALIST;
     364
     365typedef struct _FEA {
     366    BYTE fEA;
     367    BYTE cbName;
     368    USHORT cbValue;
     369} FEA, *PFEA;
     370
     371typedef struct _FEALIST {
     372    ULONG cbList;
     373    FEA list[1];
     374} FEALIST, *PFEALIST;
     375
     376typedef struct _EAOP {
     377    PGEALIST fpGEAList;
     378    PFEALIST fpFEAList;
     379    ULONG    oError;
     380} EAOP, *PEAOP;
     381#endif
     382
     383#endif
  • trunk/src/include/reqpkt.h

    r302 r303  
    206206 } RPSAVERESTORE, FAR *PRPSAVERESTORE;
    207207
    208 
    209208 //
    210209 // Shutdown
  • trunk/src/ufat32/chkdsk.c

    r298 r303  
    2828#include <conio.h>
    2929
     30#include "fat32c.h"
    3031#include "portable.h"
    31 #include "fat32c.h"
    3232
    3333#define STACKSIZE 0x20000
     
    110110void SetSHInfo1(PCDINFO pCD, PDIRENTRY1 pStreamEntry, PSHOPENINFO pSHInfo);
    111111APIRET DelFile(PCDINFO pCD, PSZ pszFilename);
     112void FileGetSize(PCDINFO pCD, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, PULONGLONG pullSize);
     113void FileSetSize(PCDINFO pCD, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, ULONGLONG ullSize);
    112114
    113115USHORT _Far16 _Pascal _loadds INIT16(HMODULE hmod, ULONG flag);
     
    14001402            if (pCD->fDetailed == 2)
    14011403               {
     1404               ULONGLONG ullSize;
     1405               FileGetSize(pCD, pDir, ulDirCluster, NULL, szLongName, &ullSize);
     1406
    14021407               show_message("%-13.13s", 0, 0, 1, MakeName(pDir, szShortName, sizeof(szShortName)));
    14031408               if (pDir->bAttr & FILE_DIRECTORY)
    14041409                  show_message("<DIR>      ", 0, 0, 0);
    14051410               else
    1406                   show_message("%10lu ", 0, 0, 1, pDir->ulFileSize);
     1411                  show_message("%10llu ", 0, 0, 1, ullSize);
    14071412
    14081413               show_message("%s ", 0, 0, 1, szLongName);
     
    14531458               DIRENTRY DirEntry;
    14541459               PSZ pszFile;
     1460               ULONGLONG ullSize;
    14551461
    14561462               strcpy(Mark.szFileName, pbPath);
     
    14681474                     rc = ERROR_FILE_NOT_FOUND;
    14691475                  }
     1476
     1477               FileGetSize(pCD, &DirEntry, ulDirCluster, NULL, pszFile, &ullSize);
     1478
    14701479               if (rc)
    14711480                  {
     
    14851494                     }
    14861495                  }
    1487                else if (!DirEntry.ulFileSize)
     1496               else if (!ullSize)
    14881497                  {
    14891498                  show_message("%s is marked having EAs, but the EA file (%s) is empty\n", 0, 0, 2, pbPath, Mark.szFileName);
     
    15061515            if (!(pDir->bAttr & FILE_DIRECTORY))
    15071516               {
    1508                ulClustersNeeded = pDir->ulFileSize / pCD->ulClusterSize +
    1509                   (pDir->ulFileSize % pCD->ulClusterSize ? 1:0);
     1517               ULONGLONG ullSize;
     1518               FileGetSize(pCD, pDir, ulDirCluster, NULL, pbPath, &ullSize);
     1519               ulClustersNeeded = ullSize / pCD->ulClusterSize +
     1520                  (ullSize % pCD->ulClusterSize ? 1:0);
    15101521               ulClustersUsed = GetClusterCount(pCD,((ULONG)pDir->wClusterHigh * 0x10000 + pDir->wCluster) & pCD->ulFatEof, NULL, pbPath);
    15111522               pEA = strstr(pbPath, EA_EXTENTION);
    1512                if (f32Parms.fEAS && pEA && pDir->ulFileSize)
     1523               if (f32Parms.fEAS && pEA && ullSize)
    15131524                  {
    15141525                  ULONG rc;
     
    16371648                        strcat(fs.szFileName, "\\");
    16381649                     strcat(fs.szFileName, MakeName(pDir, szShortName, sizeof(szShortName)));
    1639                      fs.ulFileSize = ulClustersUsed * pCD->ulClusterSize;
     1650                     fs.ullFileSize = ulClustersUsed * pCD->ulClusterSize;
    16401651                     rc = SetFileSize(pCD, (PFILESIZEDATA)&fs);
    16411652                     strcpy( strrchr( fs.szFileName, '\\' ) + 1, szLongName );
     
    22652276                           strcat(fs.szFileName, "\\");
    22662277                        strcat(fs.szFileName, MakeName((PDIRENTRY)pDir, szShortName, sizeof(szShortName))); ////
    2267                         fs.ulFileSize = ulClustersUsed * pCD->ulClusterSize;
     2278                        fs.ullFileSize = ulClustersUsed * pCD->ulClusterSize;
    22682279                        rc = SetFileSize(pCD, (PFILESIZEDATA)&fs);
    22692280                        strcpy( strrchr( fs.szFileName, '\\' ) + 1, szLongName );
  • trunk/src/ufat32/fatfunc.c

    r298 r303  
    1717#define LONGNAME_MAKE_UNIQUE 2
    1818#define LONGNAME_ERROR       3
     19
     20typedef struct _EAOP EAOP;
     21typedef struct _EAOP *PEAOP;
     22typedef struct _FEALIST FEALIST;
     23typedef struct _FEALIST *PFEALIST;
    1924
    2025BYTE rgValidChars[]="01234567890 ABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&'()-_@^`{}~";
     
    9297void SetSHInfo1(PCDINFO pCD, PDIRENTRY1 pStreamEntry, PSHOPENINFO pSHInfo);
    9398APIRET DelFile(PCDINFO pCD, PSZ pszFilename);
     99void FileGetSize(PCDINFO pCD, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, PULONGLONG pullSize);
     100void FileSetSize(PCDINFO pCD, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, ULONGLONG ullSize);
     101USHORT usModifyEAS(PCDINFO pCD, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFileName, PEAOP pEAOP);
     102USHORT usGetEAS(PCDINFO pCD, USHORT usLevel, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFileName, PEAOP pEAOP);
    94103
    95104void set_datetime(DIRENTRY *pDir);
     
    11841193}
    11851194
    1186 /************************************************************************
    1187 *
    1188 ************************************************************************/
    1189 APIRET MarkFileEAS(PCDINFO pCD, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFileName, BYTE fEAS)
    1190 {
    1191    ULONG ulCluster;
    1192    DIRENTRY OldEntry, NewEntry;
    1193    DIRENTRY1 OldEntryStream;
    1194    PDIRENTRY1 pNewEntry = (PDIRENTRY1)&NewEntry;
    1195    APIRET rc;
    1196 
    1197    ulCluster = FindPathCluster(pCD, ulDirCluster, pszFileName, pDirSHInfo, &OldEntry, &OldEntryStream, NULL);
    1198    if (ulCluster == pCD->ulFatEof)
    1199       return ERROR_FILE_NOT_FOUND;
    1200    memcpy(&NewEntry, &OldEntry, sizeof (DIRENTRY));
    1201 #ifdef EXFAT
    1202    if (pCD->bFatType < FAT_TYPE_EXFAT)
    1203       {
    1204 #endif
    1205       if( HAS_OLD_EAS( NewEntry.fEAS ))
    1206          NewEntry.fEAS = FILE_HAS_NO_EAS;
    1207       NewEntry.fEAS = ( BYTE )(( NewEntry.fEAS & FILE_HAS_WINNT_EXT ) | fEAS );
    1208 #ifdef EXFAT
    1209       }
    1210    else
    1211       {
    1212       if( HAS_OLD_EAS( pNewEntry->u.File.fEAS ))
    1213            pNewEntry->u.File.fEAS = FILE_HAS_NO_EAS;
    1214       pNewEntry->u.File.fEAS = ( BYTE )(( pNewEntry->u.File.fEAS & FILE_HAS_WINNT_EXT ) | fEAS );
    1215       }
    1216 #endif
    1217 
    1218    if (!memcmp(&NewEntry, &OldEntry, sizeof (DIRENTRY)))
    1219       return 0;
    1220 
    1221    rc = ModifyDirectory(pCD, ulDirCluster, pDirSHInfo,
    1222       MODIFY_DIR_UPDATE, &OldEntry, &NewEntry, &OldEntryStream, NULL, NULL);
    1223 
    1224    return rc;
    1225 }
    12261195
    12271196/************************************************************************
     
    16651634//ULONG     ulPrevBlock;
    16661635ULONG     ulNextCluster = pCD->ulFatEof;
     1636ULONG     ulCluster2;
    16671637PDIRENTRY1 pLNStart;
    16681638USHORT    rc;
     
    18101780         case MODIFY_DIR_UPDATE :
    18111781         case MODIFY_DIR_DELETE :
     1782            memcpy(pDirectory, pDir2, pCD->ulClusterSize);
     1783            ulCluster2 = GetNextCluster(pCD, pDirSHInfo, ulCluster, FALSE);
     1784            if (ulCluster2 != pCD->ulFatEof)
     1785               {
     1786               rc = ReadCluster(pCD, ulCluster2, pDir2);
     1787               if (rc)
     1788                  {
     1789                  //free(pDirectory);
     1790                  mem_free(pDirectory, 2 * (size_t)pCD->ulClusterSize);
     1791                  return rc;
     1792                  }
     1793               }
     1794            else
     1795               memset(pDir2, 0, pCD->ulClusterSize);
    18121796 
    18131797           /*
     
    18161800 
    18171801            fFound = FALSE;
    1818             pWork = pDir2;
     1802            pWorkFile = NULL;
     1803            pWork = pDirectory;
     1804            //pWork = pDir2;
    18191805            pDir1 = NULL;
    1820             while (pWork != pMax)
     1806            pMax = (PDIRENTRY1)((PBYTE)pDirectory + ulBytesToRead);
     1807            while (pWorkFile < pMax && !pLNStart)
     1808            //while (pWork != pMax)
    18211809               {
    18221810               //if (pWork->bFileName[0] && pWork->bFileName[0] != DELETED_ENTRY)
     
    18631851               }
    18641852
    1865             if (pWork != pMax)
     1853            if (fFound)
     1854            //if (pWork != pMax)
    18661855               {
    18671856               switch (usMode)
     
    18781867                     pWorkFile->u.File.usSetCheckSum = GetChkSum16((char *)pWorkFile,
    18791868                        sizeof(DIRENTRY1) * (pWorkFile->u.File.bSecondaryCount + 1));
    1880                      //if (ulCluster == 1)
    1881                      //   // reading root directory on FAT12/FAT16
    1882                      //   rc = WriteSector(pCD, ulSector + ulCluster * usSectorsPerCluster, usSectorsPerCluster, (void *)pDir2);
    1883                      //else
    1884                         rc = WriteCluster(pCD, ulCluster, pDir2);
     1869                     rc = WriteCluster(pCD, ulCluster, pDirectory);
    18851870                     if (rc)
    18861871                        {
     
    18881873                        mem_free(pDirectory, 2 * (size_t)pCD->ulClusterSize);
    18891874                        return rc;
     1875                        }
     1876                     if (ulCluster2 != pCD->ulFatEof)
     1877                        {
     1878                        //if (ulCluster == 1)
     1879                        //   // reading root directory on FAT12/FAT16
     1880                        //   rc = WriteSector(pCD, ulSector + ulCluster * usSectorsPerCluster, usSectorsPerCluster, (void *)pDir2);
     1881                        //else
     1882                           rc = WriteCluster(pCD, ulCluster2, pDir2);
     1883                        if (rc)
     1884                           {
     1885                           //free(pDirectory);
     1886                           mem_free(pDirectory, 2 * (size_t)pCD->ulClusterSize);
     1887                           return rc;
     1888                           }
    18901889                        }
    18911890                     ulCluster = pCD->ulFatEof;
     
    19321931                     Write current cluster
    19331932                     */
    1934                      //if (ulCluster == 1)
    1935                      //   // reading root directory on FAT12/FAT16
    1936                      //   rc = WriteSector(pCD, ulSector + ulCluster * usSectorsPerCluster, usSectorsPerCluster, (void *)pDir2);
    1937                      //else
    1938                         rc = WriteCluster(pCD, ulCluster, pDir2);
     1933                     rc = WriteCluster(pCD, ulCluster, pDirectory);
    19391934                     if (rc)
    19401935                        {
     
    19421937                        mem_free(pDirectory, 2 * (size_t)pCD->ulClusterSize);
    19431938                        return rc;
     1939                        }
     1940                     if (ulCluster2 != pCD->ulFatEof)
     1941                        {
     1942                        //if (ulCluster == 1)
     1943                        //   // reading root directory on FAT12/FAT16
     1944                        //   rc = WriteSector(pCD, ulSector + ulCluster * usSectorsPerCluster, usSectorsPerCluster, (void *)pDir2);
     1945                        //else
     1946                           rc = WriteCluster(pCD, ulCluster2, pDir2);
     1947                        if (rc)
     1948                           {
     1949                           //free(pDirectory);
     1950                           mem_free(pDirectory, 2 * (size_t)pCD->ulClusterSize);
     1951                           return rc;
     1952                           }
    19441953                        }
    19451954
     
    31553164      return ERROR_FILE_NOT_FOUND;
    31563165   if (!ulCluster)
    3157       pFileSize->ulFileSize = 0L;
    3158 
    3159    ulClustersNeeded = pFileSize->ulFileSize / pCD->ulClusterSize;
    3160    if (pFileSize->ulFileSize % pCD->ulClusterSize)
     3166      pFileSize->ullFileSize = 0L;
     3167
     3168   ulClustersNeeded = pFileSize->ullFileSize / pCD->ulClusterSize;
     3169   if (pFileSize->ullFileSize % pCD->ulClusterSize)
    31613170      ulClustersNeeded++;
    31623171
     
    31693178#endif
    31703179
    3171    if (pFileSize->ulFileSize > 0 )
     3180   if (pFileSize->ullFileSize > 0 )
    31723181      {
    31733182      ulClustersUsed = 1;
     
    31833192         }
    31843193      if (ulCluster == pCD->ulFatEof)
    3185          pFileSize->ulFileSize = ulClustersUsed * pCD->ulClusterSize;
     3194         pFileSize->ullFileSize = ulClustersUsed * pCD->ulClusterSize;
    31863195      else
    31873196         SetNextCluster(pCD, ulCluster, pCD->ulFatEof);
     
    31933202      {
    31943203#endif
    3195       DirNew.ulFileSize = pFileSize->ulFileSize;
     3204      ULONGLONG ullSize;
     3205      FileSetSize(pCD, &DirNew, ulDirCluster, pDirSHInfo, pszFile, pFileSize->ullFileSize);
    31963206#ifdef EXFAT
    31973207      }
    31983208   else
    31993209      {
    3200       DirStreamNew.u.Stream.ullValidDataLen = pFileSize->ulFileSize;
     3210      DirStreamNew.u.Stream.ullValidDataLen = pFileSize->ullFileSize;
    32013211      DirStreamNew.u.Stream.ullDataLen =
    3202          (pFileSize->ulFileSize / pCD->ulClusterSize) * pCD->ulClusterSize +
    3203          ((pFileSize->ulFileSize % pCD->ulClusterSize) ? pCD->ulClusterSize : 0);
    3204       }
    3205 #endif
    3206 
    3207    if (!pFileSize->ulFileSize)
     3212         (pFileSize->ullFileSize / pCD->ulClusterSize) * pCD->ulClusterSize +
     3213         ((pFileSize->ullFileSize % pCD->ulClusterSize) ? pCD->ulClusterSize : 0);
     3214      }
     3215#endif
     3216
     3217   if (!pFileSize->ullFileSize)
    32083218      {
    32093219#ifdef EXFAT
     
    34683478      if (pCD->bFatType < FAT_TYPE_EXFAT)
    34693479#endif
    3470          DirEntry.ulFileSize += pCD->ulClusterSize;
     3480         {
     3481         ULONGLONG ullSize;
     3482         FileGetSize(pCD, &DirEntry, ulDirCluster, NULL, szFileName, &ullSize);
     3483         ullSize += pCD->ulClusterSize;
     3484         FileSetSize(pCD, &DirEntry, ulDirCluster, NULL, szFileName, ullSize);
     3485         }
    34713486#ifdef EXFAT
    34723487      else
     
    40454060               NewEntry.wCluster = LOUSHORT(ulCluster);
    40464061               NewEntry.wClusterHigh = HIUSHORT(ulCluster);
    4047                NewEntry.ulFileSize = cbBuf;
     4062               FileSetSize(pCD, &NewEntry, ulDirCluster, pDirSHInfo, pszFile, cbBuf);
    40484063#ifdef EXFAT
    40494064               }
     
    40674082
    40684083   if (! file_exists || pszOldFile)
    4069       rc = MakeDirEntry(pCD, ulDirCluster, pDirSHInfo, &NewEntry, &NewEntryStream, pszFileName); ////
     4084      rc = MakeDirEntry(pCD, ulDirCluster, pDirSHInfo, &NewEntry, &NewEntryStream, pszFileName);
    40704085   else
    40714086      rc = ModifyDirectory(pCD, ulDirCluster, NULL, MODIFY_DIR_UPDATE,
     
    41594174   return rc;
    41604175}
     4176
     4177/************************************************************************
     4178*
     4179************************************************************************/
     4180void FileSetSize(PCDINFO pCD, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, ULONGLONG ullSize)
     4181{
     4182   pDirEntry->ulFileSize = ullSize & 0xffffffff;
     4183
     4184   //if (f32Parms.fFatPlus)
     4185      {
     4186      ULONGLONG ullTmp;
     4187      ullTmp = (ULONGLONG)(pDirEntry->fEAS);
     4188      ullSize >>= 32;
     4189      ullTmp |= (ullSize & FILE_SIZE_MASK);
     4190      pDirEntry->fEAS = (BYTE)ullTmp;
     4191      }
     4192
     4193   if ( (ullSize >> 35) )
     4194      {
     4195      // write EAs
     4196      EAOP eaop;
     4197      BYTE pBuf[sizeof(FEALIST) + 8 + 4 + sizeof(ULONGLONG)];
     4198      PFEALIST pfealist = (PFEALIST)pBuf;
     4199      APIRET rc;
     4200
     4201      pDirEntry->fEAS |= FILE_SIZE_EA | FILE_HAS_EAS;
     4202
     4203      memset(&eaop, 0, sizeof(eaop));
     4204      memset(pfealist, 0, sizeof(pBuf));
     4205      eaop.fpFEAList = pfealist;
     4206      pfealist->cbList = sizeof(pBuf);
     4207      pfealist->list[0].fEA = FEA_NEEDEA; // critical EA
     4208      strcpy((PBYTE)((PFEA)pfealist->list + 1), "FAT+FSZ");
     4209      pfealist->list[0].cbName  = 8 - 1;
     4210      pfealist->list[0].cbValue = 4 + sizeof(ULONGLONG);
     4211      *(PUSHORT)((PBYTE)((PFEA)pfealist->list + 1) + 8) = EAT_BINARY;  // EA type
     4212      *(PUSHORT)((PBYTE)((PFEA)pfealist->list + 1) + 10) = 8;          // length
     4213      *(PULONGLONG)((PBYTE)((PFEA)pfealist->list + 1) + 12) = ullSize; // value
     4214
     4215      rc = usModifyEAS(pCD, ulDirCluster, pDirSHInfo, pszFile, &eaop);
     4216      }
     4217}
     4218
     4219
     4220/************************************************************************
     4221*
     4222************************************************************************/
     4223void FileGetSize(PCDINFO pCD, PDIRENTRY pDirEntry, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo, PSZ pszFile, PULONGLONG pullSize)
     4224{
     4225   *pullSize = pDirEntry->ulFileSize;
     4226
     4227   //if (f32Parms.fFatPlus)
     4228      {
     4229      *pullSize |= (((ULONGLONG)(pDirEntry->fEAS) & FILE_SIZE_MASK) << 32);
     4230      }
     4231
     4232   if ( (pDirEntry->fEAS & FILE_SIZE_EA) )
     4233      {
     4234      // read EAs
     4235      EAOP eaop;
     4236      BYTE pBuf1[sizeof(GEALIST) + 7];
     4237      PGEALIST pgealist = (PGEALIST)pBuf1;
     4238      BYTE pBuf2[sizeof(FEALIST) + 8 + 4 + sizeof(ULONGLONG)];
     4239      PFEALIST pfealist = (PFEALIST)pBuf2;
     4240      APIRET rc;
     4241      int i;
     4242
     4243      memset(&eaop, 0, sizeof(eaop));
     4244      memset(pgealist, 0, sizeof(pBuf1));
     4245      memset(pfealist, 0, sizeof(pBuf2));
     4246      eaop.fpGEAList = pgealist;
     4247      eaop.fpFEAList = pfealist;
     4248      pgealist->cbList = sizeof(GEALIST) + 7;
     4249      pgealist->list[0].cbName = 7;
     4250      strcpy(pgealist->list[0].szName, "FAT+FSZ");
     4251      pfealist->cbList = sizeof(pBuf2);
     4252
     4253      rc = usGetEAS(pCD, FIL_QUERYEASFROMLISTL, ulDirCluster, pDirSHInfo, pszFile, &eaop);
     4254
     4255      if (rc)
     4256         return;
     4257
     4258      *pullSize = *(PULONGLONG)((PBYTE)((PFEA)pfealist->list + 1) + 12);
     4259      }
     4260}
  • trunk/src/ufat32/makefile.wcc

    r278 r303  
    2525      $(PROJ_BLD)\format.obd $(PROJ_BLD)\os2.obd $(PROJ_BLD)\msg.obd &
    2626      $(PROJ_BLD)\chkdsk.obd $(PROJ_BLD)\fatfunc.obd $(PROJ_BLD)\unicode.obd &
    27       $(PROJ_BLD)\log.obd $(PROJ_BLD)\init.obd
     27      $(PROJ_BLD)\ea.obd $(PROJ_BLD)\log.obd $(PROJ_BLD)\init.obd
    2828OBJS2=$(PROJ_BLD)\format.obj $(PROJ_BLD)\os2.obj $(PROJ_BLD)\msg.obj &
    2929      $(PROJ_BLD)\log.obj
    3030OBJS3=$(PROJ_BLD)\chkdsk.obc $(PROJ_BLD)\os2.obc $(PROJ_BLD)\msg.obc &
    31       $(PROJ_BLD)\fatfunc.obc $(PROJ_BLD)\unicode.obc $(PROJ_BLD)\log.obc
     31      $(PROJ_BLD)\fatfunc.obc $(PROJ_BLD)\unicode.obc $(PROJ_BLD)\log.obc $(PROJ_BLD)\ea.obc
    3232OBJS4=$(PROJ_BLD)\sys.obj $(PROJ_BLD)\os2.obj &
    3333      $(PROJ_BLD)\msg.obj $(PROJ_BLD)\log.obj
  • trunk/src/ufat32/win32/makefile.wcc

    r266 r303  
    2424      $(PROJ_BLD)\sys.obd $(PROJ_BLD)\recover.obd &
    2525      $(PROJ_BLD)\chkdsk.obd $(PROJ_BLD)\fatfunc.obd &
    26       $(PROJ_BLD)\log.obd
     26      $(PROJ_BLD)\ea.obd $(PROJ_BLD)\log.obd
    2727OBJS2=$(PROJ_BLD)\format.obj $(PROJ_BLD)\win32.obj &
    2828      $(PROJ_BLD)\log.obj
    2929OBJS3=$(PROJ_BLD)\chkdsk.obc $(PROJ_BLD)\win32.obc &
    30       $(PROJ_BLD)\fatfunc.obc $(PROJ_BLD)\log.obc
     30      $(PROJ_BLD)\fatfunc.obc $(PROJ_BLD)\ea.obc $(PROJ_BLD)\log.obc
    3131OBJS4=$(PROJ_BLD)\sys.obj $(PROJ_BLD)\win32.obj &
    3232      $(PROJ_BLD)\log.obj
Note: See TracChangeset for help on using the changeset viewer.