Changeset 284


Ignore:
Timestamp:
Jul 1, 2017, 11:05:29 PM (3 years ago)
Author:
Valery V. Sedletski
Message:

fat32.ifs: Make more conservative stack usage.

  • Use less stack space. Change all local buffers to dynamically allocated buffers. This should fix kernel stack overflow errors.
Location:
trunk/src/ifs
Files:
10 edited

Legend:

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

    r283 r284  
    129129PSZ   pszSrcFile;
    130130PSZ   pszDstFile;
    131 DIRENTRY DirEntry;
    132 PDIRENTRY1 pDirEntry = (PDIRENTRY1)&DirEntry;
    133 DIRENTRY TarEntry;
    134 PDIRENTRY1 pTarEntry = (PDIRENTRY1)&TarEntry;
    135 DIRENTRY1 DirStreamEntry;
    136 DIRENTRY1 TarStreamEntry;
    137 DIRENTRY1 DirSrcStream;
    138 DIRENTRY1 DirDstStream;
    139 #ifdef EXFAT
    140 SHOPENINFO DirSrcSHInfo, DirDstSHInfo;
    141 SHOPENINFO SrcSHInfo;
     131PDIRENTRY pDirEntry;
     132PDIRENTRY pTarEntry;
     133PDIRENTRY1 pDirStreamEntry = NULL;
     134PDIRENTRY1 pTarStreamEntry = NULL;
     135PDIRENTRY1 pDirSrcStream = NULL;
     136PDIRENTRY1 pDirDstStream = NULL;
     137#ifdef EXFAT
     138PDIRENTRY1 pDirEntry1;
     139PDIRENTRY1 pTarEntry1;
    142140#endif
    143141PSHOPENINFO pSrcSHInfo = NULL;
     
    147145USHORT   rc, rc2;
    148146POPENINFO pOpenInfo = NULL;
    149 BYTE     szSrcLongName[ FAT32MAXPATH ];
    150 BYTE     szDstLongName[ FAT32MAXPATH ];
     147//BYTE     szSrcLongName[ FAT32MAXPATH ];
     148PSZ      szSrcLongName;
     149//BYTE     szDstLongName[ FAT32MAXPATH ];
     150PSZ      szDstLongName;
    151151
    152152   _asm push es;
     
    178178      }
    179179   memset(pOpenInfo, 0, sizeof (OPENINFO));
     180
     181   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     182   if (!pDirEntry)
     183      {
     184      rc = ERROR_NOT_ENOUGH_MEMORY;
     185      goto FS_COPYEXIT;
     186      }
     187   pTarEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     188   if (!pTarEntry)
     189      {
     190      rc = ERROR_NOT_ENOUGH_MEMORY;
     191      goto FS_COPYEXIT;
     192      }
     193#ifdef EXFAT
     194   pDirEntry1 = (PDIRENTRY1)pDirEntry;
     195   pTarEntry1 = (PDIRENTRY1)pTarEntry;
     196
     197   pDirStreamEntry = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     198   if (!pDirStreamEntry)
     199      {
     200      rc = ERROR_NOT_ENOUGH_MEMORY;
     201      goto FS_COPYEXIT;
     202      }
     203   pTarStreamEntry = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     204   if (!pTarStreamEntry)
     205      {
     206      rc = ERROR_NOT_ENOUGH_MEMORY;
     207      goto FS_COPYEXIT;
     208      }
     209   pDirSrcStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     210   if (!pDirSrcStream)
     211      {
     212      rc = ERROR_NOT_ENOUGH_MEMORY;
     213      goto FS_COPYEXIT;
     214      }
     215   pDirDstStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     216   if (!pDirDstStream)
     217      {
     218      rc = ERROR_NOT_ENOUGH_MEMORY;
     219      goto FS_COPYEXIT;
     220      }
     221   pDirSrcSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     222   if (!pDirSrcSHInfo)
     223      {
     224      rc = ERROR_NOT_ENOUGH_MEMORY;
     225      goto FS_COPYEXIT;
     226      }
     227   pDirDstSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     228   if (!pDirDstSHInfo)
     229      {
     230      rc = ERROR_NOT_ENOUGH_MEMORY;
     231      goto FS_COPYEXIT;
     232      }
     233   pSrcSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     234   if (!pSrcSHInfo)
     235      {
     236      rc = ERROR_NOT_ENOUGH_MEMORY;
     237      goto FS_COPYEXIT;
     238      }
     239#endif
    180240
    181241   /*
     
    185245      {
    186246      rc = ERROR_CANNOT_COPY;
     247      goto FS_COPYEXIT;
     248      }
     249
     250   szSrcLongName = (PSZ)malloc((size_t)FAT32MAXPATH);
     251   if (!szSrcLongName)
     252      {
     253      rc = ERROR_NOT_ENOUGH_MEMORY;
     254      goto FS_COPYEXIT;
     255      }
     256
     257   szDstLongName = (PSZ)malloc((size_t)FAT32MAXPATH);
     258   if (!szDstLongName)
     259      {
     260      rc = ERROR_NOT_ENOUGH_MEMORY;
    187261      goto FS_COPYEXIT;
    188262      }
     
    243317      RETURN_PARENT_DIR,
    244318      &pszSrcFile,
    245       &DirSrcStream);
     319      pDirSrcStream);
    246320
    247321   if (ulSrcDirCluster == pVolInfo->ulFatEof)
     
    254328   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    255329      {
    256       pDirSrcSHInfo = &DirSrcSHInfo;
    257       SetSHInfo1(pVolInfo, &DirSrcStream, pDirSrcSHInfo);
     330      SetSHInfo1(pVolInfo, pDirSrcStream, pDirSrcSHInfo);
    258331      }
    259332#endif
    260333
    261334   ulSrcCluster = FindPathCluster(pVolInfo, ulSrcDirCluster, pszSrcFile,
    262       pDirSrcSHInfo, &DirEntry, &DirStreamEntry, NULL);
     335      pDirSrcSHInfo, pDirEntry, pDirStreamEntry, NULL);
    263336   if (ulSrcCluster == pVolInfo->ulFatEof)
    264337      {
     
    270343   */
    271344#ifdef EXFAT
    272    if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (DirEntry.bAttr & FILE_DIRECTORY)) ||
    273         ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pDirEntry->u.File.usFileAttr & FILE_DIRECTORY)) )
     345   if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (pDirEntry->bAttr & FILE_DIRECTORY)) ||
     346        ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pDirEntry1->u.File.usFileAttr & FILE_DIRECTORY)) )
    274347#else
    275    if ( DirEntry.bAttr & FILE_DIRECTORY )
     348   if ( pDirEntry->bAttr & FILE_DIRECTORY )
    276349#endif
    277350      {
     
    307380      RETURN_PARENT_DIR,
    308381      &pszDstFile,
    309       &DirDstStream);
     382      pDirDstStream);
    310383
    311384   if (ulDstDirCluster == pVolInfo->ulFatEof)
     
    318391   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    319392      {
    320       pDirDstSHInfo = &DirDstSHInfo;
    321       SetSHInfo1(pVolInfo, &DirDstStream, pDirDstSHInfo);
     393      SetSHInfo1(pVolInfo, pDirDstStream, pDirDstSHInfo);
    322394      }
    323395#endif
     
    326398
    327399   ulDstCluster = FindPathCluster(pVolInfo, ulDstDirCluster, pszDstFile,
    328       pDirDstSHInfo, &TarEntry, &TarStreamEntry, NULL);
     400      pDirDstSHInfo, pTarEntry, pTarStreamEntry, NULL);
    329401   if (ulDstCluster != pVolInfo->ulFatEof)
    330402      {
    331403#ifdef EXFAT
    332       if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (TarEntry.bAttr & FILE_DIRECTORY)) ||
    333            ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pTarEntry->u.File.usFileAttr & FILE_DIRECTORY)) )
     404      if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (pTarEntry->bAttr & FILE_DIRECTORY)) ||
     405           ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pTarEntry1->u.File.usFileAttr & FILE_DIRECTORY)) )
    334406#else
    335       if ( TarEntry.bAttr & FILE_DIRECTORY )
     407      if ( pTarEntry->bAttr & FILE_DIRECTORY )
    336408#endif
    337409         {
     
    354426            goto FS_COPYEXIT;
    355427#if 0
    356          if (TarEntry.fEAS == FILE_HAS_EAS || TarEntry.fEAS == FILE_HAS_CRITICAL_EAS)
    357             TarEntry.fEAS = FILE_HAS_NO_EAS;
     428         if (pTarEntry->fEAS == FILE_HAS_EAS || pTarEntry->fEAS == FILE_HAS_CRITICAL_EAS)
     429            pTarEntry->fEAS = FILE_HAS_NO_EAS;
    358430#endif
    359431         }
    360432
    361433      rc = ModifyDirectory(pVolInfo, ulDstDirCluster, pDirDstSHInfo, MODIFY_DIR_DELETE,
    362                            &TarEntry, NULL, &TarStreamEntry, NULL, NULL, 0);
     434                           pTarEntry, NULL, pTarStreamEntry, NULL, NULL, 0);
    363435      if (rc)
    364436         goto FS_COPYEXIT;
     
    375447   */
    376448
    377    memcpy(&TarEntry, &DirEntry, sizeof TarEntry);
     449   memcpy(pTarEntry, pDirEntry, sizeof(DIRENTRY));
    378450#ifdef EXFAT
    379451   if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    380452      {
    381453#endif
    382       TarEntry.wCluster = 0;
    383       TarEntry.wClusterHigh = 0;
    384       TarEntry.ulFileSize = 0L;
     454      pTarEntry->wCluster = 0;
     455      pTarEntry->wClusterHigh = 0;
     456      pTarEntry->ulFileSize = 0L;
    385457#ifdef EXFAT
    386458      }
    387459   else
    388460      {
    389       TarStreamEntry.u.Stream.ulFirstClus = 0;
     461      pTarStreamEntry->u.Stream.ulFirstClus = 0;
    390462#ifdef INCL_LONGLONG
    391       TarStreamEntry.u.Stream.ullValidDataLen = 0;
    392       TarStreamEntry.u.Stream.ullDataLen = 0;
     463      pTarStreamEntry->u.Stream.ullValidDataLen = 0;
     464      pTarStreamEntry->u.Stream.ullDataLen = 0;
    393465#else
    394       AssignUL(&TarStreamEntry.u.Stream.ullValidDataLen, 0);
    395       AssignUL(&TarStreamEntry.u.Stream.ullDataLen, 0);
    396 #endif
    397       }
    398 #endif
    399    rc = ModifyDirectory(pVolInfo, ulDstDirCluster, pDirDstSHInfo, MODIFY_DIR_INSERT, NULL, &TarEntry, NULL, &TarStreamEntry, pszDstFile, 0);
     466      AssignUL(pTarStreamEntry->u.Stream.ullValidDataLen, 0);
     467      AssignUL(pTarStreamEntry->u.Stream.ullDataLen, 0);
     468#endif
     469      }
     470#endif
     471   rc = ModifyDirectory(pVolInfo, ulDstDirCluster, pDirDstSHInfo, MODIFY_DIR_INSERT, NULL, pTarEntry, NULL, pTarStreamEntry, pszDstFile, 0);
    400472   if (rc)
    401473      goto FS_COPYEXIT;
     
    403475   if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    404476#endif
    405       memcpy(DirEntry.bFileName, TarEntry.bFileName, 11); ////
     477      memcpy(pDirEntry->bFileName, pTarEntry->bFileName, 11);
    406478
    407479#ifdef EXFAT
    408480   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    409481      {
    410       pSrcSHInfo = &SrcSHInfo;
    411       SetSHInfo1(pVolInfo, &DirStreamEntry, pSrcSHInfo);
     482      SetSHInfo1(pVolInfo, pDirStreamEntry, pSrcSHInfo);
    412483      }
    413484#endif
     
    424495      if (ulDstCluster != pVolInfo->ulFatEof)
    425496         {
    426          DirEntry.wCluster = LOUSHORT(ulDstCluster);
    427          DirEntry.wClusterHigh = HIUSHORT(ulDstCluster);
     497         pDirEntry->wCluster = LOUSHORT(ulDstCluster);
     498         pDirEntry->wClusterHigh = HIUSHORT(ulDstCluster);
    428499         }
    429500      else
    430501         {
    431          DirEntry.wCluster = 0;
    432          DirEntry.wClusterHigh = 0;
    433          DirEntry.ulFileSize = 0L;
     502         pDirEntry->wCluster = 0;
     503         pDirEntry->wClusterHigh = 0;
     504         pDirEntry->ulFileSize = 0L;
    434505         }
    435506#ifdef EXFAT
     
    439510      if (ulDstCluster != pVolInfo->ulFatEof)
    440511         {
    441          DirStreamEntry.u.Stream.ulFirstClus = ulDstCluster;
     512         pDirStreamEntry->u.Stream.ulFirstClus = ulDstCluster;
    442513         }
    443514      else
    444515         {
    445          DirStreamEntry.u.Stream.ulFirstClus = 0;
     516         pDirStreamEntry->u.Stream.ulFirstClus = 0;
    446517#ifdef INCL_LONGLONG
    447          DirStreamEntry.u.Stream.ullValidDataLen = 0;
    448          DirStreamEntry.u.Stream.ullDataLen = 0;
     518         pDirStreamEntry->u.Stream.ullValidDataLen = 0;
     519         pDirStreamEntry->u.Stream.ullDataLen = 0;
    449520#else
    450          AssignUL(&DirStreamEntry.u.Stream.ullValidDataLen, 0);
    451          AssignUL(&DirStreamEntry.u.Stream.ullDataLen, 0);
     521         AssignUL(pDirStreamEntry->u.Stream.ullValidDataLen, 0);
     522         AssignUL(pDirStreamEntry->u.Stream.ullDataLen, 0);
    452523#endif
    453524         }
     
    457528      modify new entry
    458529   */
    459    rc2 = ModifyDirectory(pVolInfo, ulDstDirCluster, pDirDstSHInfo, MODIFY_DIR_UPDATE, &TarEntry, &DirEntry, &TarStreamEntry, &DirStreamEntry, NULL, 0);
     530   rc2 = ModifyDirectory(pVolInfo, ulDstDirCluster, pDirDstSHInfo, MODIFY_DIR_UPDATE, pTarEntry, pDirEntry, pTarStreamEntry, pDirStreamEntry, NULL, 0);
    460531   if (rc2 && !rc)
    461532      rc = rc2;
     
    481552         free(pOpenInfo);
    482553      }
     554
     555   if (szSrcLongName)
     556      free(szSrcLongName);
     557   if (szDstLongName)
     558      free(szDstLongName);
     559   if (pDirEntry)
     560      free(pDirEntry);
     561   if (pTarEntry)
     562      free(pTarEntry);
     563#ifdef EXFAT
     564   if (pDirStreamEntry)
     565      free(pDirStreamEntry);
     566   if (pTarStreamEntry)
     567      free(pTarStreamEntry);
     568   if (pDirSrcStream)
     569      free(pDirSrcStream);
     570   if (pDirDstStream)
     571      free(pDirDstStream);
     572   if (pSrcSHInfo)
     573      free(pSrcSHInfo);
     574   if (pDirSrcSHInfo)
     575      free(pDirSrcSHInfo);
     576   if (pDirDstSHInfo)
     577      free(pDirDstSHInfo);
     578#endif
    483579
    484580   if (f32Parms.fMessageActive & LOG_FS)
     
    505601PSZ      pszFile;
    506602USHORT   rc;
    507 DIRENTRY DirEntry;
    508 DIRENTRY1 DirEntryStream;
    509 PDIRENTRY1 pDirEntry = (PDIRENTRY1)&DirEntry;
     603PDIRENTRY pDirEntry;
     604#ifdef EXFAT
     605PDIRENTRY1 pDirEntry1;
     606#endif
     607PDIRENTRY1 pDirEntryStream = NULL;
    510608POPENINFO pOpenInfo = NULL;
    511 DIRENTRY1 DirStream;
    512 #ifdef EXFAT
    513 SHOPENINFO DirSHInfo;
    514 #endif
     609PDIRENTRY1 pDirStream = NULL;
    515610PSHOPENINFO pDirSHInfo = NULL;
    516 BYTE     szLongName[ FAT32MAXPATH ];
     611//BYTE     szLongName[ FAT32MAXPATH ];
     612PSZ      szLongName;
    517613
    518614   _asm push es;
     
    553649   pOpenInfo = malloc(sizeof (OPENINFO));
    554650   if (!pOpenInfo)
     651      {
     652      rc = ERROR_NOT_ENOUGH_MEMORY;
     653      goto FS_DELETEEXIT;
     654      }
     655
     656   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     657   if (!pDirEntry)
     658      {
     659      rc = ERROR_NOT_ENOUGH_MEMORY;
     660      goto FS_DELETEEXIT;
     661      }
     662#ifdef EXFAT
     663   pDirEntry1 = (PDIRENTRY1)pDirEntry;
     664
     665   pDirEntryStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     666   if (!pDirEntryStream)
     667      {
     668      rc = ERROR_NOT_ENOUGH_MEMORY;
     669      goto FS_DELETEEXIT;
     670      }
     671   pDirStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     672   if (!pDirStream)
     673      {
     674      rc = ERROR_NOT_ENOUGH_MEMORY;
     675      goto FS_DELETEEXIT;
     676      }
     677   pDirSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     678   if (!pDirSHInfo)
     679      {
     680      rc = ERROR_NOT_ENOUGH_MEMORY;
     681      goto FS_DELETEEXIT;
     682      }
     683#endif
     684
     685   szLongName = (PSZ)malloc((size_t)FAT32MAXPATH);
     686   if (!szLongName)
    555687      {
    556688      rc = ERROR_NOT_ENOUGH_MEMORY;
     
    588720      RETURN_PARENT_DIR,
    589721      &pszFile,
    590       &DirStream);
     722      pDirStream);
    591723
    592724   if (ulDirCluster == pVolInfo->ulFatEof)
     
    599731   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    600732      {
    601       pDirSHInfo = &DirSHInfo;
    602       SetSHInfo1(pVolInfo, &DirStream, pDirSHInfo);
     733      SetSHInfo1(pVolInfo, pDirStream, pDirSHInfo);
    603734      }
    604735#endif
    605736
    606737   ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszFile, pDirSHInfo,
    607                                &DirEntry, &DirEntryStream, NULL);
     738                               pDirEntry, pDirEntryStream, NULL);
    608739   if (ulCluster == pVolInfo->ulFatEof)
    609740      {
     
    614745
    615746#ifdef EXFAT
    616    if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (DirEntry.bAttr & FILE_DIRECTORY)) ||
    617         ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pDirEntry->u.File.usFileAttr & FILE_DIRECTORY)) )
     747   if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (pDirEntry->bAttr & FILE_DIRECTORY)) ||
     748        ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pDirEntry1->u.File.usFileAttr & FILE_DIRECTORY)) )
    618749#else
    619    if ( DirEntry.bAttr & FILE_DIRECTORY )
     750   if ( pDirEntry->bAttr & FILE_DIRECTORY )
    620751#endif
    621752      {
     
    625756
    626757#ifdef EXFAT
    627    if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (DirEntry.bAttr & FILE_READONLY)) ||
    628         ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pDirEntry->u.File.usFileAttr & FILE_READONLY)) )
     758   if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (pDirEntry->bAttr & FILE_READONLY)) ||
     759        ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pDirEntry1->u.File.usFileAttr & FILE_READONLY)) )
    629760#else
    630    if ( DirEntry.bAttr & FILE_READONLY )
     761   if ( pDirEntry->bAttr & FILE_READONLY )
    631762#endif
    632763      {
     
    641772         goto FS_DELETEEXIT;
    642773#if 0
    643       if (DirEntry.fEAS == FILE_HAS_EAS || DirEntry.fEAS == FILE_HAS_CRITICAL_EAS)
    644          DirEntry.fEAS = FILE_HAS_NO_EAS;
     774      if (pDirEntry->fEAS == FILE_HAS_EAS || pDirEntry->fEAS == FILE_HAS_CRITICAL_EAS)
     775         pDirEntry->fEAS = FILE_HAS_NO_EAS;
    645776#endif
    646777      }
    647778
    648779   rc = ModifyDirectory(pVolInfo, ulDirCluster, pDirSHInfo, MODIFY_DIR_DELETE,
    649                         &DirEntry, NULL, &DirEntryStream, NULL, NULL, 0);
     780                        pDirEntry, NULL, pDirEntryStream, NULL, NULL, 0);
    650781   if (rc)
    651782      goto FS_DELETEEXIT;
     
    665796         free(pOpenInfo);
    666797      }
     798
     799   if (szLongName)
     800      free(szLongName);
     801   if (pDirEntry)
     802      free(pDirEntry);
     803#ifdef EXFAT
     804   if (pDirEntryStream)
     805      free(pDirEntryStream);
     806   if (pDirStream)
     807      free(pDirStream);
     808   if (pDirSHInfo)
     809      free(pDirSHInfo);
     810#endif
    667811
    668812   if (f32Parms.fMessageActive & LOG_FS)
     
    11211265      case FAT32_QUERYSHORTNAME:
    11221266         {
    1123          char szShortPath[ FAT32MAXPATH ] = { 0, };
     1267         //char szShortPath[ FAT32MAXPATH ] = { 0, };
     1268         PSZ szShortPath = (PSZ)malloc((size_t)FAT32MAXPATH);
    11241269         PVOLINFO pVolInfo = pGlobVolInfo;
    11251270         BYTE     bDrive;
     
    11371282         if (pVolInfo->fFormatInProgress)
    11381283            {
     1284            free(szShortPath);
    11391285            rc = ERROR_ACCESS_DENIED;
    11401286            goto FS_FSCTLEXIT;
     
    11451291            if( strlen( szShortPath ) >= cbData )
    11461292            {
     1293                free(szShortPath);
    11471294                rc = ERROR_BUFFER_OVERFLOW;
    11481295                goto FS_FSCTLEXIT;
     
    11521299         }
    11531300
     1301         free(szShortPath);
    11541302         rc = 0;
    11551303         break;
     
    13801528ULONG ulCluster;
    13811529ULONG ulBlock;
    1382 DIRENTRY DirEntry;
     1530PDIRENTRY pDirEntry;
    13831531BOOL     fFound;
    13841532USHORT   rc;
     
    13931541   pDir = NULL;
    13941542
     1543   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     1544   if (!pDirEntry)
     1545      {
     1546      return ERROR_NOT_ENOUGH_MEMORY;
     1547      }
     1548
    13951549   pDirStart = (PDIRENTRY)malloc((size_t)pVolInfo->ulBlockSize);
    13961550   if (!pDirStart)
     1551      {
     1552      free(pDirEntry);
    13971553      return ERROR_NOT_ENOUGH_MEMORY;
     1554      }
    13981555
    13991556   fFound = FALSE;
     
    14281585                  {
    14291586                  fFound = TRUE;
    1430                   memcpy(&DirEntry, pDir, sizeof (DIRENTRY));
     1587                  memcpy(pDirEntry, pDir, sizeof (DIRENTRY));
    14311588                  break;
    14321589                  }
     
    14461603                  {
    14471604                  fFound = TRUE;
    1448                   memcpy(&DirEntry, pDir, sizeof (DIRENTRY));
     1605                  memcpy(pDirEntry, pDir, sizeof (DIRENTRY));
    14491606                  break;
    14501607                  }
     
    14921649         memset(pszVolLabel, 0, *pusSize);
    14931650         *pusSize = 0;
     1651         free(pDirEntry);
    14941652         return 0;
    14951653         }
     
    14981656      if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    14991657#endif
    1500          memcpy(pszVolLabel, DirEntry.bFileName, 11);
     1658         memcpy(pszVolLabel, pDirEntry->bFileName, 11);
    15011659#ifdef EXFAT
    15021660      else
     
    15041662         // exFAT case
    15051663         USHORT pVolLabel[11];
    1506          memcpy(pVolLabel, ((PDIRENTRY1)&DirEntry)->u.VolLbl.usChars,
    1507             ((PDIRENTRY1)&DirEntry)->u.VolLbl.bCharCount * sizeof(USHORT));
    1508          pVolLabel[((PDIRENTRY1)&DirEntry)->u.VolLbl.bCharCount] = 0;
    1509          Translate2OS2(pVolLabel, pszVolLabel, ((PDIRENTRY1)&DirEntry)->u.VolLbl.bCharCount);
     1664         memcpy(pVolLabel, ((PDIRENTRY1)pDirEntry)->u.VolLbl.usChars,
     1665            ((PDIRENTRY1)pDirEntry)->u.VolLbl.bCharCount * sizeof(USHORT));
     1666         pVolLabel[((PDIRENTRY1)pDirEntry)->u.VolLbl.bCharCount] = 0;
     1667         Translate2OS2(pVolLabel, pszVolLabel, ((PDIRENTRY1)pDirEntry)->u.VolLbl.bCharCount);
    15101668         }
    15111669#endif
     
    15151673         pszVolLabel[*pusSize] = 0;
    15161674         }
     1675      free(pDirEntry);
    15171676      return 0;
    15181677      }
     
    15231682      if (!strchr(rgValidChars, pszVolLabel[usIndex]))
    15241683         {
     1684         free(pDirEntry);
    15251685         free(pDirStart);
    15261686         return ERROR_INVALID_NAME;
     
    15281688      }
    15291689
    1530    memset(&DirEntry, 0, sizeof DirEntry);
     1690   memset(pDirEntry, 0, sizeof(DIRENTRY));
    15311691
    15321692#ifdef EXFAT
     
    15341694      {
    15351695#endif
    1536       memset(DirEntry.bFileName, 0x20, 11);
    1537       memcpy(DirEntry.bFileName, pszVolLabel, min(11, *pusSize));
    1538       DirEntry.bAttr = bAttr;
     1696      memset(pDirEntry->bFileName, 0x20, 11);
     1697      memcpy(pDirEntry->bFileName, pszVolLabel, min(11, *pusSize));
     1698      pDirEntry->bAttr = bAttr;
    15391699#ifdef EXFAT
    15401700      }
     
    15451705      USHORT usChars = min(11, *pusSize);
    15461706      Translate2Win(pszVolLabel, pVolLabel, usChars);
    1547       ((PDIRENTRY1)&DirEntry)->u.VolLbl.bCharCount = (BYTE)usChars;
    1548       memcpy(((PDIRENTRY1)&DirEntry)->u.VolLbl.usChars, pVolLabel, usChars * sizeof(USHORT));
    1549       ((PDIRENTRY1)&DirEntry)->bEntryType = ENTRY_TYPE_VOLUME_LABEL;
     1707      ((PDIRENTRY1)pDirEntry)->u.VolLbl.bCharCount = (BYTE)usChars;
     1708      memcpy(((PDIRENTRY1)pDirEntry)->u.VolLbl.usChars, pVolLabel, usChars * sizeof(USHORT));
     1709      ((PDIRENTRY1)pDirEntry)->bEntryType = ENTRY_TYPE_VOLUME_LABEL;
    15501710      }
    15511711#endif
     
    15531713   if (fFound)
    15541714      {
    1555       memcpy(pDir, &DirEntry, sizeof (DIRENTRY));
     1715      memcpy(pDir, pDirEntry, sizeof (DIRENTRY));
    15561716      if (ulCluster == 1)
    15571717         // reading root directory on FAT12/FAT16
     
    15631723      {
    15641724      rc = ModifyDirectory(pVolInfo, pVolInfo->BootSect.bpb.RootDirStrtClus, NULL,
    1565          MODIFY_DIR_INSERT, NULL, &DirEntry, NULL, NULL, pszVolLabel, DVIO_OPWRTHRU);
     1725         MODIFY_DIR_INSERT, NULL, pDirEntry, NULL, NULL, pszVolLabel, DVIO_OPWRTHRU);
    15661726      }
    15671727   if (rc)
    15681728      {
     1729      free(pDirEntry);
    15691730      free(pDirStart);
    15701731      return rc;
     
    15791740         {
    15801741         pBootSect = (PBOOTSECT)pDirStart;
    1581          memcpy(pBootSect->VolumeLabel, DirEntry.bFileName, 11);
     1742         memcpy(pBootSect->VolumeLabel, pDirEntry->bFileName, 11);
    15821743         rc = WriteSector(pVolInfo, 0L, 1, (PBYTE)pBootSect, DVIO_OPWRTHRU | DVIO_OPNCACHE);
    15831744         }
    15841745      free(pDirStart);
    1585       }
    1586 
    1587    if (!rc)
    1588       {
    1589       memcpy(pVolInfo->BootSect.VolumeLabel, DirEntry.bFileName, 11);
    1590       rc = FSH_GETVOLPARM(pVolInfo->hVBP, &pvpfsi, &pvpfsd);
     1746
    15911747      if (!rc)
    1592          memcpy(pvpfsi->vpi_text, DirEntry.bFileName, 11);
    1593       }
    1594 
     1748         {
     1749         memcpy(pVolInfo->BootSect.VolumeLabel, pDirEntry->bFileName, 11);
     1750         rc = FSH_GETVOLPARM(pVolInfo->hVBP, &pvpfsi, &pvpfsd);
     1751        if (!rc)
     1752            memcpy(pvpfsi->vpi_text, pDirEntry->bFileName, 11);
     1753         }
     1754      }
     1755
     1756   free(pDirEntry);
    15951757   return rc;
    15961758}
     
    16021764// This is relevant for exFAT only
    16031765PDIRENTRY1 pDirStart, pDir, pDirEnd;
    1604 DIRENTRY1 DirEntry;
     1766PDIRENTRY1 pDirEntry;
    16051767ULONG ulCluster;
    16061768ULONG ulBlock;
     
    16091771   pDir = NULL;
    16101772
     1773   pDirEntry = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     1774   if (!pDirEntry)
     1775      {
     1776      return ERROR_NOT_ENOUGH_MEMORY;
     1777      }
     1778
    16111779   pDirStart = (PDIRENTRY1)malloc((size_t)pVolInfo->ulBlockSize);
    16121780   if (!pDirStart)
     1781      {
     1782      free(pDirEntry);
    16131783      return ERROR_NOT_ENOUGH_MEMORY;
     1784      }
    16141785
    16151786   fFound = FALSE;
     
    16271798               {
    16281799               fFound = TRUE;
    1629                memcpy(&DirEntry, pDir, sizeof (DIRENTRY1));
     1800               memcpy(pDirEntry, pDir, sizeof (DIRENTRY1));
    16301801               break;
    16311802               }
     
    16461817      }
    16471818
    1648    *pulFirstCluster = DirEntry.u.AllocBmp.ulFirstCluster;
    1649    *pullLen = DirEntry.u.AllocBmp.ullDataLength;
     1819   *pulFirstCluster = pDirEntry->u.AllocBmp.ulFirstCluster;
     1820   *pullLen = pDirEntry->u.AllocBmp.ullDataLength;
     1821   free(pDirEntry);
    16501822   free(pDirStart);
    16511823   return 0;
     
    16571829// This is relevant for exFAT only
    16581830PDIRENTRY1 pDirStart, pDir, pDirEnd;
    1659 DIRENTRY1 DirEntry;
     1831PDIRENTRY1 pDirEntry;
    16601832ULONG ulCluster;
    16611833ULONG ulBlock;
     
    16631835
    16641836   pDir = NULL;
     1837
     1838   pDirEntry = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     1839   if (!pDirEntry)
     1840      {
     1841      return ERROR_NOT_ENOUGH_MEMORY;
     1842      }
    16651843
    16661844   pDirStart = (PDIRENTRY1)malloc((size_t)pVolInfo->ulBlockSize);
     
    16821860               {
    16831861               fFound = TRUE;
    1684                memcpy(&DirEntry, pDir, sizeof (DIRENTRY1));
     1862               memcpy(pDirEntry, pDir, sizeof (DIRENTRY1));
    16851863               break;
    16861864               }
     
    17011879      }
    17021880
    1703    *pulFirstCluster = DirEntry.u.UpCaseTbl.ulFirstCluster;
    1704    *pullLen = DirEntry.u.UpCaseTbl.ullDataLength;
    1705    *pulChecksum = DirEntry.u.UpCaseTbl.ulTblCheckSum;
     1881   *pulFirstCluster = pDirEntry->u.UpCaseTbl.ulFirstCluster;
     1882   *pullLen = pDirEntry->u.UpCaseTbl.ullDataLength;
     1883   *pulChecksum = pDirEntry->u.UpCaseTbl.ulTblCheckSum;
     1884   free(pDirEntry);
    17061885   return 0;
    17071886}
     
    26662845{
    26672846ULONG ulDirCluster;
    2668 DIRENTRY1 DirStream;
    2669 #ifdef EXFAT
    2670 SHOPENINFO DirSHInfo;
    2671 #endif
     2847PDIRENTRY1 pDirStream = NULL;
    26722848PSHOPENINFO pDirSHInfo = NULL;
    26732849PSZ   pszFile;
     
    26752851   if (f32Parms.fMessageActive & LOG_FUNCS)
    26762852      Message("GetSetFileEAS");
     2853
     2854#ifdef EXFAT
     2855   pDirStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     2856   if (!pDirStream)
     2857      {
     2858      return ERROR_NOT_ENOUGH_MEMORY;
     2859      }
     2860#endif
    26772861
    26782862   ulDirCluster = FindDirCluster(pVolInfo,
     
    26832867      RETURN_PARENT_DIR,
    26842868      &pszFile,
    2685       &DirStream);
     2869      pDirStream);
    26862870
    26872871   if (ulDirCluster == pVolInfo->ulFatEof)
     2872      {
     2873#ifdef EXFAT
     2874      free(pDirStream);
     2875#endif
    26882876      return ERROR_PATH_NOT_FOUND;
     2877      }
    26892878
    26902879#ifdef EXFAT
    26912880   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    26922881      {
    2693       pDirSHInfo = &DirSHInfo;
    2694       SetSHInfo1(pVolInfo, &DirStream, pDirSHInfo);
     2882      SetSHInfo1(pVolInfo, pDirStream, pDirSHInfo);
    26952883      }
    26962884#endif
     
    26992887      {
    27002888      ULONG ulCluster;
    2701       DIRENTRY DirEntry;
    2702       PDIRENTRY1 pDirEntry = (PDIRENTRY1)&DirEntry;
    2703 
    2704       ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszFile, pDirSHInfo, &DirEntry, NULL, NULL);
     2889      PDIRENTRY pDirEntry;
     2890#ifdef EXFAT
     2891      PDIRENTRY1 pDirEntry1;
     2892#endif
     2893
     2894      pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     2895      if (!pDirEntry)
     2896         {
     2897#ifdef EXFAT
     2898         free(pDirStream);
     2899#endif
     2900         return ERROR_NOT_ENOUGH_MEMORY;
     2901         }
     2902#ifdef EXFAT
     2903      pDirEntry1 = (PDIRENTRY1)pDirEntry;
     2904#endif
     2905
     2906      ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszFile, pDirSHInfo, pDirEntry, NULL, NULL);
    27052907      if (ulCluster == pVolInfo->ulFatEof)
     2908         {
     2909         free(pDirEntry);
     2910#ifdef EXFAT
     2911         free(pDirStream);
     2912#endif
    27062913         return ERROR_FILE_NOT_FOUND;
     2914         }
    27072915#ifdef EXFAT
    27082916      if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    27092917#endif
    2710          pMark->fEAS = DirEntry.fEAS;
     2918         pMark->fEAS = pDirEntry->fEAS;
    27112919#ifdef EXFAT
    27122920      else
    2713          pMark->fEAS = pDirEntry->u.File.fEAS;
     2921         pMark->fEAS = pDirEntry1->u.File.fEAS;
     2922#endif
     2923      free(pDirEntry);
     2924#ifdef EXFAT
     2925      free(pDirStream);
    27142926#endif
    27152927      return 0;
    27162928      }
    27172929
     2930#ifdef EXFAT
     2931   free(pDirStream);
     2932#endif
    27182933   return MarkFileEAS(pVolInfo, ulDirCluster, pDirSHInfo, pszFile, pMark->fEAS);
    27192934}
     
    27212936USHORT RecoverChain(PVOLINFO pVolInfo, ULONG ulCluster, PBYTE pData, USHORT cbData)
    27222937{
    2723 DIRENTRY DirEntry;
    2724 PDIRENTRY1 pDirEntry = (PDIRENTRY1)&DirEntry;
    2725 DIRENTRY1 DirStream;
     2938PDIRENTRY pDirEntry;
     2939PDIRENTRY1 pDirStream = NULL;
    27262940BYTE     szFileName[14];
    27272941USHORT   usNr;
    27282942
    2729    memset(&DirEntry, 0, sizeof (DIRENTRY));
    2730    memset(&DirStream, 0, sizeof (DIRENTRY1));
     2943      pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     2944      if (!pDirEntry)
     2945         {
     2946         return ERROR_NOT_ENOUGH_MEMORY;
     2947         }
     2948#ifdef EXFAT
     2949      pDirStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     2950      if (!pDirStream)
     2951         {
     2952         free(pDirEntry);
     2953         return ERROR_NOT_ENOUGH_MEMORY;
     2954         }
     2955#endif
     2956
     2957   memset(pDirEntry, 0, sizeof (DIRENTRY));
     2958#ifdef EXFAT
     2959   memset(pDirStream, 0, sizeof (DIRENTRY1));
     2960#endif
    27312961
    27322962#ifdef EXFAT
     
    27342964#endif
    27352965      {
    2736       memcpy(DirEntry.bFileName, "FILE0000CHK", 11);
     2966      memcpy(pDirEntry->bFileName, "FILE0000CHK", 11);
    27372967      strcpy(szFileName, "FILE0000.CHK");
    27382968      }
     
    27542984      }
    27552985   if (usNr == 9999)
     2986      {
     2987      free(pDirEntry);
     2988#ifdef EXFAT
     2989      free(pDirStream);
     2990#endif
    27562991      return ERROR_FILE_EXISTS;
     2992      }
    27572993#ifdef EXFAT
    27582994   if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    27592995#endif
    2760       memcpy(DirEntry.bFileName, szFileName, 8);
     2996      memcpy(pDirEntry->bFileName, szFileName, 8);
    27612997   if (pData)
    27622998      strncpy(pData, szFileName, cbData);
     
    27663002      {
    27673003#endif
    2768       DirEntry.wCluster = LOUSHORT(ulCluster);
    2769       DirEntry.wClusterHigh = HIUSHORT(ulCluster);
     3004      pDirEntry->wCluster = LOUSHORT(ulCluster);
     3005      pDirEntry->wClusterHigh = HIUSHORT(ulCluster);
    27703006#ifdef EXFAT
    27713007      }
    27723008   else
    27733009      {
    2774       DirStream.u.Stream.ulFirstClus = ulCluster;
     3010      pDirStream->u.Stream.ulFirstClus = ulCluster;
    27753011      }
    27763012#endif
     
    27813017      if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    27823018#endif
    2783          DirEntry.ulFileSize += pVolInfo->ulClusterSize;
     3019         pDirEntry->ulFileSize += pVolInfo->ulClusterSize;
    27843020#ifdef EXFAT
    27853021      else
    27863022         {
    27873023#ifdef INCL_LONGLONG
    2788          DirStream.u.Stream.ullValidDataLen += pVolInfo->ulClusterSize;
    2789          DirStream.u.Stream.ullDataLen += pVolInfo->ulClusterSize;
     3024         pDirStream->u.Stream.ullValidDataLen += pVolInfo->ulClusterSize;
     3025         pDirStream->u.Stream.ullDataLen += pVolInfo->ulClusterSize;
    27903026#else
    2791          DirStream.u.Stream.ullValidDataLen = AddUL(DirStream.u.Stream.ullValidDataLen, pVolInfo->ulClusterSize);
    2792          DirStream.u.Stream.ullDataLen = AddUL(DirStream.u.Stream.ullDataLen, pVolInfo->ulClusterSize);
     3027         pDirStream->u.Stream.ullValidDataLen = AddUL(pDirStream->u.Stream.ullValidDataLen, pVolInfo->ulClusterSize);
     3028         pDirStream->u.Stream.ullDataLen = AddUL(pDirStream->u.Stream.ullDataLen, pVolInfo->ulClusterSize);
    27933029#endif
    27943030         }
     
    28043040      }
    28053041
     3042   free(pDirEntry);
     3043#ifdef EXFAT
     3044   free(pDirStream);
     3045#endif
     3046
    28063047   return MakeDirEntry(pVolInfo,
    28073048      pVolInfo->BootSect.bpb.RootDirStrtClus, NULL,
    2808       &DirEntry, &DirStream, szFileName);
     3049      pDirEntry, pDirStream, szFileName);
    28093050}
    28103051
     
    28143055PSZ   pszFile;
    28153056ULONG ulCluster;
    2816 DIRENTRY DirEntry;
    2817 DIRENTRY DirNew;
    2818 DIRENTRY1 DirStream, DirStreamNew, DirStreamEntry;
     3057PDIRENTRY pDirEntry;
     3058PDIRENTRY pDirNew;
     3059PDIRENTRY1 pDirStream = NULL;
     3060PDIRENTRY1 pDirStreamNew = NULL;
     3061PDIRENTRY1 pDirStreamEntry = NULL;
    28193062ULONG ulClustersNeeded;
    28203063ULONG ulClustersUsed;
    2821 #ifdef EXFAT
    2822 SHOPENINFO SHInfo;
    2823 #endif
    28243064PSHOPENINFO pSHInfo = NULL;
    2825 SHOPENINFO DirSHInfo;
    28263065PSHOPENINFO pDirSHInfo = NULL;
    28273066USHORT rc;
     3067
     3068   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     3069   if (!pDirEntry)
     3070      {
     3071      rc = ERROR_NOT_ENOUGH_MEMORY;
     3072      goto SetFileSizeExit;
     3073      }
     3074   pDirNew = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     3075   if (!pDirNew)
     3076      {
     3077      rc = ERROR_NOT_ENOUGH_MEMORY;
     3078      goto SetFileSizeExit;
     3079      }
     3080#ifdef EXFAT
     3081   pDirStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     3082   if (!pDirStream)
     3083      {
     3084      rc = ERROR_NOT_ENOUGH_MEMORY;
     3085      goto SetFileSizeExit;
     3086      }
     3087   pDirStreamNew = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     3088   if (!pDirStreamNew)
     3089      {
     3090      rc = ERROR_NOT_ENOUGH_MEMORY;
     3091      goto SetFileSizeExit;
     3092      }
     3093   pDirStreamEntry = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     3094   if (!pDirStreamEntry)
     3095      {
     3096      rc = ERROR_NOT_ENOUGH_MEMORY;
     3097      goto SetFileSizeExit;
     3098      }
     3099   pSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     3100   if (!pSHInfo)
     3101      {
     3102      rc = ERROR_NOT_ENOUGH_MEMORY;
     3103      goto SetFileSizeExit;
     3104      }
     3105   pDirSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     3106   if (!pDirSHInfo)
     3107      {
     3108      rc = ERROR_NOT_ENOUGH_MEMORY;
     3109      goto SetFileSizeExit;
     3110      }
     3111#endif
    28283112
    28293113   ulDirCluster = FindDirCluster(pVolInfo,
     
    28343118      RETURN_PARENT_DIR,
    28353119      &pszFile,
    2836       &DirStreamEntry);
     3120      pDirStreamEntry);
    28373121
    28383122   if (ulDirCluster == pVolInfo->ulFatEof)
     
    28413125#ifdef EXFAT
    28423126   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    2843 #endif
    2844       {
    2845       pDirSHInfo = &DirSHInfo;
    2846       SetSHInfo1(pVolInfo, (PDIRENTRY1)&DirStreamEntry, pDirSHInfo);
    2847       }
     3127      {
     3128      SetSHInfo1(pVolInfo, pDirStreamEntry, pDirSHInfo);
     3129      }
     3130#endif
    28483131
    28493132   ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszFile,
    2850       pDirSHInfo, &DirEntry, &DirStream, NULL);
     3133      pDirSHInfo, pDirEntry, pDirStream, NULL);
    28513134   if (ulCluster == pVolInfo->ulFatEof)
    28523135      return ERROR_FILE_NOT_FOUND;
     
    28613144   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    28623145      {
    2863       pSHInfo = &SHInfo;
    2864       SetSHInfo1(pVolInfo, (PDIRENTRY1)&DirStream, pSHInfo);
     3146      SetSHInfo1(pVolInfo, pDirStream, pSHInfo);
    28653147      }
    28663148#endif
     
    28853167      }
    28863168
    2887    memcpy(&DirNew, &DirEntry, sizeof (DIRENTRY));
    2888    memcpy(&DirStreamNew, &DirStream, sizeof (DIRENTRY1));
    2889 
    2890 #ifdef EXFAT
     3169   memcpy(pDirNew, pDirEntry, sizeof (DIRENTRY));
     3170#ifdef EXFAT
     3171   memcpy(pDirStreamNew, pDirStream, sizeof (DIRENTRY1));
     3172
    28913173   if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    28923174      {
    28933175#endif
    2894       DirNew.ulFileSize = pFileSize->ulFileSize;
     3176      pDirNew->ulFileSize = pFileSize->ulFileSize;
    28953177#ifdef EXFAT
    28963178      }
     
    28983180      {
    28993181#ifdef INCL_LONGLONG
    2900       DirStreamNew.u.Stream.ullValidDataLen = pFileSize->ulFileSize;
    2901       DirStreamNew.u.Stream.ullDataLen =
     3182      pDirStreamNew->u.Stream.ullValidDataLen = pFileSize->ulFileSize;
     3183      pDirStreamNew->u.Stream.ullDataLen =
    29023184         (pFileSize->ulFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    29033185         ((pFileSize->ulFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
    29043186#else
    2905       AssignUL(&DirStreamNew.u.Stream.ullValidDataLen, pFileSize->ulFileSize);
    2906       AssignUL(&DirStreamNew.u.Stream.ullDataLen,
     3187      AssignUL(pDirStreamNew->u.Stream.ullValidDataLen, pFileSize->ulFileSize);
     3188      AssignUL(pDirStreamNew->u.Stream.ullDataLen,
    29073189         (pFileSize->ulFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    29083190         ((pFileSize->ulFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0));
     
    29173199         {
    29183200#endif
    2919          DirNew.wCluster = 0;
    2920          DirNew.wClusterHigh = 0;
     3201         pDirNew->wCluster = 0;
     3202         pDirNew->wClusterHigh = 0;
    29213203#ifdef EXFAT
    29223204         }
    29233205      else
    29243206         {
    2925          DirStreamNew.u.Stream.ulFirstClus = 0;
     3207         pDirStreamNew->u.Stream.ulFirstClus = 0;
    29263208         }
    29273209#endif
     
    29293211
    29303212   rc = ModifyDirectory(pVolInfo, ulDirCluster, pDirSHInfo, MODIFY_DIR_UPDATE,
    2931       &DirEntry, &DirNew, &DirStream, &DirStreamNew, NULL, 0);
     3213      pDirEntry, pDirNew, pDirStream, pDirStreamNew, NULL, 0);
     3214
     3215SetFileSizeExit:
     3216   if (pDirEntry)
     3217      free(pDirEntry);
     3218   if (pDirNew)
     3219      free(pDirNew);
     3220#ifdef EXFAT
     3221   if (pDirStream)
     3222      free(pDirStream);
     3223   if (pDirStreamNew)
     3224      free(pDirStreamNew);
     3225   if (pDirStreamEntry)
     3226      free(pDirStreamEntry);
     3227   if (pSHInfo)
     3228      free(pSHInfo);
     3229   if (pDirSHInfo)
     3230      free(pDirSHInfo);
     3231#endif
    29323232
    29333233   return rc;
     
    29533253PSZ   pszSrcFile;
    29543254PSZ   pszDstFile;
    2955 DIRENTRY DirEntry;
    2956 DIRENTRY1 DirEntryStream, DirEntryStreamOld;
    2957 PDIRENTRY1 pDirEntry = (PDIRENTRY1)&DirEntry;
     3255PDIRENTRY pDirEntry;
     3256PDIRENTRY1 pDirEntry1;
     3257PDIRENTRY1 pDirEntryStream = NULL, pDirEntryStreamOld = NULL;
    29583258ULONG    ulCluster;
    29593259ULONG    ulTarCluster;
     
    29613261POPENINFO pOISrc = NULL;
    29623262POPENINFO pOIDst = NULL;
    2963 DIRENTRY1 DirSrcStream;
    2964 DIRENTRY1 DirDstStream;
    2965 #ifdef EXFAT
    2966 SHOPENINFO DirSrcSHInfo, DirDstSHInfo;
    2967 #endif
     3263PDIRENTRY1 pDirSrcStream = NULL;
     3264PDIRENTRY1 pDirDstStream = NULL;
    29683265PSHOPENINFO pDirSrcSHInfo = NULL, pDirDstSHInfo = NULL;
    2969 BYTE     szSrcLongName[ FAT32MAXPATH ];
    2970 BYTE     szDstLongName[ FAT32MAXPATH ];
     3266//BYTE     szSrcLongName[ FAT32MAXPATH ];
     3267PSZ      szSrcLongName;
     3268//BYTE     szDstLongName[ FAT32MAXPATH ];
     3269PSZ      szDstLongName;
    29713270
    29723271   _asm push es;
     
    30023301      {
    30033302      rc = ERROR_WRITE_PROTECT;
     3303      goto FS_MOVEEXIT;
     3304      }
     3305
     3306   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     3307   if (!pDirEntry)
     3308      {
     3309      rc = ERROR_NOT_ENOUGH_MEMORY;
     3310      goto FS_MOVEEXIT;
     3311      }
     3312#ifdef EXFAT
     3313   pDirEntry1 = (PDIRENTRY1)pDirEntry;
     3314
     3315   pDirEntryStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     3316   if (!pDirEntryStream)
     3317      {
     3318      rc = ERROR_NOT_ENOUGH_MEMORY;
     3319      goto FS_MOVEEXIT;
     3320      }
     3321   pDirEntryStreamOld = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     3322   if (!pDirEntryStreamOld)
     3323      {
     3324      rc = ERROR_NOT_ENOUGH_MEMORY;
     3325      goto FS_MOVEEXIT;
     3326      }
     3327   pDirSrcStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     3328   if (!pDirSrcStream)
     3329      {
     3330      rc = ERROR_NOT_ENOUGH_MEMORY;
     3331      goto FS_MOVEEXIT;
     3332      }
     3333   pDirDstStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     3334   if (!pDirDstStream)
     3335      {
     3336      rc = ERROR_NOT_ENOUGH_MEMORY;
     3337      goto FS_MOVEEXIT;
     3338      }
     3339   pDirSrcSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     3340   if (!pDirSrcSHInfo)
     3341      {
     3342      rc = ERROR_NOT_ENOUGH_MEMORY;
     3343      goto FS_MOVEEXIT;
     3344      }
     3345   pDirDstSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     3346   if (!pDirDstSHInfo)
     3347      {
     3348      rc = ERROR_NOT_ENOUGH_MEMORY;
     3349      goto FS_MOVEEXIT;
     3350      }
     3351#endif
     3352
     3353   szSrcLongName = (PSZ)malloc((size_t)FAT32MAXPATH);
     3354   if (!szSrcLongName)
     3355      {
     3356      rc = ERROR_NOT_ENOUGH_MEMORY;
     3357      goto FS_MOVEEXIT;
     3358      }
     3359
     3360   szDstLongName = (PSZ)malloc((size_t)FAT32MAXPATH);
     3361   if (!szDstLongName)
     3362      {
     3363      rc = ERROR_NOT_ENOUGH_MEMORY;
    30043364      goto FS_MOVEEXIT;
    30053365      }
     
    30673427      RETURN_PARENT_DIR,
    30683428      &pszDstFile,
    3069       &DirDstStream);
     3429      pDirDstStream);
    30703430
    30713431   if (ulDstDirCluster == pVolInfo->ulFatEof)
     
    30783438   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    30793439      {
    3080       pDirDstSHInfo = &DirDstSHInfo;
    3081       SetSHInfo1(pVolInfo, (PDIRENTRY1)&DirDstStream, pDirDstSHInfo);
    3082       }
    3083 #endif
    3084 
    3085    ulTarCluster = FindPathCluster(pVolInfo, ulDstDirCluster, pszDstFile, pDirDstSHInfo, &DirEntry, NULL, NULL);
     3440      SetSHInfo1(pVolInfo, pDirDstStream, pDirDstSHInfo);
     3441      }
     3442#endif
     3443
     3444   ulTarCluster = FindPathCluster(pVolInfo, ulDstDirCluster, pszDstFile, pDirDstSHInfo, pDirEntry, NULL, NULL);
    30863445
    30873446   /*
     
    30953454      RETURN_PARENT_DIR,
    30963455      &pszSrcFile,
    3097       &DirSrcStream);
     3456      pDirSrcStream);
    30983457
    30993458   if (ulSrcDirCluster == pVolInfo->ulFatEof)
     
    31063465   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    31073466      {
    3108       pDirSrcSHInfo = &DirSrcSHInfo;
    3109       SetSHInfo1(pVolInfo, (PDIRENTRY1)&DirSrcStream, pDirSrcSHInfo);
    3110       }
    3111 #endif
    3112 
    3113    ulCluster = FindPathCluster(pVolInfo, ulSrcDirCluster, pszSrcFile, pDirSrcSHInfo, &DirEntry, &DirEntryStream, NULL);
     3467      SetSHInfo1(pVolInfo, pDirSrcStream, pDirSrcSHInfo);
     3468      }
     3469#endif
     3470
     3471   ulCluster = FindPathCluster(pVolInfo, ulSrcDirCluster, pszSrcFile, pDirSrcSHInfo, pDirEntry, pDirEntryStream, NULL);
    31143472   if (ulCluster == pVolInfo->ulFatEof)
    31153473      {
     
    31313489
    31323490#if 0
    3133    if (DirEntry.bAttr & FILE_READONLY)
     3491   if (pDirEntry->bAttr & FILE_READONLY)
    31343492      {
    31353493      rc = ERROR_ACCESS_DENIED;
     
    31393497
    31403498#ifdef EXFAT
    3141    if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (DirEntry.bAttr & FILE_DIRECTORY)) ||
    3142         ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pDirEntry->u.File.usFileAttr & FILE_DIRECTORY)) )
     3499   if ( ((pVolInfo->bFatType <  FAT_TYPE_EXFAT) && (pDirEntry->bAttr & FILE_DIRECTORY)) ||
     3500        ((pVolInfo->bFatType == FAT_TYPE_EXFAT) && (pDirEntry1->u.File.usFileAttr & FILE_DIRECTORY)) )
    31433501#else
    3144    if ( DirEntry.bAttr & FILE_DIRECTORY )
     3502   if ( pDirEntry->bAttr & FILE_DIRECTORY )
    31453503#endif
    31463504      {
     
    31853543      pOISrc->pSHInfo->fLock = TRUE;
    31863544#else
    3187       BYTE szName[FAT32MAXPATH];
     3545      //BYTE szName[FAT32MAXPATH];
     3546      PSZ szName = (PSZ)malloc((size_t)FAT32MAXPATH);
     3547      if (!szName)
     3548         {
     3549         rc = ERROR_NOT_ENOUGH_MEMORY;
     3550         goto FS_MOVEEXIT;
     3551         }
    31883552      rc = FSH_ISCURDIRPREFIX(pSrc);
    31893553      if (rc)
     3554         {
     3555         free(szName);
    31903556         goto FS_MOVEEXIT;
     3557         }
    31913558      rc = TranslateName(pVolInfo, 0L, pSrc, szName, TRANSLATE_AUTO);
    31923559      if (rc)
     3560         {
     3561         free(szName);
    31933562         goto FS_MOVEEXIT;
     3563         }
    31943564      rc = FSH_ISCURDIRPREFIX(szName);
    31953565      if (rc)
     3566         {
     3567         free(szName);
    31963568         goto FS_MOVEEXIT;
     3569         }
     3570      if (szName)
     3571         free(szName);
    31973572#endif
    31983573      }
     
    32123587   if (ulSrcDirCluster == ulDstDirCluster)
    32133588      {
    3214       DIRENTRY DirOld;
    3215 
    3216       memcpy(&DirOld, &DirEntry, sizeof DirEntry);
    3217       memcpy(&DirEntryStreamOld, &DirEntryStream, sizeof DirEntry);
     3589      PDIRENTRY pDirOld;
     3590
     3591      pDirOld = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     3592      if (!pDirOld)
     3593         {
     3594         rc = ERROR_NOT_ENOUGH_MEMORY;
     3595         goto FS_MOVEEXIT;
     3596         }
     3597
     3598      memcpy(pDirOld, pDirEntry, sizeof(DIRENTRY));
     3599#ifdef EXFAT
     3600      memcpy(pDirEntryStreamOld, pDirEntryStream, sizeof(DIRENTRY1));
     3601#endif
    32183602
    32193603      rc = ModifyDirectory(pVolInfo, ulSrcDirCluster, pDirSrcSHInfo,
    3220          MODIFY_DIR_RENAME, &DirOld, &DirEntry, &DirEntryStream, &DirEntryStreamOld, pszDstFile, 0);
     3604         MODIFY_DIR_RENAME, pDirOld, pDirEntry, pDirEntryStream, pDirEntryStreamOld, pszDstFile, 0);
     3605      free(pDirOld);
    32213606      goto FS_MOVEEXIT;
    32223607      }
     
    32263611   */
    32273612
    3228    rc = ModifyDirectory(pVolInfo, ulSrcDirCluster, pDirSrcSHInfo, MODIFY_DIR_DELETE, &DirEntry, NULL, &DirEntryStream, NULL, NULL, 0);
     3613   rc = ModifyDirectory(pVolInfo, ulSrcDirCluster, pDirSrcSHInfo, MODIFY_DIR_DELETE, pDirEntry, NULL, pDirEntryStream, NULL, NULL, 0);
    32293614   if (rc)
    32303615      goto FS_MOVEEXIT;
     
    32343619   */
    32353620
    3236    rc = ModifyDirectory(pVolInfo, ulDstDirCluster, pDirDstSHInfo, MODIFY_DIR_INSERT, NULL, &DirEntry, NULL, &DirEntryStream, pszDstFile, 0);
     3621   rc = ModifyDirectory(pVolInfo, ulDstDirCluster, pDirDstSHInfo, MODIFY_DIR_INSERT, NULL, pDirEntry, NULL, pDirEntryStream, pszDstFile, 0);
    32373622   if (rc)
    32383623      goto FS_MOVEEXIT;
     
    32433628   */
    32443629#ifdef EXFAT
    3245    if ( (pVolInfo->bFatType < FAT_TYPE_EXFAT) && (DirEntry.bAttr & FILE_DIRECTORY) )
     3630   if ( (pVolInfo->bFatType < FAT_TYPE_EXFAT) && (pDirEntry->bAttr & FILE_DIRECTORY) )
    32463631#else
    3247    if ( DirEntry.bAttr & FILE_DIRECTORY )
     3632   if ( pDirEntry->bAttr & FILE_DIRECTORY )
    32483633#endif
    32493634      {
    32503635      ULONG ulTmp;
    3251       ulTmp = FindPathCluster(pVolInfo, ulCluster, "..", NULL, &DirEntry, &DirEntryStream, NULL); ////
     3636      ulTmp = FindPathCluster(pVolInfo, ulCluster, "..", NULL, pDirEntry, pDirEntryStream, NULL);
    32523637      if (ulTmp != pVolInfo->ulFatEof)
    32533638         {
    3254          DIRENTRY DirNew;
    3255 
    3256          memcpy(&DirNew, &DirEntry, sizeof (DIRENTRY));
    3257          DirNew.wCluster = LOUSHORT(ulDstDirCluster);
    3258          DirNew.wClusterHigh = HIUSHORT(ulDstDirCluster);
     3639         PDIRENTRY pDirNew;
     3640
     3641         pDirNew = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     3642         if (!pDirNew)
     3643            {
     3644            rc = ERROR_NOT_ENOUGH_MEMORY;
     3645            goto FS_MOVEEXIT;
     3646            }
     3647
     3648         memcpy(pDirNew, pDirEntry, sizeof (DIRENTRY));
     3649         pDirNew->wCluster = LOUSHORT(ulDstDirCluster);
     3650         pDirNew->wClusterHigh = HIUSHORT(ulDstDirCluster);
    32593651
    32603652         rc = ModifyDirectory(pVolInfo, ulCluster, NULL,
    3261             MODIFY_DIR_UPDATE, &DirEntry, &DirNew, NULL, NULL, NULL, 0);
     3653            MODIFY_DIR_UPDATE, pDirEntry, pDirNew, NULL, NULL, NULL, 0);
     3654         free(pDirNew);
    32623655         if (rc)
    32633656            goto FS_MOVEEXIT;
     
    32893682      }
    32903683
     3684   if (szSrcLongName)
     3685      free(szSrcLongName);
     3686   if (szDstLongName)
     3687      free(szDstLongName);
     3688   if (pDirEntry)
     3689      free(pDirEntry);
     3690#ifdef EXFAT
     3691   if (pDirEntryStream)
     3692      free(pDirEntryStream);
     3693   if (pDirEntryStreamOld)
     3694      free(pDirEntryStreamOld);
     3695   if (pDirSrcStream)
     3696      free(pDirSrcStream);
     3697   if (pDirDstStream)
     3698      free(pDirDstStream);
     3699   if (pDirSrcSHInfo)
     3700      free(pDirSrcSHInfo);
     3701   if (pDirDstSHInfo)
     3702      free(pDirDstSHInfo);
     3703#endif
     3704
    32913705   if (f32Parms.fMessageActive & LOG_FS)
    32923706      Message("FS_MOVE returned %d", rc);
    32933707
     3708   _asm pop es;
     3709
    32943710   return rc;
    3295 
    3296    _asm pop es;
    32973711
    32983712   usFlags = usFlags;
     
    36994113      }
    37004114
    3701    rc = ReadSector2(pVolInfo, pVolInfo->ulActiveFatStart + ulSec, 3,
     4115   rc = ReadSector(pVolInfo, pVolInfo->ulActiveFatStart + ulSec, 3,
    37024116      pVolInfo->pbFatSector, 0);
    37034117   if (rc)
     
    37804194      }
    37814195
    3782    rc = ReadSector2(pVolInfo, pVolInfo->ulBmpStartSector + ulSector, 1,
     4196   rc = ReadSector(pVolInfo, pVolInfo->ulBmpStartSector + ulSector, 1,
    37834197      pVolInfo->pbFatBits, 0);
    37844198   if (rc)
     
    41114525*
    41124526******************************************************************/
    4113 BOOL ClusterInUse2(PVOLINFO pVolInfo, ULONG ulCluster)
     4527BOOL ClusterInUse(PVOLINFO pVolInfo, ULONG ulCluster)
    41144528{
    41154529#ifdef EXFAT
    41164530ULONG ulBmpSector;
    41174531#endif
     4532BOOL rc;
     4533
     4534   if (f32Parms.fMessageActive & LOG_FUNCS)
     4535      Message("ClusterInUse for %lu", ulCluster);
     4536
     4537   //if (GetFatAccess(pVolInfo, "ClusterInUse"))
     4538   //   return FALSE;
    41184539
    41194540   if (ulCluster >= pVolInfo->ulTotalClusters + 2)
    41204541      {
    41214542      Message("An invalid cluster number %8.8lX was found\n", ulCluster);
    4122       return TRUE;
     4543      rc = TRUE;
     4544      goto ClusterInUse_Exit;
    41234545      }
    41244546
     
    41284550      {
    41294551      ULONG ulNextCluster;
    4130       ulNextCluster = GetNextCluster2(pVolInfo, NULL, ulCluster);
     4552      ulNextCluster = GetNextCluster(pVolInfo, NULL, ulCluster);
    41314553      if (ulNextCluster)
    4132          return TRUE;
     4554         rc = TRUE;
    41334555      else
    4134          return FALSE;
     4556         rc = FALSE;
     4557      goto ClusterInUse_Exit;
    41354558      }
    41364559
     
    41414564      ReadBmpSector(pVolInfo, ulBmpSector);
    41424565
    4143    return GetBmpEntry(pVolInfo, ulCluster);
     4566   rc = GetBmpEntry(pVolInfo, ulCluster);
    41444567#else
    4145    return FALSE;
    4146 #endif
    4147 }
    4148 
    4149 /******************************************************************
    4150 *
    4151 ******************************************************************/
    4152 BOOL ClusterInUse(PVOLINFO pVolInfo, ULONG ulCluster)
    4153 {
    4154    if (f32Parms.fMessageActive & LOG_FUNCS)
    4155       Message("ClusterInUse for %lu", ulCluster);
    4156 
    4157    if (!GetFatAccess(pVolInfo, "ClusterInUse"))
    4158       {
    4159       ulCluster = ClusterInUse2(pVolInfo, ulCluster);
    4160       ReleaseFat(pVolInfo);
    4161       return TRUE;
    4162       }
    4163 
    4164    return FALSE;
    4165 }
    4166 
    4167 #ifdef EXFAT
    4168 
    4169 /******************************************************************
    4170 *
    4171 ******************************************************************/
    4172 BOOL MarkCluster2(PVOLINFO pVolInfo, ULONG ulCluster, BOOL fState)
    4173 {
    4174 ULONG ulBmpSector;
    4175 
    4176    //if (ClusterInUse2(pVolInfo, ulCluster) && fState)
    4177    //   {
    4178    //   return FALSE;
    4179    //   }
    4180 
    4181    ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
    4182 
    4183    if (pVolInfo->ulCurBmpSector != ulBmpSector)
    4184       ReadBmpSector(pVolInfo, ulBmpSector);
    4185 
    4186    SetBmpEntry(pVolInfo, ulCluster, fState);
    4187    WriteBmpSector(pVolInfo, ulBmpSector);
    4188 
    4189    return TRUE;
    4190 }
     4568   rc = FALSE;
     4569#endif
     4570
     4571ClusterInUse_Exit:
     4572   //ReleaseFat(pVolInfo);
     4573   return rc;
     4574}
     4575
     4576#ifdef EXFAT
    41914577
    41924578/******************************************************************
     
    41954581BOOL MarkCluster(PVOLINFO pVolInfo, ULONG ulCluster, BOOL fState)
    41964582{
     4583ULONG ulBmpSector;
     4584
     4585   if (f32Parms.fMessageActive & LOG_FUNCS)
     4586      Message("MarkCluster for %lu", ulCluster);
     4587
     4588   if (!GetFatAccess(pVolInfo, "MarkCluster"))
     4589      {
     4590      //if (ClusterInUse2(pVolInfo, ulCluster) && fState)
     4591      //   {
     4592      //   return FALSE;
     4593      //   }
     4594
     4595      ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
     4596
     4597      if (pVolInfo->ulCurBmpSector != ulBmpSector)
     4598         ReadBmpSector(pVolInfo, ulBmpSector);
     4599
     4600      SetBmpEntry(pVolInfo, ulCluster, fState);
     4601      WriteBmpSector(pVolInfo, ulBmpSector);
     4602      ReleaseFat(pVolInfo);
     4603      return TRUE;
     4604      }
     4605
     4606   return FALSE;
     4607}
     4608
     4609/******************************************************************
     4610*
     4611******************************************************************/
     4612/* BOOL MarkCluster(PVOLINFO pVolInfo, ULONG ulCluster, BOOL fState)
     4613{
    41974614   if (f32Parms.fMessageActive & LOG_FUNCS)
    41984615      Message("MarkCluster for %lu", ulCluster);
     
    42064623
    42074624   return FALSE;
    4208 }
     4625} */
    42094626
    42104627#endif
     
    42134630*
    42144631******************************************************************/
    4215 ULONG GetFreeSpace2(PVOLINFO pVolInfo)
     4632ULONG GetFreeSpace(PVOLINFO pVolInfo)
    42164633{
    42174634//ULONG ulSector = 0;
     
    42374654      //ulNextCluster = GetFatEntry(pVolInfo, ulCluster);
    42384655      //if (ulNextCluster == 0)
    4239       if (!ClusterInUse2(pVolInfo, ulCluster))
     4656      if (!ClusterInUse(pVolInfo, ulCluster))
    42404657         {
    42414658         ulTotalFree++;
     
    42624679*
    42634680******************************************************************/
    4264 ULONG GetFreeSpace(PVOLINFO pVolInfo)
     4681/* ULONG GetFreeSpace(PVOLINFO pVolInfo)
    42654682{
    42664683ULONG rc;
     
    42764693
    42774694   return rc;
    4278 }
     4695} */
    42794696
    42804697/******************************************************************
     
    43124729   pVolInfo->fDiskClean = FALSE;
    43134730
    4314    if (GetFatAccess(pVolInfo, "MakeFatChain"))
     4731   if (pVolInfo->pBootFSInfo->ulFreeClusters < ulClustersRequested)
    43154732      return pVolInfo->ulFatEof;
    4316 
    4317    if (pVolInfo->pBootFSInfo->ulFreeClusters < ulClustersRequested)
    4318       {
    4319       ReleaseFat(pVolInfo);
    4320       return pVolInfo->ulFatEof;
    4321       }
    43224733
    43234734   ulReturn = pVolInfo->ulFatEof;
     
    43564767            while (ulFirstCluster < pVolInfo->ulTotalClusters + 2)
    43574768               {
    4358                ulSector  = GetFatEntrySec(pVolInfo, ulFirstCluster);
    4359                ulNextCluster = GetFatEntry(pVolInfo, ulFirstCluster);
    4360 
    4361                if (ulSector != pVolInfo->ulCurFatSector)
    4362                   ReadFatSector(pVolInfo, ulSector);
     4769               if (!GetFatAccess(pVolInfo, "MakeFatChain"))
     4770                  {
     4771                  ulSector  = GetFatEntrySec(pVolInfo, ulFirstCluster);
     4772                  ulNextCluster = GetFatEntry(pVolInfo, ulFirstCluster);
     4773
     4774                  if (ulSector != pVolInfo->ulCurFatSector)
     4775                     ReadFatSector(pVolInfo, ulSector);
     4776
     4777                  ReleaseFat(pVolInfo);
     4778                  }
    43634779
    43644780               if (!ulNextCluster)
     
    43724788            while (ulFirstCluster < pVolInfo->ulTotalClusters + 2)
    43734789               {
    4374                ulBmpSector = GetAllocBitmapSec(pVolInfo, ulFirstCluster);
    4375                fStatus = GetBmpEntry(pVolInfo, ulFirstCluster);
    4376 
    4377                if (ulBmpSector != pVolInfo->ulCurBmpSector)
    4378                   ReadBmpSector(pVolInfo, ulBmpSector);
     4790               if (!GetFatAccess(pVolInfo, "MakeFatChain"))
     4791                  {
     4792                  ulBmpSector = GetAllocBitmapSec(pVolInfo, ulFirstCluster);
     4793                  fStatus = GetBmpEntry(pVolInfo, ulFirstCluster);
     4794
     4795                  if (ulBmpSector != pVolInfo->ulCurBmpSector)
     4796                     ReadBmpSector(pVolInfo, ulBmpSector);
     4797
     4798                  ReleaseFat(pVolInfo);
     4799                  }
    43794800
    43804801               if (!fStatus)
     
    44144835               {
    44154836               ULONG ulNewCluster = 0;
    4416                ulSector = GetFatEntrySec(pVolInfo, ulCluster);
    4417                ulNewCluster = GetFatEntry(pVolInfo, ulCluster);
    4418                if (ulSector != pVolInfo->ulCurFatSector)
    4419                   ReadFatSector(pVolInfo, ulSector);
     4837               if (!GetFatAccess(pVolInfo, "MakeFatChain"))
     4838                  {
     4839                  ulSector = GetFatEntrySec(pVolInfo, ulCluster);
     4840
     4841                  ulNewCluster = GetFatEntry(pVolInfo, ulCluster);
     4842                  if (ulSector != pVolInfo->ulCurFatSector)
     4843                     ReadFatSector(pVolInfo, ulSector);
     4844
     4845                  ReleaseFat(pVolInfo);
     4846                  }
    44204847               if (ulNewCluster)
    44214848                  break;
     
    44314858               {
    44324859               BOOL fStatus1;
    4433                ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
    4434                fStatus1 = GetBmpEntry(pVolInfo, ulCluster);
    4435                if (ulBmpSector != pVolInfo->ulCurBmpSector)
    4436                   ReadBmpSector(pVolInfo, ulBmpSector);
     4860               if (!GetFatAccess(pVolInfo, "MakeFatChain"))
     4861                  {
     4862                  ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
     4863
     4864                  fStatus1 = GetBmpEntry(pVolInfo, ulCluster);
     4865                  if (ulBmpSector != pVolInfo->ulCurBmpSector)
     4866                     ReadBmpSector(pVolInfo, ulBmpSector);
     4867
     4868                  ReleaseFat(pVolInfo);
     4869                  }
    44374870               if (fStatus1)
    44384871                  break;
     
    44664899         if (ulPrevCluster != pVolInfo->ulFatEof)
    44674900            {
    4468             if (SetNextCluster2(pVolInfo, ulPrevCluster, ulFirstCluster) == pVolInfo->ulFatEof)
     4901            if (SetNextCluster(pVolInfo, ulPrevCluster, ulFirstCluster) == pVolInfo->ulFatEof)
    44694902               goto MakeFatChain_Error;
    44704903            }
     
    45014934         if (ulPrevCluster != pVolInfo->ulFatEof)
    45024935            {
    4503             if (SetNextCluster2(pVolInfo, ulPrevCluster, ulFirstCluster) == pVolInfo->ulFatEof)
     4936            if (SetNextCluster(pVolInfo, ulPrevCluster, ulFirstCluster) == pVolInfo->ulFatEof)
    45044937               goto MakeFatChain_Error;
    45054938            }
     
    45144947MakeFatChain_Error:
    45154948
    4516    ReleaseFat(pVolInfo);
    45174949   if (ulReturn != pVolInfo->ulFatEof)
    45184950      DeleteFatChain(pVolInfo, ulReturn);
     
    45434975   ulLastCluster = ulFirstCluster + ulSize - 1;
    45444976
     4977   if (GetFatAccess(pVolInfo, "MakeFatChain"))
     4978      return 1;
     4979
    45454980   ulSector = GetFatEntrySec(pVolInfo, ulFirstCluster);
    45464981   if (ulSector != pVolInfo->ulCurFatSector)
     
    45655000            rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
    45665001            if (rc)
     5002               {
     5003               ReleaseFat(pVolInfo);
    45675004               return rc;
     5005               }
    45685006            ReadFatSector(pVolInfo, ulSector);
    45695007            }
     
    45775015            CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
    45785016            Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
     5017            ReleaseFat(pVolInfo);
    45795018            return ERROR_SECTOR_NOT_FOUND;
    45805019            }
     
    45895028            rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
    45905029            if (rc)
     5030               {
     5031               ReleaseFat(pVolInfo);
    45915032               return rc;
     5033               }
    45925034            ReadBmpSector(pVolInfo, ulBmpSector);
    45935035            }
     
    45975039            CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
    45985040            Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
     5041            ReleaseFat(pVolInfo);
    45995042            return ERROR_SECTOR_NOT_FOUND;
    46005043            }
     
    46135056         rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
    46145057         if (rc)
     5058            {
     5059            ReleaseFat(pVolInfo);
    46155060            return rc;
     5061            }
    46165062         ReadFatSector(pVolInfo, ulSector);
    46175063         }
     
    46215067         CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
    46225068         Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
     5069         ReleaseFat(pVolInfo);
    46235070         return ERROR_SECTOR_NOT_FOUND;
    46245071         }
     
    46275074      rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
    46285075      if (rc)
     5076         {
     5077         ReleaseFat(pVolInfo);
    46295078         return rc;
     5079         }
    46305080      }
    46315081
     
    46385088         rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
    46395089         if (rc)
     5090            {
     5091            ReleaseFat(pVolInfo);
    46405092            return rc;
     5093            }
    46415094         ReadBmpSector(pVolInfo, ulBmpSector);
    46425095         }
     
    46465099         CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
    46475100         Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
     5101         ReleaseFat(pVolInfo);
    46485102         return ERROR_SECTOR_NOT_FOUND;
    46495103         }
     
    46525106      rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
    46535107      if (rc)
     5108         {
     5109         ReleaseFat(pVolInfo);
    46545110         return rc;
     5111         }
    46555112      }
    46565113#endif
     
    46605117   pVolInfo->pBootFSInfo->ulFreeClusters   -= ulSize;
    46615118
     5119   ReleaseFat(pVolInfo);
    46625120   return 0;
    46635121}
     
    48545312*
    48555313******************************************************************/
    4856 ULONG SetNextCluster(PVOLINFO pVolInfo, ULONG ulCluster, ULONG ulNext)
     5314/* ULONG SetNextCluster(PVOLINFO pVolInfo, ULONG ulCluster, ULONG ulNext)
    48575315{
    48585316   if (f32Parms.fMessageActive & LOG_FUNCS)
     
    48665324   ReleaseFat(pVolInfo);
    48675325   return ulCluster;
    4868 }
     5326} */
    48695327
    48705328/******************************************************************
    48715329*
    48725330******************************************************************/
    4873 ULONG SetNextCluster2(PVOLINFO pVolInfo, ULONG ulCluster, ULONG ulNext)
     5331ULONG SetNextCluster(PVOLINFO pVolInfo, ULONG ulCluster, ULONG ulNext)
    48745332{
    48755333ULONG ulNewCluster = 0;
     
    48775335ULONG ulReturn = 0;
    48785336USHORT rc;
     5337
     5338   if (f32Parms.fMessageActive & LOG_FUNCS)
     5339      Message("SetNextCluster");
     5340
    48795341
    48805342   ulReturn = ulNext;
     
    48965358         An existing chain is extended
    48975359      */
    4898       ulNext = SetNextCluster2(pVolInfo, FAT_ASSIGN_NEW, pVolInfo->ulFatEof);
     5360      ulNext = SetNextCluster(pVolInfo, FAT_ASSIGN_NEW, pVolInfo->ulFatEof);
    48995361      if (ulNext == pVolInfo->ulFatEof)
    49005362         return pVolInfo->ulFatEof;
     
    49105372      {
    49115373      // mark cluster in exFAT allocation bitmap
    4912       MarkCluster2(pVolInfo, ulCluster, (BOOL)ulNext);
    4913       }
    4914 #endif
     5374      MarkCluster(pVolInfo, ulCluster, (BOOL)ulNext);
     5375      }
     5376#endif
     5377
     5378   if (GetFatAccess(pVolInfo, "SetNextCluster"))
     5379      return pVolInfo->ulFatEof;
    49155380
    49165381   if (ReadFatSector(pVolInfo, GetFatEntrySec(pVolInfo, ulCluster)))
     
    49365401   pVolInfo->fDiskClean = fClean;
    49375402   if (rc)
     5403      {
     5404      ReleaseFat(pVolInfo);
    49385405      return pVolInfo->ulFatEof;
    4939 
     5406      }
    49405407/*
    49415408   if (fUpdateFSInfo)
     
    49435410*/
    49445411
     5412   ReleaseFat(pVolInfo);
    49455413   return ulReturn;
    49465414}
     
    49755443
    49765444   //while (GetNextCluster2(pVolInfo, NULL, ulCluster))
    4977    while (ClusterInUse2(pVolInfo, ulCluster))
     5445   while (ClusterInUse(pVolInfo, ulCluster))
    49785446      {
    49795447      ulCluster++;
     
    54215889PDIRENTRY1 pLN;
    54225890USHORT usIndex;
    5423 UCHAR  szLongName1[FAT32MAXPATH];
    5424 USHORT pusUniName[256];
     5891//UCHAR  szLongName1[FAT32MAXPATH];
     5892PSZ pszLongName1;
     5893//USHORT pusUniName[256];
     5894PUSHORT pusUniName;
    54255895USHORT uniName[15];
    54265896USHORT uniName1[15];
    5427 PSZ pszLongName1 = szLongName1;
    54285897PUSHORT p, q, p1;
    54295898PSZ     r;
    54305899
    54315900   if (!pszLongName || !strlen(pszLongName))
     5901      return pDir;
     5902
     5903   pszLongName1 = (PSZ)malloc((size_t)FAT32MAXPATH);
     5904   if (!pszLongName1)
     5905      return pDir;
     5906
     5907   pusUniName = (PUSHORT)malloc(256 * sizeof(USHORT));
     5908   if (!pusUniName)
    54325909      return pDir;
    54335910
     
    54355912   strcpy(pszLongName1, pszLongName);
    54365913   FSH_UPPERCASE(pszLongName1, FAT32MAXPATH, pszLongName1);
    5437 
    5438    //pusUniName = malloc(256 * sizeof(USHORT));
    54395914
    54405915   usNeededEntries = ( DBCSStrlen( pszLongName ) + 14 ) / 15;
     
    54775952      *pusNameHash = NameHash(pusUniName, DBCSStrlen(r));
    54785953
    5479    //free(pusUniName);
     5954   free(pusUniName);
     5955   free(pszLongName1);
    54805956
    54815957   return pLN;
     
    59616437}
    59626438
     6439#ifdef EXFAT
     6440
    59636441void SetSHInfo1(PVOLINFO pVolInfo, PDIRENTRY1 pStreamEntry, PSHOPENINFO pSHInfo)
    59646442{
     
    59686446   pSHInfo->ulLastCluster = GetLastCluster(pVolInfo, pStreamEntry->u.Stream.ulFirstClus, pStreamEntry);
    59696447}
     6448
     6449#endif
    59706450
    59716451ULONG GetLastCluster(PVOLINFO pVolInfo, ULONG ulCluster, PDIRENTRY1 pDirEntryStream)
  • trunk/src/ifs/fat32b.c

    r280 r284  
    3737static ULONG ulSemRWBuf3 = 0UL;
    3838
    39 #ifdef USE_STATIC_BUFS
    40 static BYTE _based(_segname("fat32_buf1_DATA")) pbDirBuf1[0x10000] = {0};
    41 static BYTE _based(_segname("fat32_buf2_DATA")) pbDirBuf2[0x8000]  = {0};
    42 static BYTE _based(_segname("fat32_buf2_DATA")) pbDirBuf3[0x8000]  = {0};
    43 #endif
    4439
    4540/******************************************************************
     
    5550   PDIRENTRY1 pStreamEntry)
    5651{
    57 BYTE   szDir[FAT32MAXPATH];
     52//BYTE   szDir[FAT32MAXPATH];
     53PSZ    szDir;
    5854ULONG  ulCluster;
    5955ULONG  ulCluster2;
    60 DIRENTRY DirEntry;
     56PDIRENTRY pDirEntry;
     57PDIRENTRY1 pDirEntry1;
    6158PSZ    p;
    6259
     
    7572      {
    7673      ulCluster = pVolInfo->BootSect.bpb.RootDirStrtClus;
     74#ifdef EXFAT
    7775      if (pStreamEntry)
    7876         {
    7977         // fill the Stream entry for root directory
    8078         memset(pStreamEntry, 0, sizeof(DIRENTRY1));
    81 #ifdef EXFAT
    8279         if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    8380            {
     
    8582            pStreamEntry->u.Stream.ulFirstClus = ulCluster;
    8683            }
     84         }
    8785#endif
    88          }
    8986      if (strlen(pDir) >= 2)
    9087         {
     
    9390         }
    9491      }
     92
     93   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     94   if (!pDirEntry)
     95      {
     96      return ERROR_NOT_ENOUGH_MEMORY;
     97      }
     98   pDirEntry1 = (PDIRENTRY1)pDirEntry;
    9599
    96100   if (*pDir == '\\')
     
    100104   if (!p)
    101105      p = pDir;
    102    memset(szDir, 0, sizeof szDir);
     106   szDir = (PSZ)malloc((size_t)FAT32MAXPATH);
     107   if (!szDir)
     108      {
     109      free(pDirEntry);
     110      return pVolInfo->ulFatEof;
     111      }
     112   //memset(szDir, 0, sizeof szDir);
     113   memset(szDir, 0, FAT32MAXPATH);
    103114   memcpy(szDir, pDir, p - pDir);
    104115   if (*p && p != pDir)
     
    110121      *pDirEnd = pDir;
    111122
    112    ulCluster = FindPathCluster(pVolInfo, ulCluster, szDir, NULL, &DirEntry, pStreamEntry, NULL); ////
     123   ulCluster = FindPathCluster(pVolInfo, ulCluster, szDir, NULL, pDirEntry, pStreamEntry, NULL);
    113124   if (ulCluster == pVolInfo->ulFatEof)
    114125      {
    115126      if (f32Parms.fMessageActive & LOG_FUNCS)
    116127         Message("FindDirCluster for '%s', not found", szDir);
     128      free(szDir);
     129      free(pDirEntry);
    117130      return pVolInfo->ulFatEof;
    118131      }
    119132   if ( ulCluster != pVolInfo->ulFatEof &&
    120133#ifdef EXFAT
    121        ( ( (pVolInfo->bFatType < FAT_TYPE_EXFAT)  && !(DirEntry.bAttr & FILE_DIRECTORY) ) ||
    122          ( (pVolInfo->bFatType == FAT_TYPE_EXFAT) && !(((PDIRENTRY1)&DirEntry)->u.File.usFileAttr & FILE_DIRECTORY) ) ) )
     134       ( ( (pVolInfo->bFatType < FAT_TYPE_EXFAT)  && !(pDirEntry->bAttr & FILE_DIRECTORY) ) ||
     135         ( (pVolInfo->bFatType == FAT_TYPE_EXFAT) && !(pDirEntry1->u.File.usFileAttr & FILE_DIRECTORY) ) ) )
    123136#else
    124        !(DirEntry.bAttr & FILE_DIRECTORY) )
     137       !(pDirEntry->bAttr & FILE_DIRECTORY) )
    125138#endif
    126139      {
    127140      if (f32Parms.fMessageActive & LOG_FUNCS)
    128141         Message("FindDirCluster for '%s', not a directory", szDir);
     142      free(szDir);
     143      free(pDirEntry);
    129144      return pVolInfo->ulFatEof;
    130145      }
     
    134149      if (usAttrWanted != RETURN_PARENT_DIR && !strpbrk(pDir, "?*"))
    135150         {
    136          ulCluster2 = FindPathCluster(pVolInfo, ulCluster, pDir, NULL, &DirEntry, pStreamEntry, NULL); ////
     151         ulCluster2 = FindPathCluster(pVolInfo, ulCluster, pDir, NULL, pDirEntry, pStreamEntry, NULL);
    137152         if ( ulCluster2 != pVolInfo->ulFatEof &&
    138153#ifdef EXFAT
    139              ( (pVolInfo->bFatType < FAT_TYPE_EXFAT)  && ((DirEntry.bAttr & usAttrWanted) == usAttrWanted) ) ||
    140                ( (pVolInfo->bFatType == FAT_TYPE_EXFAT) && ((((PDIRENTRY1)&DirEntry)->u.File.usFileAttr & usAttrWanted) == usAttrWanted) ) )
     154             ( (pVolInfo->bFatType < FAT_TYPE_EXFAT)  && ((pDirEntry->bAttr & usAttrWanted) == usAttrWanted) ) ||
     155               ( (pVolInfo->bFatType == FAT_TYPE_EXFAT) && ((pDirEntry1->u.File.usFileAttr & usAttrWanted) == usAttrWanted) ) )
    141156#else
    142              ( (DirEntry.bAttr & usAttrWanted) == usAttrWanted ) )
     157             ( (pDirEntry->bAttr & usAttrWanted) == usAttrWanted ) )
    143158#endif
    144159            {
    145160            if (pDirEnd)
    146161               *pDirEnd = pDir + strlen(pDir);
     162            free(szDir);
     163            free(pDirEntry);
    147164            return ulCluster2;
    148165            }
     
    150167      }
    151168
     169   free(szDir);
     170   free(pDirEntry);
    152171   return ulCluster;
    153172}
     
    156175#define MODE_RETURN 1
    157176#define MODE_SCAN   2
    158 
    159 /******************************************************************
    160 *
    161 ******************************************************************/
    162 ULONG FindPathCluster0(PVOLINFO pVolInfo, ULONG ulCluster, PSZ pszPath, PDIRENTRY pDirEntry, PSZ pszFullName)
    163 {
    164 // FAT12/FAT16/FAT32 case
    165 BYTE szShortName[13];
    166 #ifdef USE_STATIC_BUFS
    167 static BYTE szLongName[FAT32MAXPATHCOMP * 2];
    168 PSZ  pszLongName = szLongName;
    169 #else
    170 PSZ  pszLongName;
    171 #endif
    172 PSZ  pszPart;
    173 PSZ  p;
    174 PDIRENTRY pDir;
    175 #ifdef USE_STATIC_BUFS
    176 PDIRENTRY pDirStart = (PDIRENTRY)pbDirBuf3;
    177 #else
    178 PDIRENTRY pDirStart;
    179 #endif
    180 PDIRENTRY pDirEnd;
    181 BOOL fFound;
    182 USHORT usMode;
    183 BYTE   bCheck;
    184 PROCINFO ProcInfo;
    185 ULONG  ulSector;
    186 USHORT usSectorsRead;
    187 USHORT usSectorsPerBlock;
    188 USHORT usDirEntries = 0;
    189 USHORT usMaxDirEntries = (USHORT)(pVolInfo->ulBlockSize / sizeof(DIRENTRY));
    190 
    191    if (f32Parms.fMessageActive & LOG_FUNCS)
    192       Message("FindPathCluster for %s, dircluster %lu", pszPath, ulCluster);
    193 
    194    if (ulCluster == 1)
    195       {
    196       // root directory starting sector
    197       ulSector = pVolInfo->BootSect.bpb.ReservedSectors +
    198          pVolInfo->BootSect.bpb.SectorsPerFat * pVolInfo->BootSect.bpb.NumberOfFATs;
    199       usSectorsPerBlock = (USHORT)pVolInfo->SectorsPerCluster /
    200          (USHORT)(pVolInfo->ulClusterSize / pVolInfo->ulBlockSize);
    201       usSectorsRead = 0;
    202       }
    203 
    204    if (pDirEntry)
    205       {
    206       memset(pDirEntry, 0, sizeof (DIRENTRY));
    207       pDirEntry->bAttr = FILE_DIRECTORY;
    208       }
    209    if (pszFullName)
    210       {
    211       memset(pszFullName, 0, FAT32MAXPATH);
    212       if (ulCluster == pVolInfo->BootSect.bpb.RootDirStrtClus)
    213          {
    214          pszFullName[0] = (BYTE)(pVolInfo->bDrive + 'A');
    215          pszFullName[1] = ':';
    216          pszFullName[2] = '\\';
    217          }
    218       }
    219 
    220    if (strlen(pszPath) >= 2)
    221       {
    222       if (pszPath[1] == ':')
    223          pszPath += 2;
    224       }
    225 
    226 #ifndef USE_STATIC_BUFS
    227    pDirStart = malloc((size_t)pVolInfo->ulBlockSize);
    228    if (!pDirStart)
    229       {
    230       Message("FAT32: Not enough memory for cluster in FindPathCluster");
    231       return pVolInfo->ulFatEof;
    232       }
    233    pszLongName = malloc((size_t)FAT32MAXPATHCOMP * 2);
    234    if (!pszLongName)
    235       {
    236       Message("FAT32: Not enough memory for buffers in FindPathCluster");
    237       free(pDirStart);
    238       return pVolInfo->ulFatEof;
    239       }
    240 #endif
    241    memset(pszLongName, 0, FAT32MAXPATHCOMP * 2);
    242    pszPart = pszLongName + FAT32MAXPATHCOMP;
    243 
    244    usMode = MODE_SCAN;
    245    GetProcInfo(&ProcInfo, sizeof ProcInfo);
    246    /*
    247       Allow EA files to be found!
    248    */
    249    if (ProcInfo.usPdb && f32Parms.fEAS && IsEASFile(pszPath))
    250       ProcInfo.usPdb = 0;
    251 
    252    while (usMode != MODE_RETURN && ulCluster != pVolInfo->ulFatEof)
    253       {
    254       usMode = MODE_SCAN;
    255 
    256       if (*pszPath == '\\')
    257          pszPath++;
    258 
    259       if (!strlen(pszPath))
    260          break;
    261 
    262       p = strchr(pszPath, '\\');
    263       if (!p)
    264          p = pszPath + strlen(pszPath);
    265 
    266       memset(pszPart, 0, FAT32MAXPATHCOMP);
    267       if (p - pszPath > FAT32MAXPATHCOMP - 1)
    268          {
    269 #ifndef USE_STATIC_BUFS
    270          free(pDirStart);
    271          free(pszLongName);
    272 #endif
    273          return pVolInfo->ulFatEof;
    274          }
    275 
    276       memcpy(pszPart, pszPath, p - pszPath);
    277       pszPath = p;
    278 
    279       memset(pszLongName, 0, FAT32MAXPATHCOMP);
    280 
    281       fFound = FALSE;
    282       while (usMode == MODE_SCAN && ulCluster != pVolInfo->ulFatEof)
    283          {
    284          ULONG ulBlock;
    285          for (ulBlock = 0; ulBlock < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize; ulBlock++)
    286             {
    287             if (ulCluster == 1)
    288                // reading root directory on FAT12/FAT16
    289                ReadSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirStart, 0);
    290             else
    291                ReadBlock(pVolInfo, ulCluster, ulBlock, pDirStart, 0); ////
    292             pDir    = pDirStart;
    293             pDirEnd = (PDIRENTRY)((PBYTE)pDirStart + pVolInfo->ulBlockSize);
    294 
    295 #ifdef CALL_YIELD
    296             Yield();
    297 #endif
    298 
    299             usDirEntries = 0;
    300             //while (usMode == MODE_SCAN && pDir < pDirEnd)
    301             while (usMode == MODE_SCAN && usDirEntries < usMaxDirEntries)
    302                {
    303                if (pDir->bAttr == FILE_LONGNAME)
    304                   {
    305                   fGetLongName(pDir, pszLongName, FAT32MAXPATHCOMP, &bCheck);
    306                   }
    307                else if ((pDir->bAttr & 0x0F) != FILE_VOLID)
    308                   {
    309                   MakeName(pDir, szShortName, sizeof szShortName);
    310                   FSH_UPPERCASE(szShortName, sizeof szShortName, szShortName);
    311                   if (strlen(pszLongName) && bCheck != GetVFATCheckSum(pDir))
    312                      memset(pszLongName, 0, FAT32MAXPATHCOMP);
    313 
    314                    /* support for the FAT32 variation of WinNT family */
    315                    if( !*pszLongName && HAS_WINNT_EXT( pDir->fEAS ))
    316                    {
    317                        PBYTE pDot;
    318 
    319                        MakeName( pDir, pszLongName, sizeof( pszLongName ));
    320                        pDot = strchr( pszLongName, '.' );
    321 
    322                        if( HAS_WINNT_EXT_NAME( pDir->fEAS )) /* name part is lower case */
    323                        {
    324                            if( pDot )
    325                                *pDot = 0;
    326 
    327                            strlwr( pszLongName );
    328 
    329                            if( pDot )
    330                                *pDot = '.';
    331                        }
    332 
    333                        if( pDot && HAS_WINNT_EXT_EXT( pDir->fEAS )) /* ext part is lower case */
    334                            strlwr( pDot + 1 );
    335                    }
    336 
    337                   if (!strlen(pszLongName))
    338                      strcpy(pszLongName, szShortName);
    339 
    340                   if (( strlen(pszLongName) && !stricmp(pszPart, pszLongName)) ||
    341                       !stricmp( pszPart, szShortName ))
    342                      {
    343                        if( pszFullName )
    344                            strcat( pszFullName, pszLongName );
    345                        fFound = TRUE;
    346                      }
    347 
    348                   if (fFound)
    349                      {
    350                      ulCluster = (ULONG)pDir->wClusterHigh * 0x10000L + pDir->wCluster;
    351                      ulCluster &= pVolInfo->ulFatEof;
    352                      if (strlen(pszPath))
    353                         {
    354                         if (pDir->bAttr & FILE_DIRECTORY)
    355                            {
    356                            if (pszFullName)
    357                               strcat(pszFullName, "\\");
    358                            usMode = MODE_START;
    359                            break;
    360                            }
    361                         ulCluster = pVolInfo->ulFatEof;
    362                         }
    363                      else
    364                         {
    365                         if (pDirEntry)
    366                            memcpy(pDirEntry, pDir, sizeof (DIRENTRY));
    367                         }
    368                      usMode = MODE_RETURN;
    369                      break;
    370                      }
    371                   memset(pszLongName, 0, FAT32MAXPATHCOMP);
    372                   }
    373                pDir++;
    374                usDirEntries++;
    375                if (ulCluster == 1 && usDirEntries > pVolInfo->BootSect.bpb.RootDirEntries)
    376                   break;
    377                }
    378             if (usMode != MODE_SCAN)
    379                break;
    380             }
    381          if (usMode != MODE_SCAN)
    382             break;
    383          if (ulCluster == 1)
    384             {
    385             // reading the root directory in case of FAT12/FAT16
    386             ulSector += pVolInfo->SectorsPerCluster;
    387             usSectorsRead += pVolInfo->SectorsPerCluster;
    388             if (usSectorsRead * pVolInfo->BootSect.bpb.BytesPerSector >=
    389                 pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY))
    390                // root directory ended
    391                ulCluster = 0;
    392             }
    393          else
    394             ulCluster = GetNextCluster(pVolInfo, NULL, ulCluster);
    395          if (!ulCluster)
    396             ulCluster = pVolInfo->ulFatEof;
    397          }
    398       }
    399 #ifndef USE_STATIC_BUFS
    400    free(pDirStart);
    401    free(pszLongName);
    402 #endif
    403    if (f32Parms.fMessageActive & LOG_FUNCS)
    404       {
    405       if (ulCluster != pVolInfo->ulFatEof)
    406          Message("FindPathCluster for %s found cluster %ld", pszPath, ulCluster);
    407       else
    408          Message("FindPathCluster for %s returned EOF", pszPath);
    409       }
    410    return ulCluster;
    411 }
    412 
    413 #ifdef EXFAT
    414 
    415 /******************************************************************
    416 *
    417 ******************************************************************/
    418 ULONG FindPathCluster1(PVOLINFO pVolInfo, ULONG ulCluster, PSZ pszPath, PSHOPENINFO pSHInfo,
    419                        PDIRENTRY1 pDirEntry, PDIRENTRY1 pDirEntryStream,
    420                        PSZ pszFullName)
    421 {
    422 // exFAT case
    423 #ifdef USE_STATIC_BUFS
    424 static BYTE szLongName[FAT32MAXPATHCOMP * 2];
    425 PSZ  pszLongName = szLongName;
    426 #else
    427 PSZ  pszLongName;
    428 #endif
    429 PSZ  pszPart;
    430 PSZ  p;
    431 DIRENTRY1  Dir;
    432 PDIRENTRY1 pDir;
    433 #ifdef USE_STATIC_BUFS
    434 PDIRENTRY1 pDirStart = (PDIRENTRY1)pbDirBuf3;
    435 #else
    436 PDIRENTRY1 pDirStart;
    437 #endif
    438 PDIRENTRY1 pDirEnd;
    439 BOOL fFound;
    440 USHORT usMode;
    441 PROCINFO ProcInfo;
    442 USHORT usDirEntries = 0;
    443 USHORT usMaxDirEntries = (USHORT)(pVolInfo->ulBlockSize / sizeof(DIRENTRY1));
    444 ULONG  ulRet;
    445 USHORT usNumSecondary;
    446 USHORT usFileAttr;
    447 
    448    if (f32Parms.fMessageActive & LOG_FUNCS)
    449       Message("FindPathCluster for %s, dircluster %lu", pszPath, ulCluster);
    450 
    451    if (pDirEntry)
    452       {
    453       memset(pDirEntry, 0, sizeof (DIRENTRY1));
    454       pDirEntry->u.File.usFileAttr = FILE_DIRECTORY;
    455       }
    456    if (pszFullName)
    457       {
    458       memset(pszFullName, 0, FAT32MAXPATH);
    459       if (ulCluster == pVolInfo->BootSect.bpb.RootDirStrtClus)
    460          {
    461          pszFullName[0] = (BYTE)(pVolInfo->bDrive + 'A');
    462          pszFullName[1] = ':';
    463          pszFullName[2] = '\\';
    464          }
    465       }
    466 
    467    if (pDirEntryStream)
    468       memset(pDirEntryStream, 0, sizeof(DIRENTRY1));
    469 
    470    if (strlen(pszPath) >= 2)
    471       {
    472       if (pszPath[1] == ':')
    473          pszPath += 2;
    474       }
    475 
    476 #ifndef USE_STATIC_BUFS
    477    pDirStart = malloc((size_t)pVolInfo->ulBlockSize);
    478    if (!pDirStart)
    479       {
    480       Message("FAT32: Not enough memory for cluster in FindPathCluster");
    481       return pVolInfo->ulFatEof;
    482       }
    483    pszLongName = malloc((size_t)FAT32MAXPATHCOMP * 2);
    484    if (!pszLongName)
    485       {
    486       Message("FAT32: Not enough memory for buffers in FindPathCluster");
    487       free(pDirStart);
    488       return pVolInfo->ulFatEof;
    489       }
    490 #endif
    491    memset(pszLongName, 0, FAT32MAXPATHCOMP * 2);
    492    pszPart = pszLongName + FAT32MAXPATHCOMP;
    493 
    494    usMode = MODE_SCAN;
    495    GetProcInfo(&ProcInfo, sizeof ProcInfo);
    496    /*
    497       Allow EA files to be found!
    498    */
    499    if (ProcInfo.usPdb && f32Parms.fEAS && IsEASFile(pszPath))
    500       ProcInfo.usPdb = 0;
    501 
    502    while (usMode != MODE_RETURN && ulCluster != pVolInfo->ulFatEof)
    503       {
    504       usMode = MODE_SCAN;
    505 
    506       if (*pszPath == '\\')
    507          pszPath++;
    508 
    509       if (!strlen(pszPath))
    510          break;
    511 
    512       p = strchr(pszPath, '\\');
    513       if (!p)
    514          p = pszPath + strlen(pszPath);
    515 
    516       memset(pszPart, 0, FAT32MAXPATHCOMP);
    517       if (p - pszPath > FAT32MAXPATHCOMP - 1)
    518          {
    519 #ifndef USE_STATIC_BUFS
    520          free(pDirStart);
    521          free(pszLongName);
    522 #endif
    523          return pVolInfo->ulFatEof;
    524          }
    525 
    526       memcpy(pszPart, pszPath, p - pszPath);
    527       pszPath = p;
    528 
    529       memset(pszLongName, 0, FAT32MAXPATHCOMP);
    530 
    531       fFound = FALSE;
    532       while (usMode == MODE_SCAN && ulCluster != pVolInfo->ulFatEof)
    533          {
    534          ULONG ulBlock;
    535          for (ulBlock = 0; ulBlock < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize; ulBlock++)
    536             {
    537             ReadBlock(pVolInfo, ulCluster, ulBlock, pDirStart, 0);
    538             pDir    = pDirStart;
    539             pDirEnd = (PDIRENTRY1)((PBYTE)pDirStart + pVolInfo->ulBlockSize);
    540 
    541 #ifdef CALL_YIELD
    542             Yield();
    543 #endif
    544 
    545             usDirEntries = 0;
    546             //while (usMode == MODE_SCAN && pDir < pDirEnd)
    547             while (usMode == MODE_SCAN && usDirEntries < usMaxDirEntries)
    548                {
    549                if (pDir->bEntryType == ENTRY_TYPE_EOD)
    550                   {
    551                   ulCluster = pVolInfo->ulFatEof;
    552                   usMode = MODE_RETURN;
    553                   break;
    554                   }
    555                else if (pDir->bEntryType & ENTRY_TYPE_IN_USE_STATUS)
    556                   {
    557                   if (pDir->bEntryType == ENTRY_TYPE_FILE_NAME)
    558                      {
    559                      usNumSecondary--;
    560                      fGetLongName1(pDir, pszLongName, FAT32MAXPATHCOMP);
    561 
    562                      if (!usNumSecondary)
    563                         {
    564                         //MakeName(pDir, szShortName, sizeof szShortName);
    565                         //FSH_UPPERCASE(szShortName, sizeof szShortName, szShortName);
    566                         //if (strlen(pszLongName) && bCheck != GetVFATCheckSum(pDir))
    567                         //   memset(pszLongName, 0, FAT32MAXPATHCOMP);
    568 #if 0
    569                         /* support for the FAT32 variation of WinNT family */
    570                         if( !*pszLongName && HAS_WINNT_EXT( pDir->u.File.fEAS ))
    571                            {
    572                            PBYTE pDot;
    573 
    574                            MakeName( pDir, pszLongName, sizeof( pszLongName ));
    575                            pDot = strchr( pszLongName, '.' );
    576 
    577                            if( HAS_WINNT_EXT_NAME( pDir->u.File.fEAS )) /* name part is lower case */
    578                               {
    579                               if( pDot )
    580                                  *pDot = 0;
    581 
    582                               strlwr( pszLongName );
    583 
    584                               if( pDot )
    585                                  *pDot = '.';
    586                               }
    587 
    588                            if( pDot && HAS_WINNT_EXT_EXT( pDir->u.File.fEAS )) /* ext part is lower case */
    589                               strlwr( pDot + 1 );
    590                            }
    591 #endif
    592                         //if (!strlen(pszLongName))
    593                         //   strcpy(pszLongName, szShortName);
    594 
    595                         if (( strlen(pszLongName) && !stricmp(pszPart, pszLongName))) //||
    596                         //!stricmp( pszPart, szShortName ))
    597                            {
    598                            if( pszFullName )
    599                               strcat( pszFullName, pszLongName );
    600                            fFound = TRUE;
    601                            }
    602 
    603                         if (fFound)
    604                            {
    605                            //ulCluster = (ULONG)pDir->wClusterHigh * 0x10000L + pDir->wCluster;
    606                            ulCluster = ulRet;
    607                            if (strlen(pszPath))
    608                               {
    609                               if (usFileAttr & FILE_DIRECTORY)
    610                                  {
    611                                  if (pszFullName)
    612                                     strcat(pszFullName, "\\");
    613                                  usMode = MODE_START;
    614                                  break;
    615                                  }
    616                               ulCluster = pVolInfo->ulFatEof;
    617                               }
    618                            else
    619                               {
    620                               if (pDirEntry)
    621                                  memcpy(pDirEntry, &Dir, sizeof (DIRENTRY1));
    622                               }
    623                            usMode = MODE_RETURN;
    624                            break;
    625                            }
    626                         }
    627                      }
    628                   else if (pDir->bEntryType == ENTRY_TYPE_STREAM_EXT)
    629                      {
    630                      usNumSecondary--;
    631                      ulRet = pDir->u.Stream.ulFirstClus;
    632                      if (pDirEntryStream)
    633                         memcpy(pDirEntryStream, pDir, sizeof(DIRENTRY1));
    634                      }
    635                   else if (pDir->bEntryType == ENTRY_TYPE_FILE)
    636                      {
    637                      usNumSecondary = pDir->u.File.bSecondaryCount;
    638                      usFileAttr = pDir->u.File.usFileAttr;
    639                      memcpy(&Dir, pDir, sizeof (DIRENTRY1));
    640                      memset(pszLongName, 0, FAT32MAXPATHCOMP);
    641                      }
    642                   }
    643                pDir++;
    644                usDirEntries++;
    645                }
    646             if (usMode != MODE_SCAN)
    647                break;
    648             }
    649          if (usMode != MODE_SCAN)
    650             break;
    651          ulCluster = GetNextCluster(pVolInfo, pSHInfo, ulCluster);
    652          if (!ulCluster)
    653             ulCluster = pVolInfo->ulFatEof;
    654          }
    655       }
    656 #ifndef USE_STATIC_BUFS
    657    free(pDirStart);
    658    free(pszLongName);
    659 #endif
    660    if (f32Parms.fMessageActive & LOG_FUNCS)
    661       {
    662       if (ulCluster != pVolInfo->ulFatEof)
    663          Message("FindPathCluster for %s found cluster %ld", pszPath, ulCluster);
    664       else
    665          Message("FindPathCluster for %s returned EOF", pszPath);
    666       }
    667    return ulCluster;
    668 }
    669 
    670 #endif
    671177
    672178/******************************************************************
     
    677183                      PSZ pszFullName)
    678184{
    679 ULONG rc;
    680 
    681 #ifdef USE_STATIC_BUFS
    682    if (!GetBuf3Access(pVolInfo, "FindPathCluster"))
     185PSZ  pszLongName;
     186PSZ  pszPart;
     187PSZ  p;
     188BOOL fFound;
     189USHORT usMode;
     190PROCINFO ProcInfo;
     191USHORT usDirEntries = 0;
     192USHORT usMaxDirEntries = (USHORT)(pVolInfo->ulBlockSize / sizeof(DIRENTRY));
     193
     194#ifdef EXFAT
     195   if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
     196#endif
    683197      {
     198      // FAT12/FAT16/FAT32 case
     199      BYTE szShortName[13];
     200      PDIRENTRY pDir;
     201      PDIRENTRY pDirStart;
     202      PDIRENTRY pDirEnd;
     203      BYTE   bCheck;
     204      ULONG  ulSector;
     205      USHORT usSectorsRead;
     206      USHORT usSectorsPerBlock;
     207
     208      if (f32Parms.fMessageActive & LOG_FUNCS)
     209         Message("FindPathCluster for %s, dircluster %lu", pszPath, ulCluster);
     210
     211      if (ulCluster == 1)
     212         {
     213         // root directory starting sector
     214         ulSector = pVolInfo->BootSect.bpb.ReservedSectors +
     215            pVolInfo->BootSect.bpb.SectorsPerFat * pVolInfo->BootSect.bpb.NumberOfFATs;
     216         usSectorsPerBlock = (USHORT)pVolInfo->SectorsPerCluster /
     217            (USHORT)(pVolInfo->ulClusterSize / pVolInfo->ulBlockSize);
     218         usSectorsRead = 0;
     219         }
     220
     221      if (pDirEntry)
     222         {
     223         memset(pDirEntry, 0, sizeof (DIRENTRY));
     224         pDirEntry->bAttr = FILE_DIRECTORY;
     225         }
     226      if (pszFullName)
     227         {
     228         memset(pszFullName, 0, FAT32MAXPATH);
     229         if (ulCluster == pVolInfo->BootSect.bpb.RootDirStrtClus)
     230            {
     231            pszFullName[0] = (BYTE)(pVolInfo->bDrive + 'A');
     232            pszFullName[1] = ':';
     233            pszFullName[2] = '\\';
     234            }
     235         }
     236
     237      if (strlen(pszPath) >= 2)
     238         {
     239         if (pszPath[1] == ':')
     240            pszPath += 2;
     241         }
     242
     243      pDirStart = malloc((size_t)pVolInfo->ulBlockSize);
     244      if (!pDirStart)
     245         {
     246         Message("FAT32: Not enough memory for cluster in FindPathCluster");
     247         return pVolInfo->ulFatEof;
     248         }
     249      pszLongName = malloc((size_t)FAT32MAXPATHCOMP * 2);
     250      if (!pszLongName)
     251         {
     252         Message("FAT32: Not enough memory for buffers in FindPathCluster");
     253         free(pDirStart);
     254         return pVolInfo->ulFatEof;
     255         }
     256      memset(pszLongName, 0, FAT32MAXPATHCOMP * 2);
     257      pszPart = pszLongName + FAT32MAXPATHCOMP;
     258
     259      usMode = MODE_SCAN;
     260      GetProcInfo(&ProcInfo, sizeof ProcInfo);
     261      /*
     262         Allow EA files to be found!
     263      */
     264      if (ProcInfo.usPdb && f32Parms.fEAS && IsEASFile(pszPath))
     265         ProcInfo.usPdb = 0;
     266
     267      while (usMode != MODE_RETURN && ulCluster != pVolInfo->ulFatEof)
     268         {
     269         usMode = MODE_SCAN;
     270
     271         if (*pszPath == '\\')
     272            pszPath++;
     273
     274         if (!strlen(pszPath))
     275            break;
     276
     277         p = strchr(pszPath, '\\');
     278         if (!p)
     279            p = pszPath + strlen(pszPath);
     280
     281         memset(pszPart, 0, FAT32MAXPATHCOMP);
     282         if (p - pszPath > FAT32MAXPATHCOMP - 1)
     283            {
     284            free(pDirStart);
     285            free(pszLongName);
     286            return pVolInfo->ulFatEof;
     287            }
     288
     289         memcpy(pszPart, pszPath, p - pszPath);
     290         pszPath = p;
     291
     292         memset(pszLongName, 0, FAT32MAXPATHCOMP);
     293
     294         fFound = FALSE;
     295         while (usMode == MODE_SCAN && ulCluster != pVolInfo->ulFatEof)
     296            {
     297            ULONG ulBlock;
     298            for (ulBlock = 0; ulBlock < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize; ulBlock++)
     299               {
     300               if (ulCluster == 1)
     301                  // reading root directory on FAT12/FAT16
     302                  ReadSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirStart, 0);
     303               else
     304                  ReadBlock(pVolInfo, ulCluster, ulBlock, pDirStart, 0); ////
     305               pDir    = pDirStart;
     306               pDirEnd = (PDIRENTRY)((PBYTE)pDirStart + pVolInfo->ulBlockSize);
     307
     308#ifdef CALL_YIELD
     309               Yield();
    684310#endif
     311
     312               usDirEntries = 0;
     313               //while (usMode == MODE_SCAN && pDir < pDirEnd)
     314               while (usMode == MODE_SCAN && usDirEntries < usMaxDirEntries)
     315                  {
     316                  if (pDir->bAttr == FILE_LONGNAME)
     317                     {
     318                     fGetLongName(pDir, pszLongName, FAT32MAXPATHCOMP, &bCheck);
     319                     }
     320                  else if ((pDir->bAttr & 0x0F) != FILE_VOLID)
     321                     {
     322                     MakeName(pDir, szShortName, sizeof szShortName);
     323                     FSH_UPPERCASE(szShortName, sizeof szShortName, szShortName);
     324                     if (strlen(pszLongName) && bCheck != GetVFATCheckSum(pDir))
     325                        memset(pszLongName, 0, FAT32MAXPATHCOMP);
     326
     327                      /* support for the FAT32 variation of WinNT family */
     328                      if( !*pszLongName && HAS_WINNT_EXT( pDir->fEAS ))
     329                      {
     330                          PBYTE pDot;
     331
     332                          MakeName( pDir, pszLongName, sizeof( pszLongName ));
     333                          pDot = strchr( pszLongName, '.' );
     334
     335                          if( HAS_WINNT_EXT_NAME( pDir->fEAS )) /* name part is lower case */
     336                          {
     337                              if( pDot )
     338                                  *pDot = 0;
     339
     340                              strlwr( pszLongName );
     341
     342                              if( pDot )
     343                                  *pDot = '.';
     344                          }
     345
     346                          if( pDot && HAS_WINNT_EXT_EXT( pDir->fEAS )) /* ext part is lower case */
     347                              strlwr( pDot + 1 );
     348                      }
     349
     350                     if (!strlen(pszLongName))
     351                        strcpy(pszLongName, szShortName);
     352
     353                     if (( strlen(pszLongName) && !stricmp(pszPart, pszLongName)) ||
     354                         !stricmp( pszPart, szShortName ))
     355                        {
     356                          if( pszFullName )
     357                              strcat( pszFullName, pszLongName );
     358                          fFound = TRUE;
     359                        }
     360
     361                     if (fFound)
     362                        {
     363                        ulCluster = (ULONG)pDir->wClusterHigh * 0x10000L + pDir->wCluster;
     364                        ulCluster &= pVolInfo->ulFatEof;
     365                        if (strlen(pszPath))
     366                           {
     367                           if (pDir->bAttr & FILE_DIRECTORY)
     368                              {
     369                              if (pszFullName)
     370                                 strcat(pszFullName, "\\");
     371                              usMode = MODE_START;
     372                              break;
     373                              }
     374                           ulCluster = pVolInfo->ulFatEof;
     375                           }
     376                        else
     377                           {
     378                           if (pDirEntry)
     379                              memcpy(pDirEntry, pDir, sizeof (DIRENTRY));
     380                           }
     381                        usMode = MODE_RETURN;
     382                        break;
     383                        }
     384                     memset(pszLongName, 0, FAT32MAXPATHCOMP);
     385                     }
     386                  pDir++;
     387                  usDirEntries++;
     388                  if (ulCluster == 1 && usDirEntries > pVolInfo->BootSect.bpb.RootDirEntries)
     389                     break;
     390                  }
     391               if (usMode != MODE_SCAN)
     392                  break;
     393               }
     394            if (usMode != MODE_SCAN)
     395               break;
     396            if (ulCluster == 1)
     397               {
     398               // reading the root directory in case of FAT12/FAT16
     399               ulSector += pVolInfo->SectorsPerCluster;
     400               usSectorsRead += pVolInfo->SectorsPerCluster;
     401               if (usSectorsRead * pVolInfo->BootSect.bpb.BytesPerSector >=
     402                   pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY))
     403                  // root directory ended
     404                  ulCluster = 0;
     405               }
     406            else
     407               {
     408               ulCluster = GetNextCluster(pVolInfo, NULL, ulCluster);
     409               }
     410            if (!ulCluster)
     411               ulCluster = pVolInfo->ulFatEof;
     412            }
     413         }
     414      free(pDirStart);
     415      free(pszLongName);
     416      if (f32Parms.fMessageActive & LOG_FUNCS)
     417         {
     418         if (ulCluster != pVolInfo->ulFatEof)
     419            Message("FindPathCluster for %s found cluster %ld", pszPath, ulCluster);
     420         else
     421            Message("FindPathCluster for %s returned EOF", pszPath);
     422         }
     423      return ulCluster;
     424      }
    685425#ifdef EXFAT
    686       if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
     426   else
     427      {
     428      // exFAT case
     429      DIRENTRY1  Dir;
     430      PDIRENTRY1 pDir;
     431      PDIRENTRY1 pDirEntry1 = (PDIRENTRY1)pDirEntry;
     432      PDIRENTRY1 pDirStart;
     433      PDIRENTRY1 pDirEnd;
     434      ULONG  ulRet;
     435      USHORT usNumSecondary;
     436      USHORT usFileAttr;
     437
     438      if (f32Parms.fMessageActive & LOG_FUNCS)
     439         Message("FindPathCluster for %s, dircluster %lu", pszPath, ulCluster);
     440
     441      if (pDirEntry1)
     442         {
     443         memset(pDirEntry1, 0, sizeof (DIRENTRY1));
     444         pDirEntry1->u.File.usFileAttr = FILE_DIRECTORY;
     445         }
     446      if (pszFullName)
     447         {
     448         memset(pszFullName, 0, FAT32MAXPATH);
     449         if (ulCluster == pVolInfo->BootSect.bpb.RootDirStrtClus)
     450            {
     451            pszFullName[0] = (BYTE)(pVolInfo->bDrive + 'A');
     452            pszFullName[1] = ':';
     453            pszFullName[2] = '\\';
     454            }
     455         }
     456
     457      if (pDirEntryStream)
     458         memset(pDirEntryStream, 0, sizeof(DIRENTRY1));
     459
     460      if (strlen(pszPath) >= 2)
     461         {
     462         if (pszPath[1] == ':')
     463            pszPath += 2;
     464         }
     465
     466      pDirStart = malloc((size_t)pVolInfo->ulBlockSize);
     467      if (!pDirStart)
     468         {
     469         Message("FAT32: Not enough memory for cluster in FindPathCluster");
     470         return pVolInfo->ulFatEof;
     471         }
     472      pszLongName = malloc((size_t)FAT32MAXPATHCOMP * 2);
     473      if (!pszLongName)
     474         {
     475         Message("FAT32: Not enough memory for buffers in FindPathCluster");
     476         free(pDirStart);
     477         return pVolInfo->ulFatEof;
     478         }
     479      memset(pszLongName, 0, FAT32MAXPATHCOMP * 2);
     480      pszPart = pszLongName + FAT32MAXPATHCOMP;
     481
     482      usMode = MODE_SCAN;
     483      GetProcInfo(&ProcInfo, sizeof ProcInfo);
     484      /*
     485         Allow EA files to be found!
     486      */
     487      if (ProcInfo.usPdb && f32Parms.fEAS && IsEASFile(pszPath))
     488         ProcInfo.usPdb = 0;
     489
     490      while (usMode != MODE_RETURN && ulCluster != pVolInfo->ulFatEof)
     491         {
     492         usMode = MODE_SCAN;
     493
     494         if (*pszPath == '\\')
     495            pszPath++;
     496
     497         if (!strlen(pszPath))
     498            break;
     499
     500         p = strchr(pszPath, '\\');
     501         if (!p)
     502            p = pszPath + strlen(pszPath);
     503
     504         memset(pszPart, 0, FAT32MAXPATHCOMP);
     505         if (p - pszPath > FAT32MAXPATHCOMP - 1)
     506            {
     507            free(pDirStart);
     508            free(pszLongName);
     509            return pVolInfo->ulFatEof;
     510            }
     511
     512         memcpy(pszPart, pszPath, p - pszPath);
     513         pszPath = p;
     514
     515         memset(pszLongName, 0, FAT32MAXPATHCOMP);
     516
     517         fFound = FALSE;
     518         while (usMode == MODE_SCAN && ulCluster != pVolInfo->ulFatEof)
     519            {
     520            ULONG ulBlock;
     521            for (ulBlock = 0; ulBlock < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize; ulBlock++)
     522               {
     523               ReadBlock(pVolInfo, ulCluster, ulBlock, pDirStart, 0);
     524               pDir    = pDirStart;
     525               pDirEnd = (PDIRENTRY1)((PBYTE)pDirStart + pVolInfo->ulBlockSize);
     526
     527#ifdef CALL_YIELD
     528               Yield();
    687529#endif
    688          rc = FindPathCluster0(pVolInfo, ulCluster, pszPath, pDirEntry, pszFullName);
    689 #ifdef EXFAT
    690       else
    691          rc = FindPathCluster1(pVolInfo, ulCluster, pszPath, pSHInfo,
    692             (PDIRENTRY1)pDirEntry, (PDIRENTRY1)pDirEntryStream, pszFullName);
     530
     531               usDirEntries = 0;
     532               //while (usMode == MODE_SCAN && pDir < pDirEnd)
     533               while (usMode == MODE_SCAN && usDirEntries < usMaxDirEntries)
     534                  {
     535                  if (pDir->bEntryType == ENTRY_TYPE_EOD)
     536                     {
     537                     ulCluster = pVolInfo->ulFatEof;
     538                     usMode = MODE_RETURN;
     539                     break;
     540                     }
     541                  else if (pDir->bEntryType & ENTRY_TYPE_IN_USE_STATUS)
     542                     {
     543                     if (pDir->bEntryType == ENTRY_TYPE_FILE_NAME)
     544                        {
     545                        usNumSecondary--;
     546                        fGetLongName1(pDir, pszLongName, FAT32MAXPATHCOMP);
     547
     548                        if (!usNumSecondary)
     549                           {
     550                           //MakeName(pDir, szShortName, sizeof szShortName);
     551                           //FSH_UPPERCASE(szShortName, sizeof szShortName, szShortName);
     552                           //if (strlen(pszLongName) && bCheck != GetVFATCheckSum(pDir))
     553                           //   memset(pszLongName, 0, FAT32MAXPATHCOMP);
     554#if 0
     555                           /* support for the FAT32 variation of WinNT family */
     556                           if( !*pszLongName && HAS_WINNT_EXT( pDir->u.File.fEAS ))
     557                              {
     558                              PBYTE pDot;
     559
     560                              MakeName( pDir, pszLongName, sizeof( pszLongName ));
     561                              pDot = strchr( pszLongName, '.' );
     562
     563                              if( HAS_WINNT_EXT_NAME( pDir->u.File.fEAS )) /* name part is lower case */
     564                                 {
     565                                 if( pDot )
     566                                    *pDot = 0;
     567
     568                                 strlwr( pszLongName );
     569
     570                                 if( pDot )
     571                                    *pDot = '.';
     572                                 }
     573
     574                              if( pDot && HAS_WINNT_EXT_EXT( pDir->u.File.fEAS )) /* ext part is lower case */
     575                                 strlwr( pDot + 1 );
     576                              }
    693577#endif
    694 
    695 #ifdef USE_STATIC_BUFS
    696       ReleaseBuf3(pVolInfo);
     578                           //if (!strlen(pszLongName))
     579                           //   strcpy(pszLongName, szShortName);
     580
     581                           if (( strlen(pszLongName) && !stricmp(pszPart, pszLongName))) //||
     582                           //!stricmp( pszPart, szShortName ))
     583                              {
     584                              if( pszFullName )
     585                                 strcat( pszFullName, pszLongName );
     586                              fFound = TRUE;
     587                              }
     588
     589                           if (fFound)
     590                              {
     591                              //ulCluster = (ULONG)pDir->wClusterHigh * 0x10000L + pDir->wCluster;
     592                              ulCluster = ulRet;
     593                              if (strlen(pszPath))
     594                                 {
     595                                 if (usFileAttr & FILE_DIRECTORY)
     596                                    {
     597                                    if (pszFullName)
     598                                       strcat(pszFullName, "\\");
     599                                    usMode = MODE_START;
     600                                    break;
     601                                    }
     602                                 ulCluster = pVolInfo->ulFatEof;
     603                                 }
     604                              else
     605                                 {
     606                                 if (pDirEntry1)
     607                                    memcpy(pDirEntry1, &Dir, sizeof (DIRENTRY1));
     608                                 }
     609                              usMode = MODE_RETURN;
     610                              break;
     611                              }
     612                           }
     613                        }
     614                     else if (pDir->bEntryType == ENTRY_TYPE_STREAM_EXT)
     615                        {
     616                        usNumSecondary--;
     617                        ulRet = pDir->u.Stream.ulFirstClus;
     618                        if (pDirEntryStream)
     619                           memcpy(pDirEntryStream, pDir, sizeof(DIRENTRY1));
     620                        }
     621                     else if (pDir->bEntryType == ENTRY_TYPE_FILE)
     622                        {
     623                        usNumSecondary = pDir->u.File.bSecondaryCount;
     624                        usFileAttr = pDir->u.File.usFileAttr;
     625                        memcpy(&Dir, pDir, sizeof (DIRENTRY1));
     626                        memset(pszLongName, 0, FAT32MAXPATHCOMP);
     627                        }
     628                     }
     629                  pDir++;
     630                  usDirEntries++;
     631                  }
     632               if (usMode != MODE_SCAN)
     633                  break;
     634               }
     635            if (usMode != MODE_SCAN)
     636               break;
     637            ulCluster = GetNextCluster(pVolInfo, pSHInfo, ulCluster);
     638            if (!ulCluster)
     639               ulCluster = pVolInfo->ulFatEof;
     640            }
     641         }
     642      free(pDirStart);
     643      free(pszLongName);
     644      if (f32Parms.fMessageActive & LOG_FUNCS)
     645         {
     646         if (ulCluster != pVolInfo->ulFatEof)
     647            Message("FindPathCluster for %s found cluster %ld", pszPath, ulCluster);
     648         else
     649            Message("FindPathCluster for %s returned EOF", pszPath);
     650         }
     651      return ulCluster;
    697652      }
    698653#endif
    699 
    700    return rc;
    701654}
    702655
    703 USHORT TranslateName2(PVOLINFO pVolInfo, ULONG ulDirCluster, PSZ pszPath, PSZ pszTarget, USHORT usTranslate)
     656
     657USHORT TranslateName(PVOLINFO pVolInfo, ULONG ulDirCluster, PSZ pszPath, PSZ pszTarget, USHORT usTranslate)
    704658{
    705659BYTE szShortName[13];
    706 #ifdef USE_STATIC_BUFS
    707 static BYTE szLongName[FAT32MAXPATHCOMP * 4];
    708 PSZ  pszLongName = szLongName;
    709 #else
    710660PSZ  pszLongName;
    711 #endif
    712661PSZ  pszUpperName;
    713662PSZ  pszUpperPart;
     
    716665/* PSZ  pTar = pszTarget; */
    717666PDIRENTRY pDir;
    718 #ifdef USE_STATIC_BUFS
    719 PDIRENTRY pDirStart = (PDIRENTRY)pbDirBuf2;
    720 #else
    721667PDIRENTRY pDirStart;
    722 #endif
    723668PDIRENTRY pDirEnd;
    724669BOOL fFound;
     
    745690      }
    746691
    747 #ifndef USE_STATIC_BUFS
    748692   pDirStart = malloc((size_t)pVolInfo->ulBlockSize);
    749693   if (!pDirStart)
     
    759703      return ERROR_NOT_ENOUGH_MEMORY;
    760704      }
    761 #endif
    762705   memset(pszLongName, 0, FAT32MAXPATHCOMP * 4);
    763706
     
    806749      if (p - pszPath > FAT32MAXPATHCOMP - 1)
    807750         {
    808 #ifndef USE_STATIC_BUFS
    809751         free(pDirStart);
    810752         free(pszLongName);
    811 #endif
    812753         return ERROR_BUFFER_OVERFLOW;
    813754         }
     
    947888      }
    948889
    949 #ifndef USE_STATIC_BUFS
    950890   free(pDirStart);
    951891   free(pszLongName);
    952 #endif
    953892   if (ulCluster == pVolInfo->ulFatEof)
    954893      strcat(pszTarget, pszPath);
     
    956895}
    957896
    958 
    959 USHORT TranslateName(PVOLINFO pVolInfo, ULONG ulDirCluster, PSZ pszPath, PSZ pszTarget, USHORT usTranslate)
     897USHORT GetChkSum16(const char *data, int bytes)
    960898{
    961 USHORT rc;
    962 
    963 #ifdef USE_STATIC_BUFS
    964    if (!GetBuf2Access(pVolInfo, "TranslateName"))
     899   USHORT chksum = 0;
     900   int i;
     901
     902   for (i = 0; i < bytes; i++)
    965903      {
    966 #endif
    967       rc = TranslateName2(pVolInfo, ulDirCluster, pszPath, pszTarget, usTranslate);
    968 #ifdef USE_STATIC_BUFS
    969       ReleaseBuf2(pVolInfo);
     904      if (i == 2)
     905         // skip checksum field
     906         i++;
     907      else
     908         chksum = (chksum << 15) | (chksum >> 1) + data[i];
    970909      }
    971 #endif
    972 
    973    return rc;
     910
     911   return chksum;
    974912}
    975913
    976 USHORT ModifyDirectory0(PVOLINFO pVolInfo, ULONG ulDirCluster,
     914ULONG GetChkSum32(const char *data, int bytes)
     915{
     916   ULONG chksum = 0;
     917   int i;
     918
     919   for (i = 0; i < bytes; i++)
     920      chksum = (chksum << 31) | (chksum >> 1) + data[i];
     921
     922   return chksum;
     923}
     924
     925USHORT NameHash(USHORT *pszFilename, int NameLen)
     926{
     927   USHORT hash = 0;
     928   UCHAR  *data = (UCHAR *)pszFilename;
     929   int i;
     930
     931   for (i = 0; i < NameLen * 2; i++)
     932      hash = (hash << 15) | (hash >> 1) + data[i];
     933
     934   return hash;
     935}
     936
     937
     938USHORT ModifyDirectory(PVOLINFO pVolInfo, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo,
    977939                       USHORT usMode, PDIRENTRY pOld, PDIRENTRY pNew,
     940                       PDIRENTRY1 pStreamOld, PDIRENTRY1 pStreamNew,
    978941                       PSZ pszLongName, USHORT usIOMode)
    979942{
    980 #ifdef USE_STATIC_BUFS
    981 DIRENTRY _huge *pDirectory = (PDIRENTRY)pbDirBuf1;
    982 #else
    983 PDIRENTRY pDirectory;
    984 #endif
    985 PDIRENTRY pDir2;
    986 PDIRENTRY pWork, pWork2;
    987 PDIRENTRY pMax;
    988943USHORT    usEntriesNeeded;
    989944USHORT    usFreeEntries;
    990 DIRENTRY  DirNew;
    991945ULONG     ulCluster;
    992946ULONG     ulPrevCluster;
    993947ULONG     ulPrevBlock;
    994948ULONG     ulNextCluster = pVolInfo->ulFatEof;
    995 PDIRENTRY pLNStart;
    996 USHORT    rc;
    997949USHORT    usClusterCount;
    998950BOOL      fNewCluster;
     
    1004956ULONG     ulPrevBytesToRead = 0;
    1005957ULONG     ulBytesRemained;
    1006 
    1007    if (f32Parms.fMessageActive & LOG_FUNCS)
    1008       Message("ModifyDirectory DirCluster %ld, Mode = %d",
    1009       ulDirCluster, usMode);
    1010 
    1011    if (usMode == MODIFY_DIR_RENAME ||
    1012        usMode == MODIFY_DIR_INSERT)
     958USHORT    rc;
     959
     960#ifdef EXFAT
     961   if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
     962#endif
    1013963      {
    1014       if (!pNew || !pszLongName)
    1015          {
    1016          Message("Modify directory: Invalid parameters 1");
    1017          return ERROR_INVALID_PARAMETER;
    1018          }
    1019 
    1020       memcpy(&DirNew, pNew, sizeof (DIRENTRY));
    1021       if ((pNew->bAttr & 0x0F) != FILE_VOLID)
    1022          {
    1023          rc = MakeShortName(pVolInfo, ulDirCluster, pszLongName, DirNew.bFileName);
    1024          if (rc == LONGNAME_ERROR)
     964      PDIRENTRY pDirectory;
     965      PDIRENTRY pDir2;
     966      PDIRENTRY pWork, pWork2;
     967      PDIRENTRY pMax;
     968      PDIRENTRY pDirNew;
     969      PDIRENTRY pLNStart;
     970
     971      if (f32Parms.fMessageActive & LOG_FUNCS)
     972         Message("ModifyDirectory DirCluster %ld, Mode = %d",
     973            ulDirCluster, usMode);
     974
     975      pDirNew = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     976      if (!pDirNew)
     977         {
     978         return ERROR_NOT_ENOUGH_MEMORY;
     979         }
     980
     981      if (usMode == MODIFY_DIR_RENAME ||
     982          usMode == MODIFY_DIR_INSERT)
     983         {
     984         if (!pNew || !pszLongName)
    1025985            {
    1026             Message("Modify directory: Longname error");
    1027             return ERROR_FILE_EXISTS;
     986            Message("Modify directory: Invalid parameters 1");
     987            free(pDirNew);
     988            return ERROR_INVALID_PARAMETER;
    1028989            }
    1029          memcpy(pNew, &DirNew, sizeof (DIRENTRY));
    1030 
    1031          if (rc == LONGNAME_OFF)
     990
     991         memcpy(pDirNew, pNew, sizeof (DIRENTRY));
     992         if ((pNew->bAttr & 0x0F) != FILE_VOLID)
     993            {
     994            rc = MakeShortName(pVolInfo, ulDirCluster, pszLongName, pDirNew->bFileName);
     995            if (rc == LONGNAME_ERROR)
     996               {
     997               Message("Modify directory: Longname error");
     998               free(pDirNew);
     999               return ERROR_FILE_EXISTS;
     1000               }
     1001            memcpy(pNew, pDirNew, sizeof (DIRENTRY));
     1002
     1003            if (rc == LONGNAME_OFF)
     1004               pszLongName = NULL;
     1005            }
     1006         else
    10321007            pszLongName = NULL;
    1033          }
    1034       else
    1035          pszLongName = NULL;
    1036 
    1037       usEntriesNeeded = 1;
    1038       if (pszLongName)
     1008
     1009         usEntriesNeeded = 1;
     1010         if (pszLongName)
    10391011#if 0
    1040          usEntriesNeeded += strlen(pszLongName) / 13 +
    1041             (strlen(pszLongName) % 13 ? 1 : 0);
     1012            usEntriesNeeded += strlen(pszLongName) / 13 +
     1013               (strlen(pszLongName) % 13 ? 1 : 0);
    10421014#else
    1043          usEntriesNeeded += ( DBCSStrlen( pszLongName ) + 12 ) / 13;
     1015            usEntriesNeeded += ( DBCSStrlen( pszLongName ) + 12 ) / 13;
    10441016#endif
    1045       }
    1046 
    1047    if (usMode == MODIFY_DIR_RENAME ||
    1048        usMode == MODIFY_DIR_DELETE ||
    1049        usMode == MODIFY_DIR_UPDATE)
    1050       {
    1051       if (!pOld)
    1052          {
    1053          Message("Modify directory: Invalid parameter 2 ");
    1054          return ERROR_INVALID_PARAMETER;
    1055          }
    1056       }
    1057 
    1058 #ifndef USE_STATIC_BUFS
    1059    pDirectory = (PDIRENTRY)malloc(2 * (size_t)pVolInfo->ulBlockSize);
    1060    if (!pDirectory)
    1061       {
    1062       Message("Modify directory: Not enough memory");
    1063       return ERROR_NOT_ENOUGH_MEMORY;
    1064       }
     1017         }
     1018
     1019      if (usMode == MODIFY_DIR_RENAME ||
     1020          usMode == MODIFY_DIR_DELETE ||
     1021          usMode == MODIFY_DIR_UPDATE)
     1022         {
     1023         if (!pOld)
     1024            {
     1025            Message("Modify directory: Invalid parameter 2 ");
     1026            free(pDirNew);
     1027            return ERROR_INVALID_PARAMETER;
     1028            }
     1029         }
     1030
     1031      pDirectory = (PDIRENTRY)malloc(2 * (size_t)pVolInfo->ulBlockSize);
     1032      if (!pDirectory)
     1033         {
     1034         Message("Modify directory: Not enough memory");
     1035         free(pDirNew);
     1036         return ERROR_NOT_ENOUGH_MEMORY;
     1037         }
     1038      memset(pDirectory, 0, (size_t)pVolInfo->ulBlockSize);
     1039      pDir2 = (PDIRENTRY)((PBYTE)pDirectory + pVolInfo->ulBlockSize);
     1040      memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
     1041
     1042      ulCluster = ulDirCluster;
     1043      pLNStart = NULL;
     1044      ulPrevCluster = pVolInfo->ulFatEof;
     1045      ulPrevBlock = 0;
     1046      usClusterCount = 0;
     1047      fNewCluster = FALSE;
     1048
     1049      if (ulCluster == 1)
     1050         {
     1051         // root directory starting sector
     1052         ulSector = pVolInfo->BootSect.bpb.ReservedSectors +
     1053            pVolInfo->BootSect.bpb.SectorsPerFat * pVolInfo->BootSect.bpb.NumberOfFATs;
     1054         usSectorsPerBlock = (USHORT)pVolInfo->SectorsPerCluster /
     1055            (USHORT)(pVolInfo->ulClusterSize / pVolInfo->ulBlockSize);
     1056         usSectorsRead = 0;
     1057         ulBytesRemained = pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY);
     1058         }
     1059
     1060      while (ulCluster != pVolInfo->ulFatEof)
     1061         {
     1062         ULONG ulBlock;
     1063#ifdef CALL_YIELD
     1064         Yield();
    10651065#endif
    1066    memset(pDirectory, 0, (size_t)pVolInfo->ulBlockSize);
    1067    pDir2 = (PDIRENTRY)((PBYTE)pDirectory + pVolInfo->ulBlockSize);
    1068    memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
    1069 
    1070    ulCluster = ulDirCluster;
    1071    pLNStart = NULL;
    1072    ulPrevCluster = pVolInfo->ulFatEof;
    1073    ulPrevBlock = 0;
    1074    usClusterCount = 0;
    1075    fNewCluster = FALSE;
    1076 
    1077    if (ulCluster == 1)
    1078       {
    1079       // root directory starting sector
    1080       ulSector = pVolInfo->BootSect.bpb.ReservedSectors +
    1081          pVolInfo->BootSect.bpb.SectorsPerFat * pVolInfo->BootSect.bpb.NumberOfFATs;
    1082       usSectorsPerBlock = (USHORT)pVolInfo->SectorsPerCluster /
    1083          (USHORT)(pVolInfo->ulClusterSize / pVolInfo->ulBlockSize);
    1084       usSectorsRead = 0;
    1085       ulBytesRemained = pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY);
    1086       }
    1087 
    1088    while (ulCluster != pVolInfo->ulFatEof)
    1089       {
    1090       ULONG ulBlock;
    1091 #ifdef CALL_YIELD
    1092       Yield();
    1093 #endif
    1094       usClusterCount++;
    1095       for (ulBlock = 0;
    1096            ulBlock < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize &&
    1097            ulCluster != pVolInfo->ulFatEof; ulBlock++)
    1098          {
    1099          if (!fNewCluster)
     1066         usClusterCount++;
     1067         for (ulBlock = 0;
     1068              ulBlock < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize &&
     1069              ulCluster != pVolInfo->ulFatEof; ulBlock++)
    11001070            {
    1101             if (ulCluster == 1)
     1071            if (!fNewCluster)
    11021072               {
    1103                // reading root directory on FAT12/FAT16
    1104                rc = ReadSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1105                if (ulBytesRemained >= pVolInfo->ulBlockSize)
     1073               if (ulCluster == 1)
    11061074                  {
    1107                   ulBytesToRead = pVolInfo->ulBlockSize;
    1108                   ulBytesRemained -= pVolInfo->ulBlockSize;
     1075                  // reading root directory on FAT12/FAT16
     1076                  rc = ReadSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1077                  if (ulBytesRemained >= pVolInfo->ulBlockSize)
     1078                     {
     1079                     ulBytesToRead = pVolInfo->ulBlockSize;
     1080                     ulBytesRemained -= pVolInfo->ulBlockSize;
     1081                     }
     1082                  else
     1083                     {
     1084                     ulBytesToRead = ulBytesRemained;
     1085                     ulBytesRemained = 0;
     1086                     }
    11091087                  }
    11101088               else
    11111089                  {
    1112                   ulBytesToRead = ulBytesRemained;
    1113                   ulBytesRemained = 0;
     1090                  rc = ReadBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1091                  ulBytesToRead = pVolInfo->ulBlockSize;
     1092                  }
     1093               if (rc)
     1094                  {
     1095                  free(pDirNew);
     1096                  free(pDirectory);
     1097                  return rc;
    11141098                  }
    11151099               }
    11161100            else
    11171101               {
    1118                rc = ReadBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1119                ulBytesToRead = pVolInfo->ulBlockSize;
     1102               memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
     1103               fNewCluster = FALSE;
    11201104               }
    1121             if (rc)
     1105
     1106            pMax = (PDIRENTRY)((PBYTE)pDirectory + pVolInfo->ulBlockSize + ulBytesToRead);
     1107
     1108            switch (usMode)
    11221109               {
    1123 #ifndef USE_STATIC_BUFS
    1124                free(pDirectory);
    1125 #endif
    1126                return rc;
    1127                }
    1128             }
    1129          else
    1130             {
    1131             memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
    1132             fNewCluster = FALSE;
    1133             }
    1134 
    1135          pMax = (PDIRENTRY)((PBYTE)pDirectory + pVolInfo->ulBlockSize + ulBytesToRead);
    1136 
    1137          switch (usMode)
    1138             {
    1139             case MODIFY_DIR_RENAME :
    1140             case MODIFY_DIR_UPDATE :
    1141             case MODIFY_DIR_DELETE :
    1142 
    1143                /*
    1144                   Find old entry
    1145                */
    1146 
    1147                pWork = pDir2;
    1148                while (pWork != pMax)
    1149                   {
    1150                   if (pWork->bFileName[0] && pWork->bFileName[0] != DELETED_ENTRY)
    1151                      {
    1152                      if (pWork->bAttr == FILE_LONGNAME)
    1153                         {
    1154                         if (!pLNStart)
    1155                            pLNStart = pWork;
    1156                         }
    1157                      else if ((pWork->bAttr & 0x0F) != FILE_VOLID)
    1158                         {
    1159                         if (!memcmp(pWork->bFileName, pOld->bFileName, 11) &&
    1160                             pWork->wCluster     == pOld->wCluster &&
    1161                             pWork->wClusterHigh == pOld->wClusterHigh)
     1110               case MODIFY_DIR_RENAME :
     1111               case MODIFY_DIR_UPDATE :
     1112               case MODIFY_DIR_DELETE :
     1113
     1114                  /*
     1115                     Find old entry
     1116                  */
     1117
     1118                  pWork = pDir2;
     1119                  while (pWork != pMax)
     1120                     {
     1121                     if (pWork->bFileName[0] && pWork->bFileName[0] != DELETED_ENTRY)
     1122                        {
     1123                        if (pWork->bAttr == FILE_LONGNAME)
    11621124                           {
    11631125                           if (!pLNStart)
    11641126                              pLNStart = pWork;
    1165                            break;
    11661127                           }
    1167                         pLNStart = NULL;
     1128                        else if ((pWork->bAttr & 0x0F) != FILE_VOLID)
     1129                           {
     1130                           if (!memcmp(pWork->bFileName, pOld->bFileName, 11) &&
     1131                               pWork->wCluster     == pOld->wCluster &&
     1132                               pWork->wClusterHigh == pOld->wClusterHigh)
     1133                              {
     1134                              if (!pLNStart)
     1135                                 pLNStart = pWork;
     1136                              break;
     1137                              }
     1138                           pLNStart = NULL;
     1139                           }
     1140                        else
     1141                           pLNStart = NULL;
    11681142                        }
    11691143                     else
    11701144                        pLNStart = NULL;
    1171                      }
    1172                   else
    1173                      pLNStart = NULL;
    1174                   pWork++;
    1175                   }
    1176 
    1177                if (pWork != pMax)
    1178                   {
    1179                   switch (usMode)
    1180                      {
    1181                      case MODIFY_DIR_UPDATE:
    1182                         if (f32Parms.fMessageActive & LOG_FUNCS)
    1183                            Message(" Updating cluster");
    1184                         memcpy(pWork, pNew, sizeof (DIRENTRY));
    1185                         if (ulCluster == 1)
    1186                            // reading root directory on FAT12/FAT16
    1187                            rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1188                         else
    1189                            rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1190                         if (rc)
    1191                            {
    1192 #ifndef USE_STATIC_BUFS
    1193                            free(pDirectory);
    1194 #endif
    1195                            return rc;
    1196                            }
    1197                         ulCluster = pVolInfo->ulFatEof;
    1198                         break;
    1199 
    1200                      case MODIFY_DIR_DELETE:
    1201                      case MODIFY_DIR_RENAME:
    1202                         if (f32Parms.fMessageActive & LOG_FUNCS)
    1203                            Message(" Removing entry from cluster");
    1204                         pWork2 = pLNStart;
    1205                         while (pWork2 < pWork)
    1206                            {
     1145                     pWork++;
     1146                     }
     1147
     1148                  if (pWork != pMax)
     1149                     {
     1150                     switch (usMode)
     1151                        {
     1152                        case MODIFY_DIR_UPDATE:
    12071153                           if (f32Parms.fMessageActive & LOG_FUNCS)
    1208                               Message("Deleting Longname entry.");
    1209                            pWork2->bFileName[0] = DELETED_ENTRY;
    1210                            pWork2++;
    1211                            }
    1212                         pWork->bFileName[0] = DELETED_ENTRY;
    1213 
    1214                         /*
    1215                            Write previous cluster if LN start lies there
    1216                         */
    1217                         if (ulPrevCluster != pVolInfo->ulFatEof &&
    1218                            pLNStart < pDir2)
    1219                            {
    1220                            if (ulPrevCluster == 1)
     1154                              Message(" Updating cluster");
     1155                           memcpy(pWork, pNew, sizeof (DIRENTRY));
     1156                           if (ulCluster == 1)
    12211157                              // reading root directory on FAT12/FAT16
    1222                               rc = WriteSector(pVolInfo, ulPrevSector + ulPrevBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirectory, usIOMode);
     1158                              rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    12231159                           else
    1224                               rc = WriteBlock(pVolInfo, ulPrevCluster, ulPrevBlock, pDirectory, usIOMode);
     1160                              rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    12251161                           if (rc)
    12261162                              {
    1227 #ifndef USE_STATIC_BUFS
     1163                              free(pDirNew);
    12281164                              free(pDirectory);
    1229 #endif
    12301165                              return rc;
    12311166                              }
    1232                            }
    1233 
    1234                         /*
    1235                            Write current cluster
    1236                         */
    1237                         if (ulCluster == 1)
    1238                            // reading root directory on FAT12/FAT16
    1239                            rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1240                         else
    1241                            rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1242                         if (rc)
    1243                            {
    1244 #ifndef USE_STATIC_BUFS
    1245                            free(pDirectory);
    1246 #endif
    1247                            return rc;
    1248                            }
    1249 
    1250                         if (usMode == MODIFY_DIR_DELETE)
    12511167                           ulCluster = pVolInfo->ulFatEof;
    1252                         else
    1253                            {
    1254                            usMode = MODIFY_DIR_INSERT;
    1255                            ulCluster = ulDirCluster;
    1256                            ulBytesRemained = pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY);
    1257                            ulPrevCluster = pVolInfo->ulFatEof;
    1258                            ulPrevSector = 0;
    1259                            ulPrevBlock = 0;
    1260                            usClusterCount = 0;
    1261                            pLNStart = NULL;
    1262                            continue;
    1263                            }
    1264                         break;
    1265                      }
    1266                   }
    1267 
    1268                break;
    1269 
    1270             case MODIFY_DIR_INSERT:
    1271                if (ulPrevCluster != pVolInfo->ulFatEof && GetFreeEntries(pDirectory, ulPrevBytesToRead + ulBytesToRead) >= usEntriesNeeded)
     1168                           break;
     1169
     1170                        case MODIFY_DIR_DELETE:
     1171                        case MODIFY_DIR_RENAME:
     1172                           if (f32Parms.fMessageActive & LOG_FUNCS)
     1173                              Message(" Removing entry from cluster");
     1174                           pWork2 = pLNStart;
     1175                           while (pWork2 < pWork)
     1176                              {
     1177                              if (f32Parms.fMessageActive & LOG_FUNCS)
     1178                                 Message("Deleting Longname entry.");
     1179                              pWork2->bFileName[0] = DELETED_ENTRY;
     1180                              pWork2++;
     1181                              }
     1182                           pWork->bFileName[0] = DELETED_ENTRY;
     1183
     1184                           /*
     1185                              Write previous cluster if LN start lies there
     1186                           */
     1187                           if (ulPrevCluster != pVolInfo->ulFatEof &&
     1188                              pLNStart < pDir2)
     1189                              {
     1190                              if (ulPrevCluster == 1)
     1191                                 // reading root directory on FAT12/FAT16
     1192                                 rc = WriteSector(pVolInfo, ulPrevSector + ulPrevBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirectory, usIOMode);
     1193                              else
     1194                                 rc = WriteBlock(pVolInfo, ulPrevCluster, ulPrevBlock, pDirectory, usIOMode);
     1195                              if (rc)
     1196                                 {
     1197                                 free(pDirNew);
     1198                                 free(pDirectory);
     1199                                 return rc;
     1200                                 }
     1201                              }
     1202
     1203                           /*
     1204                              Write current cluster
     1205                           */
     1206                           if (ulCluster == 1)
     1207                              // reading root directory on FAT12/FAT16
     1208                              rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1209                           else
     1210                              rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1211                           if (rc)
     1212                              {
     1213                              free(pDirNew);
     1214                              free(pDirectory);
     1215                              return rc;
     1216                              }
     1217
     1218                           if (usMode == MODIFY_DIR_DELETE)
     1219                              ulCluster = pVolInfo->ulFatEof;
     1220                           else
     1221                              {
     1222                              usMode = MODIFY_DIR_INSERT;
     1223                              ulCluster = ulDirCluster;
     1224                              ulBytesRemained = pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY);
     1225                              ulPrevCluster = pVolInfo->ulFatEof;
     1226                              ulPrevSector = 0;
     1227                              ulPrevBlock = 0;
     1228                              usClusterCount = 0;
     1229                              pLNStart = NULL;
     1230                              continue;
     1231                              }
     1232                           break;
     1233                        }
     1234                     }
     1235
     1236                  break;
     1237
     1238               case MODIFY_DIR_INSERT:
     1239                  if (ulPrevCluster != pVolInfo->ulFatEof && GetFreeEntries(pDirectory, ulPrevBytesToRead + ulBytesToRead) >= usEntriesNeeded)
     1240                     {
     1241                     BYTE bCheck = GetVFATCheckSum(pDirNew);
     1242
     1243                     if (f32Parms.fMessageActive & LOG_FUNCS)
     1244                        Message(" Inserting entry into 2 clusters");
     1245
     1246                     pWork = CompactDir(pDirectory, ulPrevBytesToRead + ulBytesToRead, usEntriesNeeded);
     1247                     pWork = fSetLongName(pWork, pszLongName, bCheck);
     1248                     memcpy(pWork, pDirNew, sizeof (DIRENTRY));
     1249
     1250                     if (ulPrevCluster == 1)
     1251                        // reading root directory on FAT12/FAT16
     1252                        rc = WriteSector(pVolInfo, ulPrevSector + ulPrevBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirectory, usIOMode);
     1253                     else
     1254                        rc = WriteBlock(pVolInfo, ulPrevCluster, ulPrevBlock, pDirectory, usIOMode);
     1255                     if (rc)
     1256                        {
     1257                        free(pDirNew);
     1258                        free(pDirectory);
     1259                        return rc;
     1260                        }
     1261
     1262                     if (ulCluster == 1)
     1263                        // reading root directory on FAT12/FAT16
     1264                        rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1265                     else
     1266                        rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1267                     if (rc)
     1268                        {
     1269                        free(pDirNew);
     1270                        free(pDirectory);
     1271                        return rc;
     1272                        }
     1273                     ulCluster = pVolInfo->ulFatEof;
     1274                     break;
     1275                     }
     1276
     1277                  usFreeEntries = GetFreeEntries(pDir2, ulBytesToRead);
     1278                  if (usFreeEntries >= usEntriesNeeded)
     1279                     {
     1280                     BYTE bCheck = GetVFATCheckSum(pDirNew);
     1281
     1282                     if (f32Parms.fMessageActive & LOG_FUNCS)
     1283                        Message(" Inserting entry into 1 cluster");
     1284
     1285                     pWork = CompactDir(pDir2, ulBytesToRead, usEntriesNeeded);
     1286                     pWork = fSetLongName(pWork, pszLongName, bCheck);
     1287                     memcpy(pWork, pDirNew, sizeof (DIRENTRY));
     1288                     if (ulCluster == 1)
     1289                        // reading root directory on FAT12/FAT16
     1290                        rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1291                     else
     1292                        rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1293                     if (rc)
     1294                        {
     1295                        free(pDirNew);
     1296                        free(pDirectory);
     1297                        return rc;
     1298                        }
     1299                     ulCluster = pVolInfo->ulFatEof;
     1300                     break;
     1301                     }
     1302                  else if (usFreeEntries > 0)
     1303                     {
     1304                     MarkFreeEntries(pDir2, ulBytesToRead);
     1305                     if (ulCluster == 1)
     1306                        // reading root directory on FAT12/FAT16
     1307                        rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1308                     else
     1309                        rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1310                     if (rc)
     1311                        {
     1312                        free(pDirNew);
     1313                        free(pDirectory);
     1314                        return rc;
     1315                        }
     1316                     }
     1317
     1318                  break;
     1319               }
     1320
     1321            if (ulCluster != pVolInfo->ulFatEof)
     1322               {
     1323               ulPrevBytesToRead = ulBytesToRead;
     1324               ulPrevCluster = ulCluster;
     1325               ulPrevSector = ulSector;
     1326               ulPrevBlock = ulBlock;
     1327               memset(pDirectory, 0, (size_t)pVolInfo->ulClusterSize);
     1328               memmove(pDirectory, pDir2, (size_t)ulBytesToRead);
     1329               if (pLNStart)
     1330                  pLNStart = (PDIRENTRY)((PBYTE)pLNStart - pVolInfo->ulBlockSize);
     1331
     1332               if (ulCluster == 1)
    12721333                  {
    1273                   BYTE bCheck = GetVFATCheckSum(&DirNew);
    1274 
    1275                   if (f32Parms.fMessageActive & LOG_FUNCS)
    1276                      Message(" Inserting entry into 2 clusters");
    1277 
    1278                   pWork = CompactDir(pDirectory, ulPrevBytesToRead + ulBytesToRead, usEntriesNeeded);
    1279                   pWork = fSetLongName(pWork, pszLongName, bCheck);
    1280                   memcpy(pWork, &DirNew, sizeof (DIRENTRY));
    1281 
    1282                   if (ulPrevCluster == 1)
    1283                      // reading root directory on FAT12/FAT16
    1284                      rc = WriteSector(pVolInfo, ulPrevSector + ulPrevBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirectory, usIOMode);
     1334                  // reading the root directory in case of FAT12/FAT16
     1335                  ulSector += pVolInfo->SectorsPerCluster;
     1336                  usSectorsRead += pVolInfo->SectorsPerCluster;
     1337                  if (usSectorsRead * pVolInfo->BootSect.bpb.BytesPerSector >=
     1338                      pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY))
     1339                     // root directory ended
     1340                     ulNextCluster = 0;
    12851341                  else
    1286                      rc = WriteBlock(pVolInfo, ulPrevCluster, ulPrevBlock, pDirectory, usIOMode);
    1287                   if (rc)
    1288                      {
    1289 #ifndef USE_STATIC_BUFS
    1290                      free(pDirectory);
    1291 #endif
    1292                      return rc;
    1293                      }
    1294 
    1295                   if (ulCluster == 1)
    1296                      // reading root directory on FAT12/FAT16
    1297                      rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1298                   else
    1299                      rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1300                   if (rc)
    1301                      {
    1302 #ifndef USE_STATIC_BUFS
    1303                      free(pDirectory);
    1304 #endif
    1305                      return rc;
    1306                      }
    1307                   ulCluster = pVolInfo->ulFatEof;
    1308                   break;
    1309                   }
    1310 
    1311                usFreeEntries = GetFreeEntries(pDir2, ulBytesToRead);
    1312                if (usFreeEntries >= usEntriesNeeded)
    1313                   {
    1314                   BYTE bCheck = GetVFATCheckSum(&DirNew);
    1315 
    1316                   if (f32Parms.fMessageActive & LOG_FUNCS)
    1317                      Message(" Inserting entry into 1 cluster");
    1318 
    1319                   pWork = CompactDir(pDir2, ulBytesToRead, usEntriesNeeded);
    1320                   pWork = fSetLongName(pWork, pszLongName, bCheck);
    1321                   memcpy(pWork, &DirNew, sizeof (DIRENTRY));
    1322                   if (ulCluster == 1)
    1323                      // reading root directory on FAT12/FAT16
    1324                      rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1325                   else
    1326                      rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1327                   if (rc)
    1328                      {
    1329 #ifndef USE_STATIC_BUFS
    1330                      free(pDirectory);
    1331 #endif
    1332                      return rc;
    1333                      }
    1334                   ulCluster = pVolInfo->ulFatEof;
    1335                   break;
    1336                   }
    1337                else if (usFreeEntries > 0)
    1338                   {
    1339                   MarkFreeEntries(pDir2, ulBytesToRead);
    1340                   if (ulCluster == 1)
    1341                      // reading root directory on FAT12/FAT16
    1342                      rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1343                   else
    1344                      rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1345                   if (rc)
    1346                      {
    1347 #ifndef USE_STATIC_BUFS
    1348                      free(pDirectory);
    1349 #endif
    1350                      return rc;
    1351                      }
    1352                   }
    1353 
    1354                break;
    1355             }
    1356 
    1357          if (ulCluster != pVolInfo->ulFatEof)
    1358             {
    1359             ulPrevBytesToRead = ulBytesToRead;
    1360             ulPrevCluster = ulCluster;
    1361             ulPrevSector = ulSector;
    1362             ulPrevBlock = ulBlock;
    1363             memset(pDirectory, 0, (size_t)pVolInfo->ulClusterSize);
    1364             memmove(pDirectory, pDir2, (size_t)ulBytesToRead);
    1365             if (pLNStart)
    1366                pLNStart = (PDIRENTRY)((PBYTE)pLNStart - pVolInfo->ulBlockSize);
    1367 
    1368             if (ulCluster == 1)
    1369                {
    1370                // reading the root directory in case of FAT12/FAT16
    1371                ulSector += pVolInfo->SectorsPerCluster;
    1372                usSectorsRead += pVolInfo->SectorsPerCluster;
    1373                if (usSectorsRead * pVolInfo->BootSect.bpb.BytesPerSector >=
    1374                    pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY))
    1375                   // root directory ended
    1376                   ulNextCluster = 0;
    1377                else
    1378                   ulNextCluster = 1;
    1379                }
    1380             else
    1381                ulNextCluster = GetNextCluster(pVolInfo, NULL, ulCluster);
    1382             if (!ulNextCluster)
    1383                ulNextCluster = pVolInfo->ulFatEof;
    1384             if (ulNextCluster == pVolInfo->ulFatEof)
    1385                {
    1386                if (usMode == MODIFY_DIR_UPDATE ||
    1387                    usMode == MODIFY_DIR_DELETE ||
    1388                    usMode == MODIFY_DIR_RENAME)
    1389                   {
    1390                   if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
    1391                      {
    1392 #ifndef USE_STATIC_BUFS
    1393                      free(pDirectory);
    1394 #endif
    1395                      return ERROR_FILE_NOT_FOUND;
    1396                      }
    1397                   else
    1398                      {
    1399                      if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
    1400                         ulCluster = ulNextCluster;
    1401                      continue;
    1402                      }
     1342                     ulNextCluster = 1;
    14031343                  }
    14041344               else
     1345                  ulNextCluster = GetNextCluster(pVolInfo, NULL, ulCluster);
     1346               if (!ulNextCluster)
     1347                  ulNextCluster = pVolInfo->ulFatEof;
     1348               if (ulNextCluster == pVolInfo->ulFatEof)
    14051349                  {
    1406                   if (ulCluster == 1)
    1407                      {
    1408                      // no expanding for root directory in case of FAT12/FAT16
    1409                      ulNextCluster = pVolInfo->ulFatEof;
     1350                  if (usMode == MODIFY_DIR_UPDATE ||
     1351                      usMode == MODIFY_DIR_DELETE ||
     1352                      usMode == MODIFY_DIR_RENAME)
     1353                     {
     1354                     if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
     1355                        {
     1356                        free(pDirNew);
     1357                        free(pDirectory);
     1358                        return ERROR_FILE_NOT_FOUND;
     1359                        }
     1360                     else
     1361                        {
     1362                        if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
     1363                           ulCluster = ulNextCluster;
     1364                        continue;
     1365                        }
    14101366                     }
    14111367                  else
    1412                      ulNextCluster = SetNextCluster(pVolInfo, ulCluster, FAT_ASSIGN_NEW);
    1413                   if (ulNextCluster == pVolInfo->ulFatEof)
    1414                      {
    1415 #ifndef USE_STATIC_BUFS
    1416                      free(pDirectory);
    1417 #endif
    1418                      Message("Modify Directory: Disk Full!");
    1419                      return ERROR_DISK_FULL;
    1420                      }
    1421                   fNewCluster = TRUE;
     1368                     {
     1369                     if (ulCluster == 1)
     1370                        {
     1371                        // no expanding for root directory in case of FAT12/FAT16
     1372                        ulNextCluster = pVolInfo->ulFatEof;
     1373                        }
     1374                     else
     1375                        ulNextCluster = SetNextCluster(pVolInfo, ulCluster, FAT_ASSIGN_NEW);
     1376                     if (ulNextCluster == pVolInfo->ulFatEof)
     1377                        {
     1378                        free(pDirNew);
     1379                        free(pDirectory);
     1380                        Message("Modify Directory: Disk Full!");
     1381                        return ERROR_DISK_FULL;
     1382                        }
     1383                     fNewCluster = TRUE;
     1384                     }
    14221385                  }
     1386               ulCluster = ulNextCluster;
     1387
     1388               // clear the new cluster
     1389               if (fNewCluster)
     1390                  {
     1391                  ULONG ulBlock2;
     1392                  memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
     1393                  for (ulBlock2 = 0; ulBlock2 < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize; ulBlock2++)
     1394                     {
     1395                     rc = WriteBlock(pVolInfo, ulCluster, ulBlock2, pDir2, usIOMode);
     1396                     if (rc)
     1397                        {
     1398                        free(pDirNew);
     1399                        free(pDirectory);
     1400                        return rc;
     1401                        }
     1402                     }
     1403                  }
     1404               break;
    14231405               }
    1424             ulCluster = ulNextCluster;
    1425 
    1426             // clear the new cluster
    1427             if (fNewCluster)
    1428                {
    1429                ULONG ulBlock2;
    1430                memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
    1431                for (ulBlock2 = 0; ulBlock2 < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize; ulBlock2++)
    1432                   {
    1433                   rc = WriteBlock(pVolInfo, ulCluster, ulBlock2, pDir2, usIOMode);
    1434                   if (rc)
    1435                      {
    1436 #ifndef USE_STATIC_BUFS
    1437                      free(pDirectory);
    1438 #endif
    1439                      return rc;
    1440                      }
    1441                   }
    1442                }
    1443             break;
     1406            if (ulCluster == pVolInfo->ulFatEof)
     1407               break;
     1408            if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
     1409               ulCluster = ulNextCluster;
    14441410            }
    14451411         if (ulCluster == pVolInfo->ulFatEof)
     
    14481414            ulCluster = ulNextCluster;
    14491415         }
    1450       if (ulCluster == pVolInfo->ulFatEof)
    1451          break;
    1452       if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
    1453          ulCluster = ulNextCluster;
     1416
     1417      free(pDirNew);
     1418      free(pDirectory);
     1419      return 0;
    14541420      }
    1455 
    1456 #ifndef USE_STATIC_BUFS
    1457    free(pDirectory);
    1458 #endif
    1459    return 0;
    1460 }
    1461 
    14621421#ifdef EXFAT
    1463 
    1464 USHORT GetChkSum16(const char *data, int bytes)
    1465 {
    1466    USHORT chksum = 0;
    1467    int i;
    1468 
    1469    for (i = 0; i < bytes; i++)
     1422   else
    14701423      {
    1471       if (i == 2)
    1472          // skip checksum field
    1473          i++;
    1474       else
    1475          chksum = (chksum << 15) | (chksum >> 1) + data[i];
    1476       }
    1477 
    1478    return chksum;
    1479 }
    1480 
    1481 ULONG GetChkSum32(const char *data, int bytes)
    1482 {
    1483    ULONG chksum = 0;
    1484    int i;
    1485 
    1486    for (i = 0; i < bytes; i++)
    1487       chksum = (chksum << 31) | (chksum >> 1) + data[i];
    1488 
    1489    return chksum;
    1490 }
    1491 
    1492 USHORT NameHash(USHORT *pszFilename, int NameLen)
    1493 {
    1494    USHORT hash = 0;
    1495    UCHAR  *data = (UCHAR *)pszFilename;
    1496    int i;
    1497 
    1498    for (i = 0; i < NameLen * 2; i++)
    1499       hash = (hash << 15) | (hash >> 1) + data[i];
    1500 
    1501    return hash;
    1502 }
    1503 
    1504 
    1505 USHORT ModifyDirectory1(PVOLINFO pVolInfo, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo,
    1506                        USHORT usMode, PDIRENTRY1 pOld, PDIRENTRY1 pNew,
    1507                        PDIRENTRY1 pStreamOld, PDIRENTRY1 pStreamNew,
    1508                        PSZ pszLongName, USHORT usIOMode)
    1509 {
    1510 #ifdef USE_STATIC_BUFS
    1511 DIRENTRY1 _huge *pDirectory = (PDIRENTRY1)pbDirBuf1;
    1512 #else
    1513 PDIRENTRY1 pDirectory;
    1514 #endif
    1515 PDIRENTRY1 pDir2, pDir1;
    1516 PDIRENTRY1 pWork, pWork2, pWorkStream, pWorkFile;
    1517 PDIRENTRY1 pMax;
    1518 USHORT    usEntriesNeeded;
    1519 USHORT    usFreeEntries;
    1520 DIRENTRY1  DirNew;
    1521 ULONG     ulCluster;
    1522 ULONG     ulPrevCluster;
    1523 ULONG     ulPrevBlock;
    1524 ULONG     ulNextCluster = pVolInfo->ulFatEof;
    1525 PDIRENTRY1 pLNStart;
    1526 USHORT    rc;
    1527 USHORT    usClusterCount;
    1528 BOOL      fNewCluster;
    1529 ULONG     ulSector;
    1530 ULONG     ulPrevSector;
    1531 //USHORT    usSectorsRead;
    1532 //USHORT    usSectorsPerBlock;
    1533 ULONG     ulBytesToRead;
    1534 ULONG     ulPrevBytesToRead = 0;
    1535 ULONG     ulBytesRemained;
    1536 USHORT    usNumSecondary;
    1537 USHORT    usFileName, usIndex;
    1538 USHORT    usNameHash;
    1539 BOOL      fFound;
    1540 
    1541    if (f32Parms.fMessageActive & LOG_FUNCS)
    1542       Message("ModifyDirectory DirCluster %ld, Mode = %d",
    1543       ulDirCluster, usMode);
    1544 
    1545    if (usMode == MODIFY_DIR_RENAME ||
    1546        usMode == MODIFY_DIR_INSERT)
    1547       {
    1548       if (!pNew || !pszLongName)
    1549          {
    1550          return ERROR_INVALID_PARAMETER;
    1551          }
    1552 
    1553       memcpy(&DirNew, pNew, sizeof (DIRENTRY1));
    1554       /* if ((pNew->bAttr & 0x0F) != FILE_VOLID)
    1555          {
    1556          rc = MakeShortName(pVolInfo, ulDirCluster, pszLongName, DirNew.bFileName);
    1557          if (rc == LONGNAME_ERROR)
     1424      // exFAT case
     1425      PDIRENTRY1 pDirectory;
     1426      PDIRENTRY1 pDir2;
     1427      PDIRENTRY1 Dir2, pDir1;
     1428      PDIRENTRY1 pWork, pWork2, pWorkStream, pWorkFile;
     1429      PDIRENTRY1 pMax;
     1430      PDIRENTRY1 pNew1 = (PDIRENTRY1)pNew;
     1431      PDIRENTRY1 pLNStart;
     1432      PDIRENTRY1 pDirNew;
     1433      USHORT    usNumSecondary;
     1434      USHORT    usFileName, usIndex;
     1435      USHORT    usNameHash;
     1436      BOOL      fFound;
     1437
     1438      if (f32Parms.fMessageActive & LOG_FUNCS)
     1439         Message("ModifyDirectory DirCluster %ld, Mode = %d",
     1440            ulDirCluster, usMode);
     1441
     1442      pDirNew = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     1443      if (!pDirNew)
     1444         {
     1445         return ERROR_NOT_ENOUGH_MEMORY;
     1446         }
     1447
     1448      if (usMode == MODIFY_DIR_RENAME ||
     1449          usMode == MODIFY_DIR_INSERT)
     1450         {
     1451         if (!pNew || !pszLongName)
    15581452            {
    1559             Message("Modify directory: Longname error");
    1560             return ERROR_FILE_EXISTS;
     1453            free(pDirNew);
     1454            return ERROR_INVALID_PARAMETER;
    15611455            }
    1562          memcpy(pNew, &DirNew, sizeof (DIRENTRY));
    1563 
    1564          if (rc == LONGNAME_OFF)
    1565             pszLongName = NULL;
    1566          }
    1567       else
    1568          pszLongName = NULL; */
    1569 
    1570       //usEntriesNeeded = 1;
    1571       usEntriesNeeded = 2;
    1572       if (pszLongName)
    1573 #if 0
    1574          usEntriesNeeded += strlen(pszLongName) / 13 +
    1575             (strlen(pszLongName) % 13 ? 1 : 0);
    1576 #else
    1577          //usEntriesNeeded += ( DBCSStrlen( pszLongName ) + 12 ) / 13;
    1578          usEntriesNeeded += ( DBCSStrlen( pszLongName ) + 14 ) / 15;
    1579 #endif
    1580       }
    1581 
    1582    if (usMode == MODIFY_DIR_RENAME ||
    1583        usMode == MODIFY_DIR_DELETE ||
    1584        usMode == MODIFY_DIR_UPDATE)
    1585       {
    1586       if (!pOld)
    1587          {
    1588          return ERROR_INVALID_PARAMETER;
    1589          }
    1590       }
    1591 
    1592 #ifndef USE_STATIC_BUFS
    1593    pDirectory = (PDIRENTRY1)malloc(2 * (size_t)pVolInfo->ulBlockSize);
    1594    if (!pDirectory)
    1595       {
    1596       return ERROR_NOT_ENOUGH_MEMORY;
    1597       }
    1598 #endif
    1599    memset(pDirectory, 0, (size_t)pVolInfo->ulBlockSize);
    1600    pDir2 = (PDIRENTRY1)((PBYTE)pDirectory + pVolInfo->ulBlockSize);
    1601    memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
    1602 
    1603    ulCluster = ulDirCluster;
    1604    pLNStart = NULL;
    1605    ulPrevCluster = pVolInfo->ulFatEof;
    1606    ulPrevBlock = 0;
    1607    usClusterCount = 0;
    1608    fNewCluster = FALSE;
    1609 
    1610    //if (ulCluster == 1)
    1611    //   {
    1612    //   // root directory starting sector
    1613    //   ulSector = pVolInfo->BootSect.bpb.ReservedSectors +
    1614    //      pVolInfo->BootSect.bpb.SectorsPerFat * pVolInfo->BootSect.bpb.NumberOfFATs;
    1615    //   usSectorsPerBlock = pVolInfo->SectorsPerCluster /
    1616    //      (pVolInfo->ulClusterSize / pVolInfo->ulBlockSize);
    1617    //   usSectorsRead = 0;
    1618    //   ulBytesRemained = pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY);
    1619    //   }
    1620 
    1621    while (ulCluster != pVolInfo->ulFatEof)
    1622       {
    1623       ULONG ulBlock;
    1624 #ifdef CALL_YIELD
    1625       Yield();
    1626 #endif
    1627       usClusterCount++;
    1628       for (ulBlock = 0;
    1629            ulBlock < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize &&
    1630            ulCluster != pVolInfo->ulFatEof; ulBlock++)
    1631          {
    1632          if (!fNewCluster)
     1456
     1457         memcpy(pDirNew, pNew, sizeof (DIRENTRY1));
     1458         /* if ((pNew->bAttr & 0x0F) != FILE_VOLID)
    16331459            {
    1634             //if (ulCluster == 1)
    1635             //   {
    1636             //   // reading root directory on FAT12/FAT16
    1637             //   rc = ReadSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1638             //   if (ulBytesRemained >= pVolInfo->ulBlockSize)
    1639             //      {
    1640             //      ulBytesToRead = pVolInfo->ulBlockSize;
    1641             //      ulBytesRemained -= pVolInfo->ulBlockSize;
    1642             //      }
    1643             //   else
    1644             //      {
    1645             //      ulBytesToRead = ulBytesRemained;
    1646             //      ulBytesRemained = 0;
    1647             //      }
    1648             //   }
    1649             //else
    1650             //   {
    1651                rc = ReadBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1652                ulBytesToRead = pVolInfo->ulBlockSize;
    1653             //   }
    1654             if (rc)
     1460            rc = MakeShortName(pVolInfo, ulDirCluster, pszLongName, pDirNew->bFileName);
     1461            if (rc == LONGNAME_ERROR)
    16551462               {
    1656 #ifndef USE_STATIC_BUFS
    1657                free(pDirectory);
    1658 #endif
    1659                return rc;
     1463               Message("Modify directory: Longname error");
     1464               free(pDirNew);
     1465               return ERROR_FILE_EXISTS;
    16601466               }
     1467            memcpy(pNew, pDirNew, sizeof (DIRENTRY));
     1468
     1469            if (rc == LONGNAME_OFF)
     1470               pszLongName = NULL;
    16611471            }
    16621472         else
     1473            pszLongName = NULL; */
     1474
     1475         //usEntriesNeeded = 1;
     1476         usEntriesNeeded = 2;
     1477         if (pszLongName)
     1478#if 0
     1479            usEntriesNeeded += strlen(pszLongName) / 13 +
     1480               (strlen(pszLongName) % 13 ? 1 : 0);
     1481#else
     1482            //usEntriesNeeded += ( DBCSStrlen( pszLongName ) + 12 ) / 13;
     1483            usEntriesNeeded += ( DBCSStrlen( pszLongName ) + 14 ) / 15;
     1484#endif
     1485         }
     1486
     1487      if (usMode == MODIFY_DIR_RENAME ||
     1488          usMode == MODIFY_DIR_DELETE ||
     1489          usMode == MODIFY_DIR_UPDATE)
     1490         {
     1491         if (!pOld)
    16631492            {
    1664             memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
    1665             fNewCluster = FALSE;
     1493            free(pDirNew);
     1494            return ERROR_INVALID_PARAMETER;
    16661495            }
    1667 
    1668          pMax = (PDIRENTRY1)((PBYTE)pDirectory + pVolInfo->ulBlockSize + ulBytesToRead);
    1669 
    1670          switch (usMode)
     1496         }
     1497
     1498      pDirectory = (PDIRENTRY1)malloc(2 * (size_t)pVolInfo->ulBlockSize);
     1499      if (!pDirectory)
     1500         {
     1501         free(pDirNew);
     1502         return ERROR_NOT_ENOUGH_MEMORY;
     1503         }
     1504      memset(pDirectory, 0, (size_t)pVolInfo->ulBlockSize);
     1505      pDir2 = (PDIRENTRY1)((PBYTE)pDirectory + pVolInfo->ulBlockSize);
     1506      memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
     1507
     1508      ulCluster = ulDirCluster;
     1509      pLNStart = NULL;
     1510      ulPrevCluster = pVolInfo->ulFatEof;
     1511      ulPrevBlock = 0;
     1512      usClusterCount = 0;
     1513      fNewCluster = FALSE;
     1514
     1515      //if (ulCluster == 1)
     1516      //   {
     1517      //   // root directory starting sector
     1518      //   ulSector = pVolInfo->BootSect.bpb.ReservedSectors +
     1519      //      pVolInfo->BootSect.bpb.SectorsPerFat * pVolInfo->BootSect.bpb.NumberOfFATs;
     1520      //   usSectorsPerBlock = pVolInfo->SectorsPerCluster /
     1521      //      (pVolInfo->ulClusterSize / pVolInfo->ulBlockSize);
     1522      //   usSectorsRead = 0;
     1523      //   ulBytesRemained = pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY);
     1524      //   }
     1525
     1526      while (ulCluster != pVolInfo->ulFatEof)
     1527         {
     1528         ULONG ulBlock;
     1529#ifdef CALL_YIELD
     1530         Yield();
     1531#endif
     1532         usClusterCount++;
     1533         for (ulBlock = 0;
     1534              ulBlock < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize &&
     1535              ulCluster != pVolInfo->ulFatEof; ulBlock++)
    16711536            {
    1672             case MODIFY_DIR_RENAME :
    1673             case MODIFY_DIR_UPDATE :
    1674             case MODIFY_DIR_DELETE :
    1675 
    1676                /*
    1677                   Find old entry
    1678                */
    1679 
    1680                fFound = FALSE;
    1681                pWork = pDir2;
    1682                pDir1 = NULL;
    1683                while (pWork != pMax)
     1537            if (!fNewCluster)
     1538               {
     1539               //if (ulCluster == 1)
     1540               //   {
     1541               //   // reading root directory on FAT12/FAT16
     1542               //   rc = ReadSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1543               //   if (ulBytesRemained >= pVolInfo->ulBlockSize)
     1544               //      {
     1545               //      ulBytesToRead = pVolInfo->ulBlockSize;
     1546               //      ulBytesRemained -= pVolInfo->ulBlockSize;
     1547               //      }
     1548               //   else
     1549               //      {
     1550               //      ulBytesToRead = ulBytesRemained;
     1551               //      ulBytesRemained = 0;
     1552               //      }
     1553               //   }
     1554               //else
     1555               //   {
     1556                  rc = ReadBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1557                  ulBytesToRead = pVolInfo->ulBlockSize;
     1558               //   }
     1559               if (rc)
    16841560                  {
    1685                   //if (pWork->bFileName[0] && pWork->bFileName[0] != DELETED_ENTRY)
    1686                   if ((pWork->bEntryType != ENTRY_TYPE_EOD) && (pWork->bEntryType & ENTRY_TYPE_IN_USE_STATUS))
    1687                      {
    1688                      //if (pWork->bAttr == FILE_LONGNAME)
    1689                      if (pWork->bEntryType == ENTRY_TYPE_FILE_NAME)
    1690                         {
    1691                         //usNumSecondary--;
    1692                         //fGetLongName1(pDir, szLongName, sizeof szLongName);
    1693                         if (!pLNStart && !usFileName && fFound)
     1561                  free(pDirNew);
     1562                  free(pDirectory);
     1563                  return rc;
     1564                  }
     1565               }
     1566            else
     1567               {
     1568               memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
     1569               fNewCluster = FALSE;
     1570               }
     1571
     1572            pMax = (PDIRENTRY1)((PBYTE)pDirectory + pVolInfo->ulBlockSize + ulBytesToRead);
     1573
     1574            switch (usMode)
     1575               {
     1576               case MODIFY_DIR_RENAME :
     1577               case MODIFY_DIR_UPDATE :
     1578               case MODIFY_DIR_DELETE :
     1579
     1580                  /*
     1581                     Find old entry
     1582                  */
     1583
     1584                  fFound = FALSE;
     1585                  pWork = pDir2;
     1586                  pDir1 = NULL;
     1587                  while (pWork != pMax)
     1588                     {
     1589                     //if (pWork->bFileName[0] && pWork->bFileName[0] != DELETED_ENTRY)
     1590                     if ((pWork->bEntryType != ENTRY_TYPE_EOD) && (pWork->bEntryType & ENTRY_TYPE_IN_USE_STATUS))
     1591                        {
     1592                        //if (pWork->bAttr == FILE_LONGNAME)
     1593                        if (pWork->bEntryType == ENTRY_TYPE_FILE_NAME)
    16941594                           {
    1695                            pLNStart = pWork;
    1696                            break;
     1595                           //usNumSecondary--;
     1596                           //fGetLongName1(pDir, szLongName, sizeof szLongName);
     1597                           if (!pLNStart && !usFileName && fFound)
     1598                              {
     1599                              pLNStart = pWork;
     1600                              break;
     1601                              }
     1602                           usFileName++;
    16971603                           }
    1698                         usFileName++;
    1699                         }
    1700                      else if (pWork->bEntryType == ENTRY_TYPE_FILE)
    1701                         {
    1702                         usFileName = 0;
    1703                         usNumSecondary = pWork->u.File.bSecondaryCount;
    1704                         pWorkFile = pWork;
    1705                         }
    1706                      //else if ((pWork->bAttr & 0x0F) != FILE_VOLID)
    1707                      else if (pWork->bEntryType == ENTRY_TYPE_STREAM_EXT)
    1708                         {
    1709                         //usNumSecondary--;
    1710                         //if (!memcmp(pWork->bFileName, pOld->bFileName, 11) &&
    1711                         //    pWork->wCluster     == pOld->wCluster &&
    1712                         //    pWork->wClusterHigh == pOld->wClusterHigh)
    1713                         pWorkStream = pWork;
    1714                         if (pWork->u.Stream.ulFirstClus == pStreamOld->u.Stream.ulFirstClus)
     1604                        else if (pWork->bEntryType == ENTRY_TYPE_FILE)
    17151605                           {
    1716                            fFound = TRUE;
     1606                           usFileName = 0;
     1607                           usNumSecondary = pWork->u.File.bSecondaryCount;
     1608                           pWorkFile = pWork;
    17171609                           }
    1718                         pLNStart = NULL;
     1610                        //else if ((pWork->bAttr & 0x0F) != FILE_VOLID)
     1611                        else if (pWork->bEntryType == ENTRY_TYPE_STREAM_EXT)
     1612                           {
     1613                           //usNumSecondary--;
     1614                           //if (!memcmp(pWork->bFileName, pOld->bFileName, 11) &&
     1615                           //    pWork->wCluster     == pOld->wCluster &&
     1616                           //    pWork->wClusterHigh == pOld->wClusterHigh)
     1617                           pWorkStream = pWork;
     1618                           if (pWork->u.Stream.ulFirstClus == pStreamOld->u.Stream.ulFirstClus)
     1619                              {
     1620                              fFound = TRUE;
     1621                              }
     1622                           pLNStart = NULL;
     1623                           }
     1624                        else
     1625                           pLNStart = NULL;
    17191626                        }
    17201627                     else
    17211628                        pLNStart = NULL;
     1629                     pWork++;
     1630                     }
     1631
     1632                  if (pWork != pMax)
     1633                     {
     1634                     switch (usMode)
     1635                        {
     1636                        case MODIFY_DIR_UPDATE:
     1637                           if (f32Parms.fMessageActive & LOG_FUNCS)
     1638                              Message(" Updating cluster");
     1639                           memcpy(pWorkFile, pNew, sizeof (DIRENTRY1));
     1640                           if (pStreamNew)
     1641                              {
     1642                              memcpy(pWorkStream, pStreamNew, sizeof (DIRENTRY1));
     1643                              }
     1644                           pWorkFile->u.File.usSetCheckSum = GetChkSum16((char *)pWorkFile,
     1645                              sizeof(DIRENTRY1) * (pWorkFile->u.File.bSecondaryCount + 1));
     1646                           //if (ulCluster == 1)
     1647                           //   // reading root directory on FAT12/FAT16
     1648                           //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1649                           //else
     1650                              rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1651                           if (rc)
     1652                              {
     1653                              free(pDirNew);
     1654                              free(pDirectory);
     1655                              return rc;
     1656                              }
     1657                           ulCluster = pVolInfo->ulFatEof;
     1658                           break;
     1659
     1660                        case MODIFY_DIR_DELETE:
     1661                        case MODIFY_DIR_RENAME:
     1662                           if (f32Parms.fMessageActive & LOG_FUNCS)
     1663                              Message(" Removing entry from cluster");
     1664                           pWork2 = pLNStart;
     1665                           //while (pWork2 < pWork)
     1666                           for (usIndex = 0; usIndex < usNumSecondary - 1; usIndex++)
     1667                              {
     1668                              if (f32Parms.fMessageActive & LOG_FUNCS)
     1669                                 Message("Deleting Longname entry.");
     1670                              //pWork2->bFileName[0] = DELETED_ENTRY;
     1671                              pWork2->bEntryType &= ~ENTRY_TYPE_IN_USE_STATUS;
     1672                              pWork2++;
     1673                              }
     1674                           //pWork->bFileName[0] = DELETED_ENTRY;
     1675                           pWorkFile->bEntryType &= ~ENTRY_TYPE_IN_USE_STATUS;
     1676                           pWorkStream->bEntryType &= ~ENTRY_TYPE_IN_USE_STATUS;
     1677
     1678                           /*
     1679                              Write previous cluster if LN start lies there
     1680                           */
     1681                           //if (ulPrevCluster != pVolInfo->ulFatEof &&
     1682                           //   pLNStart < pDir2)
     1683                           //   {
     1684                           //   if (ulPrevCluster == 1)
     1685                           //      // reading root directory on FAT12/FAT16
     1686                           //      rc = WriteSector(pVolInfo, ulPrevSector + ulPrevBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirectory, usIOMode);
     1687                           //   else
     1688                           //      rc = WriteBlock(pVolInfo, ulPrevCluster, ulPrevBlock, pDirectory, usIOMode);
     1689                           //   if (rc)
     1690                           //      {
     1691                           //      free(pDirNew);
     1692                           //      free(pDirectory);
     1693                           //      return rc;
     1694                           //      }
     1695                           //   }
     1696
     1697                           /*
     1698                              Write current cluster
     1699                           */
     1700                           //if (ulCluster == 1)
     1701                           //   // reading root directory on FAT12/FAT16
     1702                           //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1703                           //else
     1704                              rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1705                           if (rc)
     1706                              {
     1707                              free(pDirNew);
     1708                              free(pDirectory);
     1709                              return rc;
     1710                              }
     1711
     1712                           if (usMode == MODIFY_DIR_DELETE)
     1713                              ulCluster = pVolInfo->ulFatEof;
     1714                           else
     1715                              {
     1716                              usMode = MODIFY_DIR_INSERT;
     1717                              ulCluster = ulDirCluster;
     1718                              ulBytesRemained = pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY);
     1719                              ulPrevCluster = pVolInfo->ulFatEof;
     1720                              ulPrevSector = 0;
     1721                              ulPrevBlock = 0;
     1722                              usClusterCount = 0;
     1723                              pLNStart = NULL;
     1724                              continue;
     1725                              }
     1726                           break;
     1727                        }
     1728                     }
     1729
     1730                  break;
     1731
     1732               case MODIFY_DIR_INSERT:
     1733                  pNew1->bEntryType = ENTRY_TYPE_FILE;
     1734                  pStreamNew->bEntryType = ENTRY_TYPE_STREAM_EXT;
     1735
     1736                  if (ulPrevCluster != pVolInfo->ulFatEof && GetFreeEntries((PDIRENTRY)pDirectory, ulPrevBytesToRead + ulBytesToRead) >= usEntriesNeeded)
     1737                     {
     1738                     PDIRENTRY1 pWork3;
     1739                     //BYTE bCheck = GetVFATCheckSum(pDirNew);
     1740
     1741                     if (f32Parms.fMessageActive & LOG_FUNCS)
     1742                        Message(" Inserting entry into 2 clusters");
     1743
     1744                     pWork = CompactDir1(pDirectory, ulPrevBytesToRead + ulBytesToRead, usEntriesNeeded);
     1745                     //pWork = fSetLongName(pWork, pszLongName, bCheck);
     1746                     //memcpy(pWork, pDirNew, sizeof (DIRENTRY));
     1747                     pWork3 = fSetLongName1(pWork+2, pszLongName, &usNameHash);
     1748                     pNew1->u.File.bSecondaryCount = (BYTE)(pWork3 - pWork - 1);
     1749                     memcpy(pWork++, pNew, sizeof (DIRENTRY1));
     1750                     pStreamNew->u.Stream.usNameHash = usNameHash;
     1751                     pStreamNew->u.Stream.bNameLen = (BYTE)strlen(pszLongName);
     1752                     memcpy(pWork++, pStreamNew, sizeof (DIRENTRY1));
     1753                     (pWork-2)->u.File.usSetCheckSum = GetChkSum16((char *)(pWork-2),
     1754                        sizeof(DIRENTRY1) * ((pWork-2)->u.File.bSecondaryCount + 1));
     1755
     1756                     //if (ulPrevCluster == 1)
     1757                     //   // reading root directory on FAT12/FAT16
     1758                     //   rc = WriteSector(pVolInfo, ulPrevSector + ulPrevBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirectory, usIOMode);
     1759                     //else
     1760                        rc = WriteBlock(pVolInfo, ulPrevCluster, ulPrevBlock, pDirectory, usIOMode);
     1761                     if (rc)
     1762                        {
     1763                        free(pDirNew);
     1764                        free(pDirectory);
     1765                        return rc;
     1766                        }
     1767
     1768                     //if (ulCluster == 1)
     1769                     //   // reading root directory on FAT12/FAT16
     1770                     //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1771                     //else
     1772                        rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1773                     if (rc)
     1774                        {
     1775                        free(pDirNew);
     1776                        free(pDirectory);
     1777                        return rc;
     1778                        }
     1779                     ulCluster = pVolInfo->ulFatEof;
     1780                     break;
     1781                     }
     1782
     1783                  usFreeEntries = GetFreeEntries((PDIRENTRY)pDir2, ulBytesToRead);
     1784                  if (usFreeEntries >= usEntriesNeeded)
     1785                     {
     1786                     PDIRENTRY1 pWork3;
     1787                     //BYTE bCheck = GetVFATCheckSum(pDirNew);
     1788
     1789                     if (f32Parms.fMessageActive & LOG_FUNCS)
     1790                        Message(" Inserting entry into 1 cluster");
     1791
     1792                     pWork = CompactDir1(pDir2, ulBytesToRead, usEntriesNeeded);
     1793                     pWork3 = fSetLongName1(pWork+2, pszLongName, &usNameHash);
     1794                     pNew1->u.File.bSecondaryCount = (BYTE)(pWork3 - pWork - 1);
     1795                     memcpy(pWork++, pNew, sizeof (DIRENTRY1));
     1796                     pStreamNew->u.Stream.usNameHash = usNameHash;
     1797                     pStreamNew->u.Stream.bNameLen = (BYTE)strlen(pszLongName);
     1798                     memcpy(pWork++, pStreamNew, sizeof (DIRENTRY1));
     1799                     (pWork-2)->u.File.usSetCheckSum = GetChkSum16((char *)(pWork-2),
     1800                        sizeof(DIRENTRY1) * ((pWork-2)->u.File.bSecondaryCount + 1));
     1801                     //if (ulCluster == 1)
     1802                     //   // reading root directory on FAT12/FAT16
     1803                     //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1804                     //else
     1805                        rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1806                     if (rc)
     1807                        {
     1808                        free(pDirNew);
     1809                        free(pDirectory);
     1810                        return rc;
     1811                        }
     1812                     ulCluster = pVolInfo->ulFatEof;
     1813                     break;
     1814                     }
     1815                  else if (usFreeEntries > 0)
     1816                     {
     1817                     MarkFreeEntries1(pDir2, ulBytesToRead);
     1818                     //if (ulCluster == 1)
     1819                     //   // reading root directory on FAT12/FAT16
     1820                     //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
     1821                     //else
     1822                        rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
     1823                     if (rc)
     1824                        {
     1825                        free(pDirNew);
     1826                        free(pDirectory);
     1827                        return rc;
     1828                        }
     1829                     }
     1830
     1831                  break;
     1832               }
     1833
     1834            if (ulCluster != pVolInfo->ulFatEof)
     1835               {
     1836               ulPrevBytesToRead = ulBytesToRead;
     1837               ulPrevCluster = ulCluster;
     1838               ulPrevSector = ulSector;
     1839               ulPrevBlock = ulBlock;
     1840               memset(pDirectory, 0, (size_t)pVolInfo->ulClusterSize);
     1841               memmove(pDirectory, pDir2, (size_t)ulBytesToRead);
     1842               if (pLNStart)
     1843                  pLNStart = (PDIRENTRY1)((PBYTE)pLNStart - pVolInfo->ulBlockSize);
     1844
     1845               //if (ulCluster == 1)
     1846               //   {
     1847               //   // reading the root directory in case of FAT12/FAT16
     1848               //   ulSector += pVolInfo->SectorsPerCluster;
     1849               //   usSectorsRead += pVolInfo->SectorsPerCluster;
     1850               //   if (usSectorsRead * pVolInfo->BootSect.bpb.BytesPerSector >=
     1851               //       pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY))
     1852               //      // root directory ended
     1853               //      ulNextCluster = 0;
     1854               //   else
     1855               //      ulNextCluster = 1;
     1856               //   }
     1857               //else
     1858                  ulNextCluster = GetNextCluster(pVolInfo, pDirSHInfo, ulCluster);
     1859               if (!ulNextCluster)
     1860                  ulNextCluster = pVolInfo->ulFatEof;
     1861               if (ulNextCluster == pVolInfo->ulFatEof)
     1862                  {
     1863                  if (usMode == MODIFY_DIR_UPDATE ||
     1864                      usMode == MODIFY_DIR_DELETE ||
     1865                      usMode == MODIFY_DIR_RENAME)
     1866                     {
     1867                     if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
     1868                        {
     1869                        free(pDirNew);
     1870                        free(pDirectory);
     1871                        return ERROR_FILE_NOT_FOUND;
     1872                        }
     1873                     else
     1874                        {
     1875                        if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
     1876                           ulCluster = ulNextCluster;
     1877                        continue;
     1878                        }
    17221879                     }
    17231880                  else
    1724                      pLNStart = NULL;
    1725                   pWork++;
     1881                     {
     1882                     //if (ulCluster == 1)
     1883                     //   {
     1884                     //   // no expanding for root directory in case of FAT12/FAT16
     1885                     //   ulNextCluster = pVolInfo->ulFatEof;
     1886                     //   }
     1887                     //else
     1888                        ulNextCluster = SetNextCluster(pVolInfo, ulCluster, FAT_ASSIGN_NEW);
     1889                     if (ulNextCluster == pVolInfo->ulFatEof)
     1890                        {
     1891                        free(pDirNew);
     1892                        free(pDirectory);
     1893                        return ERROR_DISK_FULL;
     1894                        }
     1895                     fNewCluster = TRUE;
     1896                     }
    17261897                  }
    1727 
    1728                if (pWork != pMax)
     1898               ulCluster = ulNextCluster;
     1899
     1900               // clear the new cluster
     1901               if (fNewCluster)
    17291902                  {
    1730                   switch (usMode)
    1731                      {
    1732                      case MODIFY_DIR_UPDATE:
    1733                         if (f32Parms.fMessageActive & LOG_FUNCS)
    1734                            Message(" Updating cluster");
    1735                         memcpy(pWorkFile, pNew, sizeof (DIRENTRY1));
    1736                         if (pStreamNew)
    1737                            {
    1738                            memcpy(pWorkStream, pStreamNew, sizeof (DIRENTRY1));
    1739                            }
    1740                         pWorkFile->u.File.usSetCheckSum = GetChkSum16((char *)pWorkFile,
    1741                            sizeof(DIRENTRY1) * (pWorkFile->u.File.bSecondaryCount + 1));
    1742                         //if (ulCluster == 1)
    1743                         //   // reading root directory on FAT12/FAT16
    1744                         //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1745                         //else
    1746                            rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1747                         if (rc)
    1748                            {
    1749 #ifndef USE_STATIC_BUFS
    1750                            free(pDirectory);
    1751 #endif
    1752                            return rc;
    1753                            }
    1754                         ulCluster = pVolInfo->ulFatEof;
    1755                         break;
    1756 
    1757                      case MODIFY_DIR_DELETE:
    1758                      case MODIFY_DIR_RENAME:
    1759                         if (f32Parms.fMessageActive & LOG_FUNCS)
    1760                            Message(" Removing entry from cluster");
    1761                         pWork2 = pLNStart;
    1762                         //while (pWork2 < pWork)
    1763                         for (usIndex = 0; usIndex < usNumSecondary - 1; usIndex++)
    1764                            {
    1765                            if (f32Parms.fMessageActive & LOG_FUNCS)
    1766                               Message("Deleting Longname entry.");
    1767                            //pWork2->bFileName[0] = DELETED_ENTRY;
    1768                            pWork2->bEntryType &= ~ENTRY_TYPE_IN_USE_STATUS;
    1769                            pWork2++;
    1770                            }
    1771                         //pWork->bFileName[0] = DELETED_ENTRY;
    1772                         pWorkFile->bEntryType &= ~ENTRY_TYPE_IN_USE_STATUS;
    1773                         pWorkStream->bEntryType &= ~ENTRY_TYPE_IN_USE_STATUS;
    1774 
    1775                         /*
    1776                            Write previous cluster if LN start lies there
    1777                         */
    1778                         //if (ulPrevCluster != pVolInfo->ulFatEof &&
    1779                         //   pLNStart < pDir2)
    1780                         //   {
    1781                         //   if (ulPrevCluster == 1)
    1782                         //      // reading root directory on FAT12/FAT16
    1783                         //      rc = WriteSector(pVolInfo, ulPrevSector + ulPrevBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirectory, usIOMode);
    1784                         //   else
    1785                         //      rc = WriteBlock(pVolInfo, ulPrevCluster, ulPrevBlock, pDirectory, usIOMode);
    1786                         //   if (rc)
    1787                         //      {
    1788 #ifndef USE_STATIC_BUFS
    1789                         //      free(pDirectory);
    1790 #endif
    1791                         //      return rc;
    1792                         //      }
    1793                         //   }
    1794 
    1795                         /*
    1796                            Write current cluster
    1797                         */
    1798                         //if (ulCluster == 1)
    1799                         //   // reading root directory on FAT12/FAT16
    1800                         //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1801                         //else
    1802                            rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1803                         if (rc)
    1804                            {
    1805 #ifndef USE_STATIC_BUFS
    1806                            free(pDirectory);
    1807 #endif
    1808                            return rc;
    1809                            }
    1810 
    1811                         if (usMode == MODIFY_DIR_DELETE)
    1812                            ulCluster = pVolInfo->ulFatEof;
    1813                         else
    1814                            {
    1815                            usMode = MODIFY_DIR_INSERT;
    1816                            ulCluster = ulDirCluster;
    1817                            ulBytesRemained = pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY);
    1818                            ulPrevCluster = pVolInfo->ulFatEof;
    1819                            ulPrevSector = 0;
    1820                            ulPrevBlock = 0;
    1821                            usClusterCount = 0;
    1822                            pLNStart = NULL;
    1823                            continue;
    1824                            }
    1825                         break;
     1903                  ULONG ulBlock2;
     1904                  memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
     1905                  for (ulBlock2 = 0; ulBlock2 < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize; ulBlock2++)
     1906                     {
     1907                     rc = WriteBlock(pVolInfo, ulCluster, ulBlock2, pDir2, usIOMode);
     1908                     if (rc)
     1909                        {
     1910                        free(pDirNew);
     1911                        free(pDirectory);
     1912                        return rc;
     1913                        }
    18261914                     }
    18271915                  }
    1828 
    18291916               break;
    1830 
    1831             case MODIFY_DIR_INSERT:
    1832                pNew->bEntryType = ENTRY_TYPE_FILE;
    1833                pStreamNew->bEntryType = ENTRY_TYPE_STREAM_EXT;
    1834 
    1835                if (ulPrevCluster != pVolInfo->ulFatEof && GetFreeEntries((PDIRENTRY)pDirectory, ulPrevBytesToRead + ulBytesToRead) >= usEntriesNeeded)
    1836                   {
    1837                   PDIRENTRY1 pWork3;
    1838                   //BYTE bCheck = GetVFATCheckSum(&DirNew);
    1839 
    1840                   if (f32Parms.fMessageActive & LOG_FUNCS)
    1841                      Message(" Inserting entry into 2 clusters");
    1842 
    1843                   pWork = CompactDir1(pDirectory, ulPrevBytesToRead + ulBytesToRead, usEntriesNeeded);
    1844                   //pWork = fSetLongName(pWork, pszLongName, bCheck);
    1845                   //memcpy(pWork, &DirNew, sizeof (DIRENTRY));
    1846                   pWork3 = fSetLongName1(pWork+2, pszLongName, &usNameHash);
    1847                   pNew->u.File.bSecondaryCount = (BYTE)(pWork3 - pWork - 1);
    1848                   memcpy(pWork++, pNew, sizeof (DIRENTRY1));
    1849                   pStreamNew->u.Stream.usNameHash = usNameHash;
    1850                   pStreamNew->u.Stream.bNameLen = (BYTE)strlen(pszLongName);
    1851                   memcpy(pWork++, pStreamNew, sizeof (DIRENTRY1));
    1852                   (pWork-2)->u.File.usSetCheckSum = GetChkSum16((char *)(pWork-2),
    1853                      sizeof(DIRENTRY1) * ((pWork-2)->u.File.bSecondaryCount + 1));
    1854 
    1855                   //if (ulPrevCluster == 1)
    1856                   //   // reading root directory on FAT12/FAT16
    1857                   //   rc = WriteSector(pVolInfo, ulPrevSector + ulPrevBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDirectory, usIOMode);
    1858                   //else
    1859                      rc = WriteBlock(pVolInfo, ulPrevCluster, ulPrevBlock, pDirectory, usIOMode);
    1860                   if (rc)
    1861                      {
    1862 #ifndef USE_STATIC_BUFS
    1863                      free(pDirectory);
    1864 #endif
    1865                      return rc;
    1866                      }
    1867 
    1868                   //if (ulCluster == 1)
    1869                   //   // reading root directory on FAT12/FAT16
    1870                   //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1871                   //else
    1872                      rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1873                   if (rc)
    1874                      {
    1875 #ifndef USE_STATIC_BUFS
    1876                      free(pDirectory);
    1877 #endif
    1878                      return rc;
    1879                      }
    1880                   ulCluster = pVolInfo->ulFatEof;
    1881                   break;
    1882                   }
    1883 
    1884                usFreeEntries = GetFreeEntries((PDIRENTRY)pDir2, ulBytesToRead);
    1885                if (usFreeEntries >= usEntriesNeeded)
    1886                   {
    1887                   PDIRENTRY1 pWork3;
    1888                   //BYTE bCheck = GetVFATCheckSum(&DirNew);
    1889 
    1890                   if (f32Parms.fMessageActive & LOG_FUNCS)
    1891                      Message(" Inserting entry into 1 cluster");
    1892 
    1893                   pWork = CompactDir1(pDir2, ulBytesToRead, usEntriesNeeded);
    1894                   pWork3 = fSetLongName1(pWork+2, pszLongName, &usNameHash);
    1895                   pNew->u.File.bSecondaryCount = (BYTE)(pWork3 - pWork - 1);
    1896                   memcpy(pWork++, pNew, sizeof (DIRENTRY1));
    1897                   pStreamNew->u.Stream.usNameHash = usNameHash;
    1898                   pStreamNew->u.Stream.bNameLen = (BYTE)strlen(pszLongName);
    1899                   memcpy(pWork++, pStreamNew, sizeof (DIRENTRY1));
    1900                   (pWork-2)->u.File.usSetCheckSum = GetChkSum16((char *)(pWork-2),
    1901                      sizeof(DIRENTRY1) * ((pWork-2)->u.File.bSecondaryCount + 1));
    1902                   //if (ulCluster == 1)
    1903                   //   // reading root directory on FAT12/FAT16
    1904                   //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1905                   //else
    1906                      rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1907                   if (rc)
    1908                      {
    1909 #ifndef USE_STATIC_BUFS
    1910                      free(pDirectory);
    1911 #endif
    1912                      return rc;
    1913                      }
    1914                   ulCluster = pVolInfo->ulFatEof;
    1915                   break;
    1916                   }
    1917                else if (usFreeEntries > 0)
    1918                   {
    1919                   MarkFreeEntries1(pDir2, ulBytesToRead);
    1920                   //if (ulCluster == 1)
    1921                   //   // reading root directory on FAT12/FAT16
    1922                   //   rc = WriteSector(pVolInfo, ulSector + ulBlock * usSectorsPerBlock, usSectorsPerBlock, (void *)pDir2, usIOMode);
    1923                   //else
    1924                      rc = WriteBlock(pVolInfo, ulCluster, ulBlock, pDir2, usIOMode);
    1925                   if (rc)
    1926                      {
    1927 #ifndef USE_STATIC_BUFS
    1928                      free(pDirectory);
    1929 #endif
    1930                      return rc;
    1931                      }
    1932                   }
    1933 
     1917               }
     1918            if (ulCluster == pVolInfo->ulFatEof)
    19341919               break;
    1935             }
    1936 
    1937          if (ulCluster != pVolInfo->ulFatEof)
    1938             {
    1939             ulPrevBytesToRead = ulBytesToRead;
    1940             ulPrevCluster = ulCluster;
    1941             ulPrevSector = ulSector;
    1942             ulPrevBlock = ulBlock;
    1943             memset(pDirectory, 0, (size_t)pVolInfo->ulClusterSize);
    1944             memmove(pDirectory, pDir2, (size_t)ulBytesToRead);
    1945             if (pLNStart)
    1946                pLNStart = (PDIRENTRY1)((PBYTE)pLNStart - pVolInfo->ulBlockSize);
    1947 
    1948             //if (ulCluster == 1)
    1949             //   {
    1950             //   // reading the root directory in case of FAT12/FAT16
    1951             //   ulSector += pVolInfo->SectorsPerCluster;
    1952             //   usSectorsRead += pVolInfo->SectorsPerCluster;
    1953             //   if (usSectorsRead * pVolInfo->BootSect.bpb.BytesPerSector >=
    1954             //       pVolInfo->BootSect.bpb.RootDirEntries * sizeof(DIRENTRY))
    1955             //      // root directory ended
    1956             //      ulNextCluster = 0;
    1957             //   else
    1958             //      ulNextCluster = 1;
    1959             //   }
    1960             //else
    1961                ulNextCluster = GetNextCluster(pVolInfo, pDirSHInfo, ulCluster);
    1962             if (!ulNextCluster)
    1963                ulNextCluster = pVolInfo->ulFatEof;
    1964             if (ulNextCluster == pVolInfo->ulFatEof)
    1965                {
    1966                if (usMode == MODIFY_DIR_UPDATE ||
    1967                    usMode == MODIFY_DIR_DELETE ||
    1968                    usMode == MODIFY_DIR_RENAME)
    1969                   {
    1970                   if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
    1971                      {
    1972 #ifndef USE_STATIC_BUFS
    1973                      free(pDirectory);
    1974 #endif
    1975                      return ERROR_FILE_NOT_FOUND;
    1976                      }
    1977                   else
    1978                      {
    1979                      if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
    1980                         ulCluster = ulNextCluster;
    1981                      continue;
    1982                      }
    1983                   }
    1984                else
    1985                   {
    1986                   //if (ulCluster == 1)
    1987                   //   {
    1988                   //   // no expanding for root directory in case of FAT12/FAT16
    1989                   //   ulNextCluster = pVolInfo->ulFatEof;
    1990                   //   }
    1991                   //else
    1992                      ulNextCluster = SetNextCluster(pVolInfo, ulCluster, FAT_ASSIGN_NEW);
    1993                   if (ulNextCluster == pVolInfo->ulFatEof)
    1994                      {
    1995 #ifndef USE_STATIC_BUFS
    1996                      free(pDirectory);
    1997 #endif
    1998                      return ERROR_DISK_FULL;
    1999                      }
    2000                   fNewCluster = TRUE;
    2001                   }
    2002                }
    2003             ulCluster = ulNextCluster;
    2004 
    2005             // clear the new cluster
    2006             if (fNewCluster)
    2007                {
    2008                ULONG ulBlock2;
    2009                memset(pDir2, 0, (size_t)pVolInfo->ulBlockSize);
    2010                for (ulBlock2 = 0; ulBlock2 < pVolInfo->ulClusterSize / pVolInfo->ulBlockSize; ulBlock2++)
    2011                   {
    2012                   rc = WriteBlock(pVolInfo, ulCluster, ulBlock2, pDir2, usIOMode);
    2013                   if (rc)
    2014                      {
    2015 #ifndef USE_STATIC_BUFS
    2016                      free(pDirectory);
    2017 #endif
    2018                      return rc;
    2019                      }
    2020                   }
    2021                }
    2022             break;
     1920            if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
     1921               ulCluster = ulNextCluster;
    20231922            }
    20241923         if (ulCluster == pVolInfo->ulFatEof)
     
    20271926            ulCluster = ulNextCluster;
    20281927         }
    2029       if (ulCluster == pVolInfo->ulFatEof)
    2030          break;
    2031       if (ulBlock == pVolInfo->ulClusterSize / pVolInfo->ulBlockSize - 1)
    2032          ulCluster = ulNextCluster;
    2033       }
    2034 
    2035 #ifndef USE_STATIC_BUFS
    2036    free(pDirectory);
    2037 #endif
    2038    return 0;
    2039 }
    2040 
    2041 #endif
    2042 
    2043 USHORT ModifyDirectory(PVOLINFO pVolInfo, ULONG ulDirCluster, PSHOPENINFO pDirSHInfo,
    2044                        USHORT usMode, PDIRENTRY pOld, PDIRENTRY pNew,
    2045                        PDIRENTRY1 pStreamOld, PDIRENTRY1 pStreamNew,
    2046                        PSZ pszLongName, USHORT usIOMode)
    2047 {
    2048 USHORT rc;
    2049 
    2050 #ifdef USE_STATIC_BUFS
    2051    if (!GetBuf1Access(pVolInfo, "ModifyDirectory"))
    2052       {
    2053 #endif
    2054 #ifdef EXFAT
    2055       if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    2056 #endif
    2057          rc = ModifyDirectory0(pVolInfo, ulDirCluster, usMode, pOld, pNew,
    2058                                pszLongName, usIOMode);
    2059 #ifdef EXFAT
    2060       else
    2061          rc = ModifyDirectory1(pVolInfo, ulDirCluster, pDirSHInfo, usMode,
    2062                                (PDIRENTRY1)pOld, (PDIRENTRY1)pNew,
    2063                                pStreamOld, pStreamNew, pszLongName, usIOMode);
    2064 #endif
    2065 #ifdef USE_STATIC_BUFS
    2066       ReleaseBuf1(pVolInfo);
     1928
     1929      free(pDirNew);
     1930      free(pDirectory);
     1931      return 0;
    20671932      }
    20681933#endif
    2069 
    2070    return rc;
    20711934}
    2072 
    2073 USHORT GetBuf1Access(PVOLINFO pVolInfo, PSZ pszName)
    2074 {
    2075 USHORT rc;
    2076 
    2077    pVolInfo = pVolInfo;
    2078 
    2079    Message("GetBuf1Access: %s", pszName);
    2080    rc = SemRequest(&ulSemRWBuf1, TO_INFINITE, pszName);
    2081    if (rc)
    2082       {
    2083       Message("ERROR: SemRequest GetBuf1Access Failed, rc = %d!", rc);
    2084       CritMessage("FAT32: SemRequest GetBuf1Access Failed, rc = %d!", rc);
    2085       Message("GetBuf1Access Failed for %s, rc = %d", pszName, rc);
    2086       return rc;
    2087       }
    2088    return 0;
    2089 }
    2090 
    2091 VOID ReleaseBuf1(PVOLINFO pVolInfo)
    2092 {
    2093    pVolInfo = pVolInfo;
    2094    Message("ReleaseBuf1");
    2095    FSH_SEMCLEAR(&ulSemRWBuf1);
    2096 }
    2097 
    2098 USHORT GetBuf2Access(PVOLINFO pVolInfo, PSZ pszName)
    2099 {
    2100 USHORT rc;
    2101 
    2102    pVolInfo = pVolInfo;
    2103 
    2104    Message("GetBuf2Access: %s", pszName);
    2105    rc = SemRequest(&ulSemRWBuf2, TO_INFINITE, pszName);
    2106    if (rc)
    2107       {
    2108       Message("ERROR: SemRequest GetBuf2Access Failed, rc = %d!", rc);
    2109       CritMessage("FAT32: SemRequest GetBuf2Access Failed, rc = %d!", rc);
    2110       Message("GetBuf2Access Failed for %s, rc = %d", pszName, rc);
    2111       return rc;
    2112       }
    2113    return 0;
    2114 }
    2115 
    2116 VOID ReleaseBuf2(PVOLINFO pVolInfo)
    2117 {
    2118    pVolInfo = pVolInfo;
    2119    Message("ReleaseBuf2");
    2120    FSH_SEMCLEAR(&ulSemRWBuf2);
    2121 }
    2122 
    2123 USHORT GetBuf3Access(PVOLINFO pVolInfo, PSZ pszName)
    2124 {
    2125 USHORT rc;
    2126 
    2127    pVolInfo = pVolInfo;
    2128 
    2129    Message("GetBuf3Access: %s", pszName);
    2130    rc = SemRequest(&ulSemRWBuf3, TO_INFINITE, pszName);
    2131    if (rc)
    2132       {
    2133       Message("ERROR: SemRequest GetBuf3Access Failed, rc = %d!", rc);
    2134       CritMessage("FAT32: SemRequest GetBuf3Access Failed, rc = %d!", rc);
    2135       Message("GetBuf3Access Failed for %s, rc = %d", pszName, rc);
    2136       return rc;
    2137       }
    2138    return 0;
    2139 }
    2140 
    2141 VOID ReleaseBuf3(PVOLINFO pVolInfo)
    2142 {
    2143    pVolInfo = pVolInfo;
    2144    Message("ReleaseBuf3");
    2145    FSH_SEMCLEAR(&ulSemRWBuf3);
    2146 }
  • trunk/src/ifs/ifsattr.c

    r268 r284  
    2929ULONG ulDirCluster;
    3030PSZ   pszFile;
    31 DIRENTRY DirEntry;
    32 DIRENTRY DirNew;
    33 DIRENTRY1 DirStream, DirEntryStream;
    34 #ifdef EXFAT
    35 SHOPENINFO DirSHInfo;
    36 #endif
     31PDIRENTRY pDirEntry;
     32PDIRENTRY pDirNew;
     33PDIRENTRY1 pDirStream = NULL, pDirEntryStream = NULL;
    3734PSHOPENINFO pDirSHInfo = NULL;
    3835USHORT rc;
     
    6259      goto FS_FILEATTRIBUTEEXIT;
    6360      }
     61
     62   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     63   if (!pDirEntry)
     64      {
     65      rc = ERROR_NOT_ENOUGH_MEMORY;
     66      goto FS_FILEATTRIBUTEEXIT;
     67      }
     68   pDirNew = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     69   if (!pDirNew)
     70      {
     71      rc = ERROR_NOT_ENOUGH_MEMORY;
     72      goto FS_FILEATTRIBUTEEXIT;
     73      }
     74#ifdef EXFAT
     75   pDirStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     76   if (!pDirStream)
     77      {
     78      rc = ERROR_NOT_ENOUGH_MEMORY;
     79      goto FS_FILEATTRIBUTEEXIT;
     80      }
     81   pDirEntryStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     82   if (!pDirEntryStream)
     83      {
     84      rc = ERROR_NOT_ENOUGH_MEMORY;
     85      goto FS_FILEATTRIBUTEEXIT;
     86      }
     87   pDirSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     88   if (!pDirSHInfo)
     89      {
     90      rc = ERROR_NOT_ENOUGH_MEMORY;
     91      goto FS_FILEATTRIBUTEEXIT;
     92      }
     93#endif
    6494
    6595   if (strlen(pName) > FAT32MAXPATH)
     
    76106      RETURN_PARENT_DIR,
    77107      &pszFile,
    78       &DirStream);
     108      pDirStream);
    79109
    80110   if (ulDirCluster == pVolInfo->ulFatEof)
     
    87117   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    88118      {
    89       pDirSHInfo = &DirSHInfo;
    90       SetSHInfo1(pVolInfo, &DirStream, pDirSHInfo);
    91       }
    92 #endif
    93 
    94    ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszFile, pDirSHInfo, &DirEntry, &DirEntryStream, NULL);
     119      SetSHInfo1(pVolInfo, pDirStream, pDirSHInfo);
     120      }
     121#endif
     122
     123   ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszFile, pDirSHInfo, pDirEntry, pDirEntryStream, NULL);
    95124   if (ulCluster == pVolInfo->ulFatEof)
    96125      {
     
    105134         if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
    106135#endif
    107             *pAttr = DirEntry.bAttr;
     136            *pAttr = pDirEntry->bAttr;
    108137#ifdef EXFAT
    109138         else
    110139            {
    111             PDIRENTRY1 pDirEntry = (PDIRENTRY1)&DirEntry;
    112             *pAttr = pDirEntry->u.File.usFileAttr;
     140            PDIRENTRY1 pDirEntry1 = (PDIRENTRY1)pDirEntry;
     141            *pAttr = pDirEntry1->u.File.usFileAttr;
    113142            }
    114143#endif
     
    143172            {
    144173#endif
    145             memcpy(&DirNew, &DirEntry, sizeof (DIRENTRY));
    146 
    147             if (DirNew.bAttr & FILE_DIRECTORY)
    148                DirNew.bAttr = (BYTE)(*pAttr | FILE_DIRECTORY);
    149             else
    150                DirNew.bAttr = (BYTE)*pAttr;
     174            memcpy(pDirNew, pDirEntry, sizeof (DIRENTRY));
     175
     176            if (pDirNew->bAttr & FILE_DIRECTORY)
     177               pDirNew->bAttr = (BYTE)(*pAttr | FILE_DIRECTORY);
     178            else
     179               pDirNew->bAttr = (BYTE)*pAttr;
    151180            rc = ModifyDirectory(pVolInfo, ulDirCluster, pDirSHInfo, MODIFY_DIR_UPDATE,
    152                &DirEntry, &DirNew, NULL, NULL, NULL, 0);
     181               pDirEntry, pDirNew, NULL, NULL, NULL, 0);
    153182#ifdef EXFAT
    154183            }
    155184         else
    156185            {
    157             DIRENTRY1 DirNew1;
    158             memcpy(&DirNew1, &DirEntry, sizeof (DIRENTRY));
    159 
    160             if (DirNew1.u.File.usFileAttr & FILE_DIRECTORY)
    161                DirNew1.u.File.usFileAttr = (BYTE)(*pAttr | FILE_DIRECTORY);
    162             else
    163                DirNew1.u.File.usFileAttr = (BYTE)*pAttr;
     186            PDIRENTRY1 pDirNew1 = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     187            if (!pDirNew1)
     188               {
     189               rc = ERROR_NOT_ENOUGH_MEMORY;
     190               goto FS_FILEATTRIBUTEEXIT;
     191               }
     192            memcpy(pDirNew1, pDirEntry, sizeof (DIRENTRY));
     193
     194            if (pDirNew1->u.File.usFileAttr & FILE_DIRECTORY)
     195               pDirNew1->u.File.usFileAttr = (BYTE)(*pAttr | FILE_DIRECTORY);
     196            else
     197               pDirNew1->u.File.usFileAttr = (BYTE)*pAttr;
    164198            rc = ModifyDirectory(pVolInfo, ulDirCluster, pDirSHInfo, MODIFY_DIR_UPDATE,
    165                &DirEntry, (PDIRENTRY)&DirNew1, &DirEntryStream, NULL, NULL, 0);
     199               pDirEntry, (PDIRENTRY)pDirNew1, pDirEntryStream, NULL, NULL, 0);
     200            free(pDirNew1);
    166201            }
    167202#endif
     
    174209
    175210FS_FILEATTRIBUTEEXIT:
     211   if (pDirEntry)
     212      free(pDirEntry);
     213   if (pDirNew)
     214      free(pDirNew);
     215#ifdef EXFAT
     216   if (pDirStream)
     217      free(pDirStream);
     218   if (pDirEntryStream)
     219      free(pDirEntryStream);
     220   if (pDirSHInfo)
     221      free(pDirSHInfo);
     222#endif
    176223
    177224   if (f32Parms.fMessageActive & LOG_FS)
     
    202249ULONG ulDirCluster;
    203250PSZ   pszFile;
    204 DIRENTRY DirEntry;
    205 DIRENTRY1 DirEntryStream;
    206 DIRENTRY1 DirStream;
    207 #ifdef EXFAT
    208 SHOPENINFO DirSHInfo;
    209 #endif
     251PDIRENTRY pDirEntry;
     252PDIRENTRY1 pDirEntryStream = NULL;
     253PDIRENTRY1 pDirStream = NULL;
    210254PSHOPENINFO pDirSHInfo = NULL;
    211255USHORT usNeededSize;
     
    237281      goto FS_PATHINFOEXIT;
    238282      }
     283
     284   pDirEntry = (PDIRENTRY)malloc((size_t)sizeof(DIRENTRY));
     285   if (!pDirEntry)
     286      {
     287      rc = ERROR_NOT_ENOUGH_MEMORY;
     288      goto FS_PATHINFOEXIT;
     289      }
     290#ifdef EXFAT
     291   pDirEntryStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     292   if (!pDirEntryStream)
     293      {
     294      rc = ERROR_NOT_ENOUGH_MEMORY;
     295      goto FS_PATHINFOEXIT;
     296      }
     297   pDirStream = (PDIRENTRY1)malloc((size_t)sizeof(DIRENTRY1));
     298   if (!pDirStream)
     299      {
     300      rc = ERROR_NOT_ENOUGH_MEMORY;
     301      goto FS_PATHINFOEXIT;
     302      }
     303   pDirSHInfo = (PSHOPENINFO)malloc((size_t)sizeof(SHOPENINFO));
     304   if (!pDirSHInfo)
     305      {
     306      rc = ERROR_NOT_ENOUGH_MEMORY;
     307      goto FS_PATHINFOEXIT;
     308      }
     309#endif
    239310
    240311   if (strlen(pName) > FAT32MAXPATH)
     
    253324         RETURN_PARENT_DIR,
    254325         &pszFile,
    255          &DirStream);
     326         pDirStream);
    256327
    257328      if (ulDirCluster == pVolInfo->ulFatEof)
     
    264335      if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    265336         {
    266          pDirSHInfo = &DirSHInfo;
    267          SetSHInfo1(pVolInfo, &DirStream, pDirSHInfo);
     337         SetSHInfo1(pVolInfo, pDirStream, pDirSHInfo);
    268338         }
    269339#endif
     
    272342   if (usFlag == PI_RETRIEVE)
    273343      {
    274       BYTE szFullName[FAT32MAXPATH];
     344      //BYTE szFullName[FAT32MAXPATH];
     345      PSZ szFullName = (PSZ)malloc((size_t)FAT32MAXPATH);
     346      if (!szFullName)
     347         {
     348         rc = ERROR_NOT_ENOUGH_MEMORY;
     349         goto FS_PATHINFOEXIT;
     350         }
    275351
    276352      if (usLevel != FIL_NAMEISVALID)
    277353         {
    278          ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszFile, pDirSHInfo, &DirEntry, &DirEntryStream, NULL);
     354         ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszFile, pDirSHInfo, pDirEntry, pDirEntryStream, NULL);
    279355         if (ulCluster == pVolInfo->ulFatEof)
    280356            {
     
    342418               {
    343419#endif
    344                pfStatus->fdateCreation = DirEntry.wCreateDate;
    345                pfStatus->ftimeCreation = DirEntry.wCreateTime;
    346                pfStatus->fdateLastAccess = DirEntry.wAccessDate;
    347                pfStatus->fdateLastWrite = DirEntry.wLastWriteDate;
    348                pfStatus->ftimeLastWrite = DirEntry.wLastWriteTime;
    349