开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
ISO9660_API.c
资源名称：tb_i86_wr_1019_1102.　[点击查看]
上传用户：super_houu
上传日期：2008-09-21
资源大小：4099k
文件大小：70k
源码类别：

DVD

开发平台：

Others

ISO9660_API.c：源码内容
  2. /****************************************************************************************
  3.  *  Copyright (c) 2002 ZORAN Corporation, All Rights Reserved
  4.  *  THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
  5.  *
  6.  *  File: $Workfile: ISO9660_API.c $             
  7.  *
  8.  * Description:
  9.  * ============
  10.  * 
  11.  * 
  12.  * Log:
  13.  * ====
  14.  * $Revision: 22 $
  15.  * Last Modified by $Author: Mikex $ at $Modtime: 04-03-20 20:36 $ 
  16.  ****************************************************************************************
  17.  * Updates:
  18.  ****************************************************************************************
  19.  * $Log: /I76/I76_Common/I76_Reference/Playcore/FileSys/ISO9660/ISO9660_API.c $
  20.  * 
  21.  * 22    04-03-20 21:00 Mikex
  22.  * Cut the file name longer than 128 bytes.
  23.  * example: if the file name length is 130
  24.  * origenal: abc...xyz.mp3
  25.  * before:   abc...xyz.m
  26.  * now:       abc...x.mp3
  27.  * 
  28.  * 21    11/19/03 10:25a Leslie
  29.  * 
  30.  * 20    03-07-17 17:11 Jerryc
  31.  * support finding files with name length of 63 and 64. 
  32.  * 
  33.  * 19    03-07-15 18:57 Jerryc
  34.  * ISO9660_checkValid will not return FLASE if some pathTable records are
  35.  * empty.
  36.  * 
  37.  * 18    7/08/03 3:39p Mikex
  38.  * delete the CHECK_ISO9660_PATHTABLE define switch
  39.  * 
  40.  * 17    7/08/03 3:14p Mikex
  41.  * change function ISO9660_checkValid for having several iso9660 PVD disc.
  42.  * 
  43.  * 16    03-07-06 1:55 Leslie
  44.  * Add CHECK_ISO9660_PATHTABLE
  45.  * 
  46.  * 15    7/03/03 7:37p Mikex
  47.  * 
  48.  * 14    7/03/03 2:16p Mikex
  49.  * add a function ISO9660_checkValid to check whether the ISO9660 file
  50.  * system was ok or not. the function was transferred by
  51.  * ISO9660_initialize function.
  52.  * 
  53.  * 13    7/01/03 6:28p Mikex
  54.  * add ISO9660_getFilesFirst, ISO9660_getFilesNext and
  55.  * ISO9660_getFilesClose function to get all files in one directory
  56.  * 
  57.  * 12    2/07/03 10:41p Tomasp
  58.  * - changed SW feature selection to compilation switch
  59.  * 
  60.  * 11    03-01-30 23:12 Leslie
  61.  * Add functions ISO9660_GetcurrentDirICB and ISO9660_SetcurrentDirICB
  62.  * 
  63.  * 10    03-01-10 12:20 Leslie
  64.  * Add builtin unicode support
  65.  * 
  66.  * 9     10/31/02 17:22 Hamadk
  67.  * Check of the parameter in filesystem intializing
  68.  * 
  69.  * 10    23/04/02 9:30 Nirm
  70.  * - Added dependency in "Config.h".
  71.  * 
  72.  * 9     13/03/02 21:25 Nirm
  73.  * Fixed an endless-loop problem in _findNextFileRecord(): If a directory
  74.  * padding spans beyond a sector-boundary (due to authoring error), the
  75.  * sector-boundary wouldn't be crossed. This is a result of the caching
  76.  * mechanism.
  77.  * A special check was added to assure correct sector-boundary crossing.
  78.  * 
  79.  * 8     4/02/02 10:54 Nirm
  80.  * Unused External-Memory is freed, to reduce memory consumption.
  81.  * 
  82.  * 7     30/01/02 18:16 Nirm
  83.  * Updated debugging-messages.
  84.  * 
  85.  * 6     27/01/02 17:47 Nirm
  86.  * - Added ISO9660_construct() and ISO9660_destruct(), to allow proper
  87.  * allocation and deallocation of system resources;
  88.  * - Modifications and optimizations to memory consumption.
  89.  * 
  90.  * 5     16/01/02 11:46 Atai
  91.  * Change Debug printing
  92.  * 
  93.  * 4     1/10/02 18:08 Idan
  94.  * added optimization - avoid memory allocation when wild card search is
  95.  * requested.
  96.  * 
  97.  * 3     1/10/02 15:32 Idan
  98.  * FindFirstFile, FindNextFile, GoUp, ChangeDirectory, GetFileAttributes
  99.  * and all memory allocatations are working properly.
  100.  * 
  101.  * 2     12/31/01 19:46 Idan
  102.  * initializing the ISO9660 FS is working.
  103.  * 
  104.  * 1     12/27/01 14:19 Idan
  105.  * 
  106.  ****************************************************************************************/
  109. /////////////////////////////////////////////////////////////////////////////
  110. // ISO9660_API.c - Implementation of the ISO-9660 File-System For DVD/S-VCD
  111. //    Players.
  112. //
  113. // Author: Nir Milstein
  116. #include "Config.h" // Global Configuration - do not remove!
  118. #ifdef _DEBUG
  119. #undef IFTRACE
  120. #define IFTRACE if (gTraceFileSys)
  121. #include "DebugDbgMain.h"
  122. #endif //_DEBUG
  125. #include "Includemath-macro.h"
  126. #include "Includestring_ex.h"
  127. #include "PlaycoreFileSysFileSystem_Impl.h"
  128. #include "PlaycoreFileSysIso9660ISO9660_API.h"
  129. #include "PlaycoreFileSysIso9660ECMA119.h"
  130. #include "PlaycoreDataStructuresArray.h"
  131. #include "PlaycoreAuxCacheAuxCache.h"
  132. #include "PlaycoreScPadscmgr.h"
  133. #include "PlaycoreCoremaincoregdef.h"
  134. #include "PlaycoreFileSysFileSystem.h"
  135. #ifdef MACESTROLINK_SUPPORT
  136. #include "drivefe_manager.h"
  137. #endif
  139. /////////////////////////////////////////////////////////////////////////////
  140. // Constants
  142. #define DIRECTORY_RECLIST_SZ (5 * (sizeof(struct DirFileRecord) + MAX_ID_LENGTH))
  145. /////////////////////////////////////////////////////////////////////////////
  146. // Macros
  148. #ifdef MOTOROLA
  150. #define BB_WORD(wBothBytes) (WORD)(wBothBytes ## .wBE16)
  151. #define BB_DWORD(dwBothBytes) (DWORD)(dwBothBytes ## .dwBE32)
  153. #else
  155. #define BB_WORD(wBothBytes) (WORD)(wBothBytes ## .wLE16)
  156. #define BB_DWORD(dwBothBytes) (DWORD)(dwBothBytes ## .dwLE32)
  158. #endif //MOTOROLA
  161. /////////////////////////////////////////////////////////////////////////////
  162. // Globals and Singletons
  164. /*
  165. //static struct ISO9660_TAG {
  166. typedef struct {
  167. // Session information
  168. DWORD dwSessionStartLBN;
  170. // Unicode support
  171. BOOL  bIsUsingUnicode;
  173. // Volume information
  174. DWORD dwRootDirICB;
  175. DWORD dwCurrDirICB;
  177. // Current Working-Directory storage
  178. BOOL  bCWDStored;
  179. DWORD dwCWDStorage;
  181. // Directory Hierarchy Tree
  182. UINT16 uDirectoryCnt;
  183. UINT32 hDirTree;
  184. } ISO9660_TAG;//g_ISO9660Info;
  185. */
  187. ISO9660_TAG * g_pISO9660Info;
  189. /////////////////////////////////////////////////////////////////////////////
  190. // Internal Structures / Types
  192. typedef struct ISO9660_DirectorySearchInfo_TAG {
  193. // Directory Location and Size related
  194. DWORD  dwDirICB; // Location of the Directory
  195. UINT16 uDirNumber; // Serial Number
  196. DWORD  dwDirectorySize; // In Bytes
  198. // Search Criteria related
  199. LPWSTR pszFileID; // The Pattern/Name to search for
  200. UINT8  uFileFlagsMask; // A Mask to apply to File-Flags
  201. UINT8  uFileFlags; // The required File-Flags
  203. // Search Status/Position related
  204. WORD   hDirFileRecordList;
  205. UINT32 cbRecListOffset; // In Bytes from the Directory's start
  206. UINT16 cbCurrRecOffset; // In Bytes from the Record-List start
  207. } DirectorySearchInfo;
  210. typedef struct DirectoryNode_TAG {
  211. UINT16 uParentDirNumber;
  212. DWORD  dwDirICB;
  213. } DirectoryNode;
  214. #define MAX_FILEREC_SIZE (sizeof(struct DirFileRecord) + MAX_ID_LENGTH + 2)
  217. /////////////////////////////////////////////////////////////////////////////
  218. // Forward-Declarations of Private-Services
  220. static BOOL _buildDirectoryTree(DWORD dwPathTableAddress, DWORD dwPathTableSize);
  221. static UINT16 _findFirstFileRecord(LPCWSTR i_pszFileID, UINT8 uFileFlagsMask, 
  222.    UINT8 uFileFlags, 
  223.    struct DirFileRecord **o_pFileRecordPtr);
  225. static BOOL _findNextFileRecord(UINT16 uSearchID, struct DirFileRecord **o_pFileRecordPtr);
  226. static BOOL _findClose(UINT16 uSearchID);
  227. static void _getFileAttributes(const struct DirFileRecord *i_pFileRec, FindData *o_pFindData);
  230. /////////////////////////////////////////////////////////////////////////////
  231. // Detection
  233. /////////////////////////////////////////////////////////////////////////////
  234. // ISO9660_isResident()
  235. //
  236. // Description: Tests a given LBN to detect whether or not an instance of
  237. // ISO-9660 is resident on the Medium at that location.
  238. //
  239. // Input: dwCandidateLBN - The candidate LBN to test.
  240. // Output: None
  241. // In/Out: None
  242. // Return: TRUE if an ISO-9660 instance was found at the specified LBN;
  243. // FALSE otherwise.
  244. //
  245. // Remarks:
  246. // The method assumes that the given LBN is the beginning of a
  247. // Volume-Recognition Sequence, and searches for the Standard-ID associated
  248. // with ISO-9660.
  250. BOOL ISO9660_isResident(DWORD dwCandidateLBN)
  251. {
  252. struct GenericVolumeStructureDesc_Base gvsdVolumeDesc;
  254. dbg_printf(("ISO9660_isResident(0x%08x) calling.n", dwCandidateLBN));
  256. // Load the first Volume-Structure Descriptor within the Volume-Recognition-Sequence
  257. if (! AuxCache_GetBytes((dwCandidateLBN + VOLUME_RECOGNITION_SEQUENCE_START_LSN), 0, 
  258.    sizeof(gvsdVolumeDesc), (BYTE*)&gvsdVolumeDesc))
  259. {
  260. dbg_printf(("WARNING: ISO9660_isResident() Failed [1]n"));
  261. return FALSE;
  262. }
  264. // Check for an ISO-9660 Standard-ID
  265. if (0 == strncmp((LPCSTR)gvsdVolumeDesc.aStandardID, STANDARD_ID_CD001, STANDARD_ID_LEN))
  266. return TRUE;
  268. return FALSE;
  269. }
  272. /////////////////////////////////////////////////////////////////////////////
  273. // Construction / Destruction
  275. /////////////////////////////////////////////////////////////////////////////
  276. // ISO9660_construct()
  277. //
  278. // Description: Constructs the File-System, and allocates system resources
  279. // needed for correct operation.
  280. //
  281. // Input: dwSessionStartLBN - The Start-LBN of the current Session.
  282. // Output: None
  283. // In/Out: None
  284. // Return: None
  285. //
  286. // Remarks:
  287. // This method must be called prior to initialization of the File-System.
  289. void ISO9660_construct(DWORD dwSessionStartLBN)
  290. {
  291. dbg_printf(("ISO9660_construct(0x%08x) calling.n", dwSessionStartLBN));
  293. if( g_pISO9660Info != NULL)
  294. {
  295. free(g_pISO9660Info);
  296. }
  297. g_pISO9660Info = (FileInfo *)malloc(sizeof(FileInfo));
  298. if(NULL == g_pISO9660Info)
  299. {
  300. tr_printf(("ISO9660_construct() failed--alloc memory for g_pISO9660Info failed.n"));
  301. return;
  302. }
  304. // Record the Session-Start Address
  305. g_pISO9660Info->dwSessionStartLBN= dwSessionStartLBN;
  307. // Initialize the Directory-Tree Handle
  308. g_pISO9660Info->hDirTree= NULL;
  310. // Reset the Search-Info Pool
  311. if (! _FileSys_resetSearchInfoPool(sizeof(DirectorySearchInfo))) {
  312. tr_printf(("FATAL: ISO9660_construct() Failed [1]n"));
  313. }
  315. return;
  316. }
  319. /////////////////////////////////////////////////////////////////////////////
  320. // ISO9660_destruct()
  321. //
  322. // Description: Destructs the File-System, and frees system resources
  323. // allocated during the operation.
  324. //
  325. // Input: None
  326. // Output: None
  327. // In/Out: None
  328. // Return: None
  329. //
  330. // Remarks:
  331. // This method should be called when the File-System is no longer needed.
  333. void ISO9660_destruct(void)
  334. {
  335. dbg_printf(("ISO9660_destruct() callingn"));
  337. // Free the Directory-Tree
  338. if (NULL != g_pISO9660Info->hDirTree) {
  339. Array_destruct(g_pISO9660Info->hDirTree);
  340. g_pISO9660Info->hDirTree= NULL;
  341. }
  343. if(NULL != g_pISO9660Info)
  344. {
  345. free(g_pISO9660Info);
  346. g_pISO9660Info = NULL;
  347. }
  349. return;
  350. }
  353. /////////////////////////////////////////////////////////////////////////////
  354. // Initialization
  356. /////////////////////////////////////////////////////////////////////////////
  357. // ISO9660_initialize()
  358. //
  359. // Description: Initializes the File-System and switches to the Root 
  360. // directory.
  361. //
  362. // Input: bLongFilenameSupport - Determines whether or not Long-Filenames
  363. //    Support is enabled.
  364. // Output: None
  365. // In/Out: None
  366. // Return: TRUE if the File-System was successfully initialized; FALSE
  367. // otherwise.
  368. //
  369. // Remarks:
  370. // 1. In case of failure, none of the Navigation or Queries methods may
  371. //    be used.
  372. // 2. Supplying a value of FALSE in bLongFilenameSupport forces use
  373. //    of Filenames in 8.3 format, even if the Medium carries a Joliet
  374. //    extension for Long-Filenames.
  375. // 3. The File-System information is taken from the last Closed-Session on 
  376. //    the Medium.
  378. BOOL ISO9660_initialize(BOOL bLongFilenameSupport)
  379. {
  380. BOOL bRootDirEstablished= FALSE;
  381. DWORD dwCurrDescLBN;
  382. struct GenericVolumeStructureDesc_Base *pCurrDescHdr;
  383. struct VolumeDesc_Partial *pPartialVolDesc;
  385. dbg_printf(("ISO9660_initialize() calling.n"));
  387. if(!ISO9660_checkValid())
  388. return FALSE;
  389. // Allocate space for a generic Descriptor base
  390. pCurrDescHdr= (struct GenericVolumeStructureDesc_Base*)malloc(sizeof(struct GenericVolumeStructureDesc_Base));
  391. if (NULL == pCurrDescHdr) {
  392. tr_printf(("FATAL: ISO9660_initialize() Failed [1]: Low system resourcesn"));
  393. return FALSE;
  394. }
  396. // Allocate space for a Partial Volume Descriptor (will be used for Primary or Supplemantary 
  397. // Volume descriptors).
  398. pPartialVolDesc = (struct VolumeDesc_Partial*)malloc(sizeof(struct VolumeDesc_Partial));
  399. if (NULL == pPartialVolDesc) {
  400. tr_printf(("FATAL: ISO9660_initialize() Failed [2]: Low system resourcesn"));
  401. free(pCurrDescHdr);
  402. return FALSE;
  403. }
  405. g_pISO9660Info->bIsUsingUnicode= FALSE;
  407. // Start searching for the Primary or Supplementary Volume Descriptor, while verifying the 
  408. // integrity of the Volume-Recognition Sequence.
  409. dwCurrDescLBN= (g_pISO9660Info->dwSessionStartLBN + VOLUME_RECOGNITION_SEQUENCE_START_LSN);
  411. while (TRUE) 
  412. {
  413. // Read the first few bytes in order to determine the type of the descriptor
  414. if (! AuxCache_GetBytes(dwCurrDescLBN, 0, sizeof(struct GenericVolumeStructureDesc_Base),
  415.    (BYTE *)pCurrDescHdr)) 
  416. {
  417. dbg_printf(("WARNING: ISO9660_initialize() Failed [3]n"));
  418. break;
  419. }
  421. // Check for a Primary-Volume
  422. if (DESC_TYPE_PRIMARY_VOLUME == pCurrDescHdr->uVolumeDescType) 
  423. {
  424. // Read the essential part of the descriptor
  425. if (! AuxCache_GetBytes(dwCurrDescLBN, PARTIAL_VOLUME_DESC_OFFSET, 
  426.    sizeof(struct VolumeDesc_Partial), (BYTE *)pPartialVolDesc))
  427. {
  428. dbg_printf(("WARNING: ISO9660_initialize() Failed [4]n"));
  429. break;
  430. }
  432. #ifdef HW_POWER_ON_RESUME
  433. {
  434. // Calculate checksum here for poweron resume
  435. // Calculating checksum using simple mechanism of adding each byte of the 
  436.           int i;
  437. BYTE * pTmp = 0;
  439. pTmp = (BYTE*)&pPartialVolDesc->dwVolumeSpaceSize;
  440. NewChecksum = 0;
  442. for (i=0;i<32;i++)
  443. NewChecksum+=pPartialVolDesc->sVolumeID[i];
  445. for (i=0;i<8;i++)
  446. NewChecksum += *pTmp++; //Add 8 bytes of volume space size.
  447. }
  448. #endif//HW_POWER_ON_RESUME
  450. // Collect information of the Root-Directory
  451. g_pISO9660Info->dwRootDirICB= BB_DWORD(pPartialVolDesc->rdrRootDir.dwExtentLocation);
  452. bRootDirEstablished= TRUE;
  454. dbg_printf(("Primary Volume Descriptor found.n"));
  456. // Copy the Primary-Volume Name
  457. pPartialVolDesc->sVolumeID[SHORT_ID_LENGTH]= 0;
  458. sc_SetBytes(SC_VOLUME_ID_ADDR, 0, FILESYSTEM_MAX_VOLUME_NAME*sizeof(WCHAR), pPartialVolDesc->sVolumeID);
  461. dbg_printf(("Volume-ID: '%s'n", (LPCSTR)pPartialVolDesc->sVolumeID));
  463. // Build the Directory-Hierarchy Tree, based on the M-Type Path-Table or the L-Type Path-Table
  464. #ifdef MOTOROLA
  465. if (! _buildDirectoryTree(pPartialVolDesc->dwLoactionOfMPathTable, BB_DWORD(pPartialVolDesc->dwPathTableSize))) {
  466. dbg_printf(("Failed to build the Directory-Hierarchy Tree.n"));
  467. }
  468. #else
  469. if (! _buildDirectoryTree(pPartialVolDesc->dwLocationOfLPathTable, BB_DWORD(pPartialVolDesc->dwPathTableSize))) {
  470. dbg_printf(("Failed to build the Directory-Hierarchy Tree.n"));
  471. }
  472. #endif //MOTOROLA
  473. dwCurrDescLBN++; // Move to the next Descriptor
  474. continue;
  475. }
  477. // Check for a Supplementary Volume
  478. if (DESC_TYPE_SUPPL_VOLUME == pCurrDescHdr->uVolumeDescType) 
  479. {
  480. if (! AuxCache_GetBytes(dwCurrDescLBN, PARTIAL_VOLUME_DESC_OFFSET, 
  481.    sizeof(struct VolumeDesc_Partial), (BYTE *)pPartialVolDesc))
  482. {
  483. dbg_printf(("WARNING: ISO9660_initialize() Failed [5]n"));
  484. break;
  485. }
  487. // Check if the Supplementary Volume describes a Joliet extension to ISO-9660
  488. if ((0x25 == pPartialVolDesc->aEscapeSequences[0]) && 
  489. (0x2F == pPartialVolDesc->aEscapeSequences[1])) 
  490. {
  491. BYTE ucJolietLevel= pPartialVolDesc->aEscapeSequences[2];
  493. if ((0x40 == ucJolietLevel) || (0x43 == ucJolietLevel) || (0x45 == ucJolietLevel)) {
  494. dbg_printf(("Joliet Extension Level-%d detected.n",
  495.    ((0x40 == ucJolietLevel) ? 1 : ((0x43 == ucJolietLevel) ? 2 : 3))));
  497. // Collect information of the Supplementary Root-Directory
  498. if (bLongFilenameSupport)
  499. {
  500. g_pISO9660Info->dwRootDirICB= BB_DWORD(pPartialVolDesc->rdrRootDir.dwExtentLocation);
  501. g_pISO9660Info->bIsUsingUnicode= TRUE;
  502. bRootDirEstablished= TRUE;
  504. // Collect the Directory-Hierarchy Tree, based on the M/L-Type Path-Table
  505. #ifdef MOTOROLA
  506. if (! _buildDirectoryTree(pPartialVolDesc->dwLoactionOfMPathTable, BB_DWORD(pPartialVolDesc->dwPathTableSize))) {
  507. dbg_printf(("Failed to build the Directory-Hierarchy Tree.n"));
  508. }
  509. #else
  510. if (! _buildDirectoryTree(pPartialVolDesc->dwLocationOfLPathTable, BB_DWORD(pPartialVolDesc->dwPathTableSize))) {
  511. dbg_printf(("Failed to build the Directory-Hierarchy Tree.n"));
  512. }
  513. #endif //MOTOROLA
  514. }
  515. }
  516. else {
  517. dbg_printf(("Unexpected Joliet Extension Level found. Ignored.n"));
  518. }
  519. }
  521. dwCurrDescLBN++; // Skip to the next Descriptor
  522. continue;
  523. }
  525. // Check for a Terminator
  526. if (( (DESC_TYPE_BOOT != pCurrDescHdr->uVolumeDescType) &&
  527.   (DESC_TYPE_PRIMARY_VOLUME != pCurrDescHdr->uVolumeDescType) &&
  528.   (DESC_TYPE_SUPPL_VOLUME != pCurrDescHdr->uVolumeDescType) &&
  529.   (DESC_TYPE_VOLUME_PARTITION != pCurrDescHdr->uVolumeDescType) ) ||
  530. ((dwCurrDescLBN - g_pISO9660Info->dwSessionStartLBN) >= 20))
  531. {
  532. dbg_printf(("Volume-Recognition-Sequence Termination found.n"));
  533. break;
  534. }
  536. #ifdef _DEBUG
  537. // Check for a Boot-Record
  538. if (DESC_TYPE_BOOT == pCurrDescHdr->uVolumeDescType) {
  539. dbg_printf(("Boot Descriptor found.n"));
  540. dwCurrDescLBN++; // Skip to the next Descriptor
  541. continue;
  542. }
  544. // Check for a Volume-Partition
  545. if (DESC_TYPE_VOLUME_PARTITION == pCurrDescHdr->uVolumeDescType) {
  546. dbg_printf(("Volume-Partition Descriptor found.n"));
  547. dwCurrDescLBN++; // Skip to the next Descriptor
  548. continue;
  549. }
  550. #endif //_DEBUG
  552. // Any other type -- skip
  553. dbg_printf(("Skipping Volume-Descriptor of type: 0x%02x.n", pCurrDescHdr->uVolumeDescType));
  555. dwCurrDescLBN++;
  556. } //endof while()
  558. // When this point is reached, the entire File-Set Descriptor Sequence has been
  559. // scanned, and the Root-Directory's ICB possibly established.
  560. free(pCurrDescHdr);
  561. free(pPartialVolDesc);
  563. // Set the Current Directory to the Root-Directory, if it was established.
  564. if (bRootDirEstablished)
  565. g_pISO9660Info->dwCurrDirICB= g_pISO9660Info->dwRootDirICB;
  567. // Currently, no CWD is stored
  568. g_pISO9660Info->bCWDStored= FALSE;
  570. return bRootDirEstablished;
  571. }
  574. /////////////////////////////////////////////////////////////////////////////
  575. // Navigation
  577. /////////////////////////////////////////////////////////////////////////////
  578. // ISO9660_goToRootDir()
  579. //
  580. // Description: Sets the current working-directory to the Root directory.
  581. //
  582. // Input: None
  583. // Output: None
  584. // In/Out: None
  585. // Return: TRUE if the current working-directory was successfully switched
  586. // to the Root; FALSE otherwise.
  587. //
  588. // Remarks: None
  590. BOOL ISO9660_goToRootDir(void)
  591. {
  592. dbg_printf(("ISO9660_goToRootDir() calling.n"));
  594. g_pISO9660Info->dwCurrDirICB= g_pISO9660Info->dwRootDirICB;
  596. return TRUE;
  597. }
  600. DWORD ISO9660_GetcurrentDirICB(void)
  601. {
  602. return g_pISO9660Info->dwCurrDirICB;
  603. }
  605. void ISO9660_SetCurrentDirICB(DWORD CurrentDirICB)
  606. {
  607. g_pISO9660Info->dwCurrDirICB = CurrentDirICB;
  608. }
  611. /////////////////////////////////////////////////////////////////////////////
  612. // ISO9660_changeDir()
  613. //
  614. // Description: Changes the current working-directory to a desired directory.
  615. //
  616. // Input: i_pszDestDirName - A string holding the name of the destination
  617. //    Directory.
  618. // Output: None
  619. // In/Out: None
  620. // Return: TRUE if the current working-directory was successfully changed;
  621. // FALSE otherwise.
  622. //
  623. // Remarks:
  624. // 1. The destination Directory must be a direct descendant of the current
  625. //    working-directory.
  626. // 2. Only a single directory may be specified inside i_pszDestDirName.
  627. //    I.e., i_pszDestDirName is treated as a name of a single directory
  628. //    (directory hierarchy cannot be specified).
  630. BOOL ISO9660_changeDir(LPCWSTR i_pszDestDirName)
  631. {
  632. UINT16 hFileRecFind;
  633. struct DirFileRecord *pDestDirRec;
  635. dbg_printf(("ISO9660_changeDir() calling.n"));
  637. // Try to locate a Directory/File Record corresponding to the required Directory
  638. hFileRecFind= _findFirstFileRecord(i_pszDestDirName, FILE_FLAGS_DIRECTORY, 
  639.    FILE_FLAGS_DIRECTORY, &pDestDirRec);
  641. if (NULL == hFileRecFind)
  642. return FALSE;
  644. // The appropriate Directory was found: record the location of its ICB for
  645. // future use.
  646. g_pISO9660Info->dwCurrDirICB= BB_DWORD(pDestDirRec->dwExtentLocation);
  648. // Free the file record and terminate the search
  649. free(pDestDirRec);
  651. _findClose(hFileRecFind);
  653. return TRUE;
  654. }
  657. /////////////////////////////////////////////////////////////////////////////
  658. // ISO9660_goUp()
  659. //
  660. // Description: Moves up one level in the Directories hierarchy.
  661. //
  662. // Input: None
  663. // Output: None
  664. // In/Out: None
  665. // Return: TRUE if the current working-directory was successfully changed;
  666. // FALSE otherwise.
  667. //
  668. // Remarks:
  669. // This method changes the current working-directory to its direct parent
  670. // in the Directories hierarchy. If the current working-directory is already
  671. // the Root when this method is called, no change is made.
  673. BOOL ISO9660_goUp(void)
  674. {
  675. WCHAR szParentDirname[2];
  676. UINT16 hFileRecFind;
  677. struct DirFileRecord *pParentDirRec;
  679. dbg_printf(("ISO9660_goUp() calling.n"));
  681. // Prohibit climbing up from the Root Directory
  682. if (g_pISO9660Info->dwRootDirICB == g_pISO9660Info->dwCurrDirICB)
  683. return TRUE;
  685. // Locate the Parent-Directory of the Current Directory
  686. _str2wcs(FILE_FILEID_PARENT, szParentDirname, sizeof(szParentDirname));
  688. hFileRecFind= _findFirstFileRecord((LPCWSTR)szParentDirname, FILE_FLAGS_DIRECTORY, 
  689.    FILE_FLAGS_DIRECTORY, &pParentDirRec);
  691. if (NULL == hFileRecFind)
  692. return FALSE;
  694. // Record the location of the Parent-Directory
  695. g_pISO9660Info->dwCurrDirICB= BB_DWORD(pParentDirRec->dwExtentLocation);
  697. // Free the file record and terminate the search
  698. free(pParentDirRec);
  700. _findClose(hFileRecFind);
  702. return TRUE;
  703. }
  706. /////////////////////////////////////////////////////////////////////////////
  707. // ISO9660_storeWorkingDirectory()
  708. //
  709. // Description: Stores the position of the Current Working Directory.
  710. //
  711. // Input: None
  712. // Output: None
  713. // In/Out: None
  714. // Return: None
  715. //
  716. // Remarks:
  717. // The position of the Current Directory is unconditionally stored, and may
  718. // be later recalled via ISO0660_recallWorkingDirectory().
  719. // This method is useful for peeking into different directories, and then
  720. // restoring the original Working-Directory.
  722. void ISO9660_storeWorkingDirectory(void)
  723. {
  724. // Store the Working-Directory and set the Storage indicator
  725. g_pISO9660Info->dwCWDStorage= g_pISO9660Info->dwCurrDirICB;
  726. g_pISO9660Info->bCWDStored= TRUE;
  728. return;
  729. }
  732. /////////////////////////////////////////////////////////////////////////////
  733. // ISO0660_recallWorkingDirectory()
  734. //
  735. // Description: Recalls the position of the Current Working Directory.
  736. //
  737. // Input: None
  738. // Output: None
  739. // In/Out: None
  740. // Return: None
  741. //
  742. // Remarks:
  743. // The position of the Current Directory is stored only if it has been
  744. // previously stored via ISO9660_storeWorkingDirectory().
  746. void ISO9660_recallWorkingDirectory(void)
  747. {
  748. // Restore the Working-Directory
  749. if (g_pISO9660Info->bCWDStored)
  750. g_pISO9660Info->dwCurrDirICB= g_pISO9660Info->dwCWDStorage;
  752. // Clear the Storage indicator
  753. g_pISO9660Info->bCWDStored= FALSE;
  755. return;
  756. }
  759. /////////////////////////////////////////////////////////////////////////////
  760. // Queries
  762. /////////////////////////////////////////////////////////////////////////////
  763. // ISO9660_getVolumeName()
  764. //
  765. // Description: Retrieves the Name of the Primary-Volume on the Medium.
  766. //
  767. // Input: None
  768. // Output: None
  769. // In/Out: None
  770. // Return: A pointer to a constant String, containing the Volume-Name.
  771. //
  772. // Remarks:
  773. // The returned String must not be modified or freed by the caller.
  775. void ISO9660_getVolumeName(LPCWSTR volumeName)
  776. {
  777. sc_GetBytes(SC_VOLUME_ID_ADDR, 0, FILESYSTEM_MAX_VOLUME_NAME*sizeof(WCHAR), (BYTE*)volumeName);
  778. return;
  779. }
  782. /////////////////////////////////////////////////////////////////////////////
  783. // ISO9660_fileExists()
  784. //
  785. // Description: Tests whether a certain file exists in the current working-
  786. // directory, or not.
  787. //
  788. // Input: i_pszFilename - A string holding the name of the File to test.
  789. // Output: None
  790. // In/Out: None
  791. // Return: TRUE if the requested File exists in the current working-directory;
  792. // FALSE otherwise.
  793. //
  794. // Remarks:
  795. // A return value of FALSE may also indicate that the currently-selected
  796. // File-System is unknown. The user is responsible for verifying correctness
  797. // by assuring that the File-System type was selected and the File-System 
  798. // successfully initialized.
  800. BOOL ISO9660_fileExists(LPCWSTR i_pszFilename)
  801. {
  802. UINT16 hFileRecFind;
  803. struct DirFileRecord *pDestDirRec;
  805. dbg_printf(("ISO9660_fileExists() calling.n"));
  807. // Try to locate a File-ID Descriptor corresponding to the required File; Specify
  808. // that the required file must be non-directory, not hidden, not a Parent, and undeleted.
  809. hFileRecFind= _findFirstFileRecord(i_pszFilename, 
  810.    (FILE_FLAGS_DIRECTORY | FILE_FLAGS_HIDDEN),
  811.    0x0, &pDestDirRec);
  813. if (NULL == hFileRecFind)
  814. return FALSE;
  816. // Free the file record and terminate the search
  817. free(pDestDirRec);
  819. _findClose(hFileRecFind);
  821. return TRUE;
  822. }
  825. /////////////////////////////////////////////////////////////////////////////
  826. // ISO9660_fileLocation()
  827. //
  828. // Description: Retrieves the location of a certain file (its start address).
  829. //
  830. // Input: i_pszFilename - A string holding the name of the requested File.
  831. // Output: o_pFileLocation - Points to a DWORD to receive the File's start
  832. //   address.
  833. // In/Out: None
  834. // Return: TRUE if the requested File was located and its address retrieved;
  835. // FALSE otherwise.
  836. //
  837. // Remarks:
  838. // 1. A return value of FALSE indicates that the requested File does not
  839. //    exist in the current working-directory.
  840. // 2. The File's start-address is given in terms of the Medium's native
  841. //    addressing system. E.g., for Optical-Storage Media, the returned
  842. //    address is expressed in terms of Logical-Block-Number (LBN).
  844. BOOL ISO9660_fileLocation(LPCWSTR i_pszFilename, DWORD *o_pFileLocation)
  845. {
  846. UINT16 hFileRecFind;
  847. struct DirFileRecord *pFileRec;
  849. dbg_printf(("ISO9660_fileLocation() calling.n"));
  851. // Try to locate a Directory/File Record corresponding to the required File; Specify
  852. // that the required file must be non-directory and not hidden.
  853. hFileRecFind= _findFirstFileRecord(i_pszFilename,
  854.    (FILE_FLAGS_DIRECTORY | FILE_FLAGS_HIDDEN),
  855.    0x0, &pFileRec);
  856. if (NULL == hFileRecFind)
  857. return FALSE;
  859. *o_pFileLocation= BB_DWORD(pFileRec->dwExtentLocation);
  861. // Free the file record and terminate the search
  862. free(pFileRec);
  864. _findClose(hFileRecFind);
  866. return TRUE;
  867. }
  870. /////////////////////////////////////////////////////////////////////////////
  871. // ISO9660_findFirstFile()
  872. //
  873. // Description: Initiates a search for a certain file, or collection of
  874. // files.
  875. //
  876. // Input: i_pszFilename - A string holding the name of the requested File,
  877. // or a pattern to match.
  878. // Output: o_pFindData - Points to a FindData structure, to receive the File's
  879. //   details upon successful completion of the search.
  880. // In/Out: None
  881. // Return: A UINT16 which serves as the Handle to this search. This value
  882. // must be saved for later use with other find-related methods.
  883. // NULL is returned if the search fails.
  884. //
  885. // Remarks:
  886. // 1. The user must save the returned Handle in order to supply it to future
  887. //    calls to any of the other find-related methods.
  888. // 2. If the returned Handle is NULL, then no File matching the supplied
  889. //    name/pattern could be located in the current working-directory.
  890. // 3. The search is limited to the current working-directory only.
  891. // 4. The following patterns may be supplied in i_pszFilename:
  892. // - An empty string ("") - matches any File/Sub-Directory;
  893. // - Some non-empty string: treated as a Filename/Sub-Directory prefix.
  894. //   For a string of length N, only the first N characters are used
  895. //   for matching.
  896. //   For example: supplying a value of i_pszFilename="A" would retrieve
  897. //   the first File/Sub-Directory whose name begins with a Captial 'A',
  898. //   if such a File/Sub-Directory exists.
  899. // 5. The search is Case-Sensitive.
  900. // 6. ISO9660_findClose() must be called when no additional searches are needed.
  902. UINT16 ISO9660_findFirstFile(LPCWSTR i_pszPattern, FindData *o_pFindData)
  903. {
  904. UINT16 hFileRecFind;
  905. struct DirFileRecord *pFileRec;
  907. dbg_printf(("ISO9660_findFirstFile() calling.n"));
  909. // Try to locate a Directory/File Record corresponding to the required File.
  910. // There are no restrictions over the file's Attributes (find any File/Directory).
  911. hFileRecFind= _findFirstFileRecord(i_pszPattern, 0x0, 0x0, &pFileRec);
  913. if (NULL == hFileRecFind)
  914. return NULL;
  916. // Acquire the found item's Attributes
  917. _getFileAttributes((const struct DirFileRecord *)pFileRec, o_pFindData);
  919. // Free the found record
  920.    free(pFileRec);
  922. return hFileRecFind;
  923. }
  926. /////////////////////////////////////////////////////////////////////////////
  927. // ISO9660_findNextFile()
  928. //
  929. // Description: Continues a search that was previously initiated using a call
  930. // to ISO9660_findFirstFile().
  931. //
  932. // Input: hFindFile - A Handle to a file-search, that was returned from 
  933. // a previous call to ISO9660_findFirstFile().
  934. // Output: o_pFindData - Points to a FindData structure, to receive the File's
  935. //   details upon successful completion of the search.
  936. // In/Out: None
  937. // Return: TRUE if the search succeeded, and an additional File matching
  938. // the Filename/pattern was found. In this case, the supplied
  939. // o_pFindData contains updated information of the found File.
  940. // FALSE is returned if no more Files/Sub-Directories matching the
  941. // supplied Filename/pattern could be found. In this case, the
  942. // supplied o_pFindData is invalid.
  943. //
  944. // Remarks:
  945. // 1. This method continues a previous search from the point it left off.
  946. // 2. The search relates to the Directory that was the current working-
  947. //    directory at the time the search was initiated via ISO9660_findFirstFile().
  948. // 3. The search uses the same Filename/pattern as was originally supplied
  949. //    to ISO9660_findFirstFile().
  950. // 4. ISO9660_findClose() must be called when no additional searches are needed.
  952. BOOL ISO9660_findNextFile(UINT16 hFindFile, FindData *o_pFindData)
  953. {
  954. struct DirFileRecord *pFileRec;
  956. dbg_printf(("ISO9660_findNextFile() calling.n"));
  958. // Continue the Search
  959. if (! _findNextFileRecord((WORD)hFindFile, &pFileRec))
  960. return FALSE;
  962. // Acquire the found item's Attributes
  963. _getFileAttributes((const struct DirFileRecord *)pFileRec, o_pFindData);
  965. // Free the found record
  966. free(pFileRec);
  968. return TRUE;
  969. }
  972. /////////////////////////////////////////////////////////////////////////////
  973. // ISO9660_findClose()
  974. //
  975. // Description: Terminates a file-search.
  976. //
  977. // Input: hFindFile - A Handle to a file-search, that was returned from 
  978. // a previous call to ISO9660_findFirstFile().
  979. // Output: None
  980. // In/Out: None
  981. // Return: TRUE if the search was successfully terminated; FALSE othewise.
  982. //
  983. // Remarks:
  984. // Any search that is initiated via ISO9660_findFirstFile() must be terminated
  985. // using a call to this method, in order to allow for proper release of
  986. // resources that were allocated for that search.
  988. BOOL ISO9660_findClose(UINT16 hFileFind)
  989. {
  990. dbg_printf(("ISO9660_findClose() calling.n"));
  992. return _findClose((WORD)hFileFind);
  993. }
  994. /////////////////////////////////////////////////////////////////////////////
  995. // ISO9660_getFilesFirst()
  996. //
  997. // Description: Get all files in the indicated directory.
  998. //
  999. // Input: LPCWSTR i_pszFilename: The directory name which want to get from
  1000. // UINT16 uGetFileCount: The files count which want get
  1001. //
  1002. // Output: UINT16 *o_uGetFileNum: The files count which has been get
  1003. // FindData *o_pGetData: Points to a FindData structure, to receive the File's
  1004. //   details upon successful completion of the search.
  1005. //
  1006. // In/Out: None
  1007. // Return: A UINT16, which is the ID of the search, and should be passed
  1008. // to future calls to any of the search-related methods.
  1009. // NULL is returned if no File matching the requested criteria could
  1010. // be found.
  1011. //
  1012. // Remarks:
  1013. // Any search that is initiated via ISO9660_getFilesFirst() must be terminated
  1014. // using a call to this method, in order to allow for proper release of
  1015. // resources that were allocated for that search. 
  1016. //  If the call to ISO9660_getFilesFirst() returned NULL, it is prohibited 
  1017. // to call ISO9660_getFilesClose().
  1018. // If you want to get current directory, you can give the i_pszFilename with L""
  1019. // If you want to get parent directory, you can give the i_pszFilename with L"1"
  1020. // If you want to get root directory, you can give the i_pszFilename with L"\"
  1021. UINT16 ISO9660_getFilesFirst(LPCWSTR i_pszFilename, UINT16 uGetFileCount, UINT16 *o_uGetFileNum, FindData *o_pGetData)
  1022. {
  1023. BOOL bSuccess;
  1024. UINT16 hFileRecFind;
  1025. struct DirFileRecord *pFileRec;
  1026. DirectorySearchInfo dsiInfo;
  1027. UINT16 uSearchID;
  1029. dbg_printf(("ISO9660_getFilesFirst() calling.n"));
  1031. if( (i_pszFilename[0]==(WCHAR)'\' || i_pszFilename[0]==(WCHAR)'')
  1032. && i_pszFilename[1]==0)
  1033. {
  1034. if(i_pszFilename[0]==(WCHAR)'\' && i_pszFilename[1]==0)
  1035. dsiInfo.dwDirICB=g_pISO9660Info->dwRootDirICB;
  1036. else
  1037. dsiInfo.dwDirICB=g_pISO9660Info->dwCurrDirICB;
  1038. pFileRec=(struct DirFileRecord*)malloc(sizeof(struct DirFileRecord)+1);
  1039. if (NULL == pFileRec)
  1040. {
  1041. dbg_printf(("WARNING: ISO9660_getFilesFirst() Failed [1]:n"));
  1042. *o_uGetFileNum=0;
  1043. return NULL;
  1044. }
  1046. if(!AuxCache_GetBytes(dsiInfo.dwDirICB, 0, sizeof(struct DirFileRecord)+1, (BYTE*)pFileRec))
  1047. {
  1048. dbg_printf(("WARNING: ISO9660_getFilesFirst() Failed [2]:n"));
  1049. free(pFileRec);
  1050. *o_uGetFileNum=0;
  1051. return NULL;
  1052. }
  1053. if(1 == pFileRec->cbLengthOfFileID && 0 == pFileRec->sFileID[0])
  1054. dsiInfo.dwDirectorySize = BB_DWORD( pFileRec->dwDataLength );
  1055. else
  1056. {
  1057. dbg_printf(("WARNING: ISO9660_getFilesFirst() Failed [3]: Directory record was error.n"));
  1058. free(pFileRec);
  1059. *o_uGetFileNum=0;
  1060. return NULL;
  1061. }
  1062. free(pFileRec);
  1064. }
  1065. else
  1066. {
  1067. hFileRecFind= _findFirstFileRecord(i_pszFilename,FILE_FLAGS_DIRECTORY,
  1068.    FILE_FLAGS_DIRECTORY, &pFileRec);
  1069. if (NULL == hFileRecFind)
  1070. {
  1071. dbg_printf(("WARNING: ISO9660_getFilesFirst() Failed [4]: Directory no found.n"));
  1072. *o_uGetFileNum=0;
  1073. return NULL;
  1074. }
  1077. dsiInfo.dwDirICB = BB_DWORD( pFileRec->dwExtentLocation );
  1078. dsiInfo.dwDirectorySize = BB_DWORD( pFileRec->dwDataLength );
  1080. // Free the file record and terminate the search
  1081. free(pFileRec);
  1082. _findClose(hFileRecFind);
  1083. }
  1085. dsiInfo.uDirNumber = 0;
  1086. dsiInfo.pszFileID = NULL;
  1087. dsiInfo.uFileFlagsMask = 0;
  1088. dsiInfo.uFileFlags = 0;
  1089. dsiInfo.hDirFileRecordList = 0;
  1090. dsiInfo.cbRecListOffset = 0;
  1091. dsiInfo.cbCurrRecOffset = 0;
  1093. // Allocate a Search-Info
  1094. uSearchID= _FileSys_allocateSearchInfo();
  1095. if (NULL == uSearchID) {
  1096. dbg_printf(("WARNING: ISO9660_getFilesFirst() Failed [5]: No available Search-Info IDn"));
  1097. *o_uGetFileNum=0;
  1098. return NULL;
  1099. }
  1103. // Register the Directory-Search Info in the Search-Info Pool
  1104. bSuccess= _FileSys_setSearchInfo(uSearchID, (const BYTE*)&dsiInfo);
  1105. if (! bSuccess) {
  1106. dbg_printf(("FATAL: ISO9660_getFilesFirst() Failed [6]: Cannot register new Searchn"));
  1107. }
  1109. // Now, the information in dsiInfo is stable and complete: perform the search
  1110. if (bSuccess)
  1111. if(!(*o_uGetFileNum = ISO9660_getFilesNext(uSearchID, uGetFileCount, o_pGetData)))
  1112. {
  1113. dbg_printf(("WARNING: ISO9660_getFilesFirst() Failed [7]: Could not find a matchn"));
  1114. bSuccess= FALSE;
  1115. }
  1117. if (! bSuccess) {
  1118. _FileSys_freeSearchInfo(uSearchID);
  1119. *o_uGetFileNum=0;
  1120. return NULL;
  1121. }
  1123. return uSearchID;
  1124. }
  1126. /////////////////////////////////////////////////////////////////////////////
  1127. // ISO9660_getFilesNext()
  1128. //
  1129. // Description: Continues to get the files that was previously initiated using a call
  1130. // to ISO9660_getFilesFirst().
  1131. //
  1132. // Input: UINT16 hFindFile: A Handle to a file-search, that was returned from 
  1133. // a previous call to ISO9660_getFilesFirst().
  1134. // UINT16 uGetFileCount: 
  1135. // Output: FindData *o_pGetData: Points to a FindData structure, to receive the File's
  1136. //   details upon successful completion of the search.
  1137. // In/Out: None
  1138. // Return: >0 if the search succeeded, and return the get files count.
  1139. // and the o_pGetData is valid.
  1140. // 0 is returned if no more Files could be get. In this case, the
  1141. // supplied o_pGetData is invalid.
  1142. //
  1143. // Remarks:
  1144. // 1. This method continues a previous search from the point it left off.
  1145. // 2. The search relates to the Directory that was the current working-
  1146. //    directory at the time the search was initiated via ISO9660_getFilesFirst().
  1147. // 3. The search uses the same Filename/pattern as was originally supplied
  1148. //    to ISO9660_findFirstFile().
  1149. // 4. ISO9660_findClose() must be called when no additional searches are needed.
  1151. UINT16 ISO9660_getFilesNext(UINT16 uSearchID,UINT16 uGetFileCount, FindData *o_pGetData)
  1152. {
  1153. UINT16 uGetNum=0;
  1154. struct DirFileRecord *pRec;
  1155. DirectorySearchInfo dsiInfo;
  1156. LPWSTR pszSeparator2;
  1158. dbg_printf(("ISO9660_getFilesNext() calling.n"));
  1160. // Retrieve the Directory-Search Info from the Search-Pool
  1161. if ((NULL == uSearchID) ||
  1162. ! _FileSys_getSearchInfo(uSearchID, (BYTE*)&dsiInfo))
  1163. {
  1164. dbg_printf(("WARNING: ISO9660_getFilesNext() Failed [1]: Directory no found.n"));
  1165. return FALSE;
  1166. }
  1168. if(dsiInfo.cbRecListOffset >= dsiInfo.dwDirectorySize)
  1169. {
  1170. dbg_printf(("WARNING: ISO9660_getFilesNext() Failed [2]: This directory has already get all files.n"));
  1171. return 0;
  1172. }
  1174. pRec= (struct DirFileRecord *)malloc(MAX_FILEREC_SIZE);
  1175. if (NULL == pRec) {
  1176. tr_printf(("FATAL: ISO9660_getFilesNext() Failed [3]: Low system resourcesn"));
  1177. return NULL;
  1178. }
  1180. for(uGetNum=0;( uGetNum<uGetFileCount ) && ( dsiInfo.cbRecListOffset < dsiInfo.dwDirectorySize );
  1181. uGetNum++)
  1182. {
  1184. if (! AuxCache_GetBytes(dsiInfo.dwDirICB+dsiInfo.cbRecListOffset/2048, dsiInfo.cbRecListOffset%2048, 
  1185. MAX_FILEREC_SIZE, (BYTE*)pRec))
  1186. {
  1187. dbg_printf(("WARNING: ISO9660_getFilesNext() Failed [4]n"));
  1188. free(pRec);
  1189. return NULL;
  1190. }
  1191. if( 0 == pRec->cbLengthOfDirRecord )
  1192. {
  1193. dsiInfo.cbRecListOffset = (dsiInfo.cbRecListOffset/2048 + 1) * 2048;
  1194. uGetNum--;
  1195. continue;
  1196. }
  1197. else
  1198. dsiInfo.cbRecListOffset += pRec->cbLengthOfDirRecord;
  1200. _getFileAttributes(pRec,&(o_pGetData[uGetNum]));
  1202. }
  1203. free(pRec);
  1205. // Update the Directory-Search Info in the Search-Pool
  1206. if (! _FileSys_setSearchInfo(uSearchID, (const BYTE*)&dsiInfo)) {
  1207. dbg_printf(("WARNING: ISO9660_getFilesNext() Failed [5]n"));
  1208. }
  1210. return uGetNum;
  1211. }
  1212. /////////////////////////////////////////////////////////////////////////////
  1213. // ISO9660_getFilesClose()
  1214. //
  1215. // Description: Terminates a file-get.
  1216. //
  1217. // Input: hFindFile - A Handle to a file-search, that was returned from 
  1218. // a previous call to ISO9660_getFilesFirst().
  1219. // Output: None
  1220. // In/Out: None
  1221. // Return: TRUE if the search was successfully terminated; FALSE othewise.
  1222. //
  1223. // Remarks:
  1224. // Any search that is initiated via ISO9660_getFilesFirst() must be terminated
  1225. // using a call to this method, in order to allow for proper release of
  1226. // resources that were allocated for that search.
  1228. BOOL ISO9660_getFilesClose(UINT16 uSearchID)
  1229. {
  1230. DirectorySearchInfo dsiInfo;
  1232. dbg_printf(("ISO9660_getFilesClose() calling.n"));
  1234. // Retrieve the Directory-Search Info from the Search-Pool
  1235. if ((NULL == uSearchID) ||
  1236. ! _FileSys_getSearchInfo(uSearchID, (BYTE*)&dsiInfo))
  1237. {
  1238. return FALSE;
  1239. }
  1241. _FileSys_freeSearchInfo(uSearchID);
  1242. return TRUE;
  1243. }
  1244. /////////////////////////////////////////////////////////////////////////////
  1245. // ISO9660_checkValid()
  1246. //
  1247. // Description: Check whether the ISO9660 file system was valid or not
  1248. //
  1249. // Input: None
  1250. // Output: None
  1251. // In/Out: None
  1252. // Return: TRUE if the ISO9660 File-System was valid; FALSE otherwise.
  1253. //
  1254. // Remarks:
  1255. // 1. Check whether the ISO9660 path table was empty or not
  1256. //
  1257. BOOL ISO9660_checkValid()
  1258. {
  1259. BOOL iso9660_valid=TRUE;
  1260. DWORD dwCurrDescLBN;
  1261. DWORD dwRootDirICB,dwPathTableICB,dwPathTableSize;
  1262. DWORD dwTemp;
  1263. DWORD dwOffset=0;
  1264. struct PathTableRecord *pCurrRec;
  1265. struct GenericVolumeStructureDesc_Base *pCurrDescHdr;
  1266. struct VolumeDesc_Partial *pPartialVolDesc;
  1268. dbg_printf(("ISO9660_checkValid() calling.n"));
  1270. // Allocate space for a generic Descriptor base
  1271. pCurrDescHdr= (struct GenericVolumeStructureDesc_Base*)malloc(sizeof(struct GenericVolumeStructureDesc_Base));
  1272. if (NULL == pCurrDescHdr) {
  1273. tr_printf(("FATAL: ISO9660_checkValid() Failed [1]: Low system resourcesn"));
  1274. return FALSE;
  1275. }
  1277. // Allocate space for a Partial Volume Descriptor (will be used for Primary or Supplemantary 
  1278. // Volume descriptors).
  1279. pPartialVolDesc = (struct VolumeDesc_Partial*)malloc(sizeof(struct VolumeDesc_Partial));
  1280. if (NULL == pPartialVolDesc) {
  1281. tr_printf(("FATAL: ISO9660_checkValid() Failed [2]: Low system resourcesn"));
  1282. free(pCurrDescHdr);
  1283. return FALSE;
  1284. }
  1286. // Start searching for the Primary or Supplementary Volume Descriptor, while verifying the 
  1287. // integrity of the Volume-Recognition Sequence.
  1288. dwCurrDescLBN= (g_pISO9660Info->dwSessionStartLBN + VOLUME_RECOGNITION_SEQUENCE_START_LSN);
  1290. while (TRUE) 
  1291. {
  1292. // Read the first few bytes in order to determine the type of the descriptor
  1293. if (! AuxCache_GetBytes(dwCurrDescLBN, 0, sizeof(struct GenericVolumeStructureDesc_Base),
  1294.    (BYTE *)pCurrDescHdr)) 
  1295. {
  1296. dbg_printf(("WARNING: ISO9660_checkValid() Failed [3]n"));
  1297. break;
  1298. }
  1300. // Check for a Primary-Volume
  1301. if (DESC_TYPE_PRIMARY_VOLUME == pCurrDescHdr->uVolumeDescType) 
  1302. {
  1303. // Read the essential part of the descriptor
  1304. if (! AuxCache_GetBytes(dwCurrDescLBN, PARTIAL_VOLUME_DESC_OFFSET, 
  1305.    sizeof(struct VolumeDesc_Partial), (BYTE *)pPartialVolDesc))
  1306. {
  1307. dbg_printf(("WARNING: ISO9660_checkValid() Failed [4]n"));
  1308. iso9660_valid=FALSE;
  1309. break;
  1310. }
  1312. // Collect information of the Root-Directory
  1313. dwRootDirICB = BB_DWORD(pPartialVolDesc->rdrRootDir.dwExtentLocation);
  1315. // Build the Directory-Hierarchy Tree, based on the M-Type Path-Table or the L-Type Path-Table
  1316. #ifdef MOTOROLA
  1317. dwPathTableICB = pPartialVolDesc->dwLoactionOfMPathTable;
  1318. #else
  1319. dwPathTableICB = pPartialVolDesc->dwLocationOfLPathTable;
  1320. #endif //MOTOROLA
  1321. dwPathTableSize = BB_DWORD(pPartialVolDesc->dwPathTableSize);
  1323. dwOffset=0;
  1324. while(TRUE)
  1325. {
  1327. // Allocate room for a single Path-Table Record, used for iteration
  1328. pCurrRec= (struct PathTableRecord *)malloc(sizeof(struct PathTableRecord));
  1329. if (NULL == pCurrRec) {
  1330. dbg_printf(("WARNING: ISO9660_checkValid() Failed [5]n"));
  1331. break;
  1332. }
  1333. if (! AuxCache_GetBytes(dwPathTableICB, dwOffset, 
  1334.    sizeof(struct PathTableRecord), (BYTE *)pCurrRec))
  1335. {
  1336. dbg_printf(("WARNING: ISO9660_checkValid() Failed [6]n"));
  1337. free(pCurrRec);
  1338. iso9660_valid=FALSE;
  1339. break;
  1340. }
  1341. if (0 == pCurrRec->cbLengthOfDirID && 0 == pCurrRec->dwExtentLocation && 0 == pCurrRec->uParentDirNumber)
  1342. {
  1343. dbg_printf(("WARNING: ISO9660_checkValid() Failed [7]: The Path Table is Empty!n"));
  1344. free(pCurrRec);
  1346.                if(0 == dwOffset) //jerry cai, only if the first record is invalid, the file system is invalid.
  1347. iso9660_valid=FALSE;
  1349. break;
  1350. }
  1351. dwOffset += (sizeof(struct PathTableRecord) + pCurrRec->cbLengthOfDirID);
  1352. if (pCurrRec->cbLengthOfDirID & 0x1)
  1353. dwOffset++;
  1354. free(pCurrRec);
  1355. if(dwOffset>=dwPathTableSize)
  1356. break;
  1357. }
  1358. dwCurrDescLBN++; // Move to the next Descriptor
  1359. continue;
  1360. }
  1362. // Check for a Terminator
  1363. if (( (DESC_TYPE_BOOT != pCurrDescHdr->uVolumeDescType) &&
  1364.   (DESC_TYPE_PRIMARY_VOLUME != pCurrDescHdr->uVolumeDescType) &&
  1365.   (DESC_TYPE_SUPPL_VOLUME != pCurrDescHdr->uVolumeDescType) &&
  1366.   (DESC_TYPE_VOLUME_PARTITION != pCurrDescHdr->uVolumeDescType) ) ||
  1367. ((dwCurrDescLBN - g_pISO9660Info->dwSessionStartLBN) >= 20))
  1368. {
  1369. dbg_printf(("Volume-Recognition-Sequence Termination found.n"));
  1370. break;
  1371. }
  1373. // Any other type -- skip
  1374. dbg_printf(("Skipping Volume-Descriptor of type: 0x%02x.n", pCurrDescHdr->uVolumeDescType));
  1376. dwCurrDescLBN++;
  1377. } //endof while()
  1379. // When this point is reached, the entire File-Set Descriptor Sequence has been
  1380. // scanned, and the Root-Directory's ICB possibly established.
  1381. free(pCurrDescHdr);
  1382. free(pPartialVolDesc);
  1384. return iso9660_valid;
  1385. }
  1388. /////////////////////////////////////////////////////////////////////////////
  1389. // Private Services
  1391. /////////////////////////////////////////////////////////////////////////////
  1392. // _buildDirectoryTree()
  1393. //
  1394. // Description: Builds an Array describing the Directories, based on the
  1395. // Volume Descriptor's Path-Table.
  1396. //
  1397. // Input: dwPathTableAddress - Holds the starting address of the Path-Table.
  1398. // dwPathTableSize - Holds the size of the Path-Table.
  1399. // Output: None
  1400. // In/Out: None
  1401. // Return: TRUE if the entire Path Table was extracted; FALSE otherwise.
  1402. //
  1403. // Remarks: None
  1405. static BOOL _buildDirectoryTree(DWORD dwPathTableAddress, DWORD dwPathTableSize)
  1406. {
  1407. UINT16 uDirsCnt= 0;
  1408. UINT16 uMaxDirsCnt= (UINT16)(dwPathTableSize / sizeof(struct PathTableRecord));
  1409. DWORD  cbCurrRecOffset= 0;
  1410. BOOL   bSuccess= TRUE;
  1411. struct PathTableRecord *pCurrRec;
  1413. // Allocate room for a single Path-Table Record, used for iteration
  1414. pCurrRec= (struct PathTableRecord *)malloc(sizeof(struct PathTableRecord));
  1415. if (NULL == pCurrRec) {
  1416. dbg_printf(("WARNING: _buildDirectoryTree() Failed [1]n"));
  1417. return FALSE;
  1418. }
  1420. // If the Directories Tree was previously allocated, free that allocation
  1421. if (NULL != g_pISO9660Info->hDirTree)
  1422. Array_destruct(g_pISO9660Info->hDirTree);
  1424. // Allocate the Array that will hold the Directories-Tree
  1425. g_pISO9660Info->hDirTree= Array_construct(uMaxDirsCnt, sizeof(DirectoryNode), NULL);
  1426. if (NULL == g_pISO9660Info->hDirTree) {
  1427. dbg_printf(("WARNING: _buildDirectoryTree() Failed [2]: Low system resources.n"));
  1428. free(pCurrRec);
  1429. return FALSE;
  1430. }
  1432. // Start scanning the Path-Table, adding new Directories Nodes to the array along the way
  1433. while (cbCurrRecOffset < dwPathTableSize) {
  1434. DirectoryNode dnCurrDir;
  1436. // Read Path-Table's base contents
  1437. if (! AuxCache_GetBytes(dwPathTableAddress, cbCurrRecOffset, sizeof(struct PathTableRecord),
  1438.    (BYTE*)pCurrRec)) 
  1439. {
  1440. dbg_printf(("WARNING: _buildDirectoryTree() Failed [3]n"));
  1441. bSuccess= FALSE;
  1442. break;
  1443. }
  1445. // Copy the Parent-Directory Number and the Extent-Location
  1446. dnCurrDir.uParentDirNumber= pCurrRec->uParentDirNumber;
  1447. dnCurrDir.dwDirICB= pCurrRec->dwExtentLocation;
  1449. // Set the new Directory-Node
  1450. if (! Array_setAt(g_pISO9660Info->hDirTree, uDirsCnt++, (BYTE*)&dnCurrDir)) {
  1451. dbg_printf(("WARNING: _buildDirectoryTree() Failed [4]n"));
  1452. bSuccess= FALSE;
  1453. break;
  1454. }
  1456. // Move to the next Record
  1457. cbCurrRecOffset += (sizeof(struct PathTableRecord) + pCurrRec->cbLengthOfDirID);
  1458. if (pCurrRec->cbLengthOfDirID & 0x1)
  1459. cbCurrRecOffset++;
  1460. }
  1462. free(pCurrRec);
  1464. // Get rid of any Extra-Memory, that was not actually used
  1465. Array_freeExtra(g_pISO9660Info->hDirTree);
  1467. if (bSuccess) {
  1468. // Record the total number of Directories
  1469. g_pISO9660Info->uDirectoryCnt= uDirsCnt;
  1470. }
  1471. else {
  1472. Array_destruct(g_pISO9660Info->hDirTree);
  1473. g_pISO9660Info->hDirTree= NULL;
  1474. }
  1476. return TRUE;
  1477. }
  1480. /////////////////////////////////////////////////////////////////////////////
  1481. // _findFirstFileRecord()
  1482. //
  1483. // Description: Initiates a search for the first occurrence of a File-Record
  1484. // structure describing a File/Sub-Directory that meets the 
  1485. // supplied criteria.
  1486. //
  1487. // Input: i_pszFileID - A string holding the requested Filename/pattern.
  1488. // uFileFlagsMask - A Mask to apply to the File's Flags.
  1489. // uFileFlags - A combination of Flags, that should match.
  1490. // Output: o_pFileRecordPtr - Points to a DirFileRecord Pointer, to receive
  1491. //    the File-Record of a matching File/Sub-Directory.
  1492. // In/Out: None
  1493. // Return: A UINT16, which is the ID of the search, and should be passed
  1494. // to future calls to any of the search-related methods.
  1495. // NULL is returned if no File matching the requested criteria could
  1496. // be found.
  1497. //
  1498. // Remarks:
  1499. // 1. The supplied i_pszFileID can be a Filename or a pattern, as described
  1500. //    in the documentation for ISO9660_findFirstFile().
  1501. // 2. uFileFlagsMask is a Mask that is applied to any File-Record whose 
  1502. //    File-ID mathces the supplied Filename/pattern. This mask is applied
  1503. //    to that item's Flags.
  1504. // 3. uFileFlags is compared against the Masked Flags of a matching item.
  1505. //    If there is a match, then the whole item is considered to match the
  1506. //    requested criteria.
  1507. // 4. The returned ID should be saved for future use with search-related
  1508. //    methods.
  1509. // 5. A return value of NULL indicates that no File/Sub-Directory matching
  1510. //    the requested criteria could be found. That might happen also because there
  1511. //    isn't enough memory in the system.
  1512. // 6. The search is limited to the current working-directory.
  1513. // 7. The search is Case-Sensitive.
  1514. // 8. The returned File-Record Pointer should be considered persistant
  1515. //    across calls. The caller has to make sure that o_pFileRecordPtr 
  1516. //    is freed when it is no longer needed.
  1517. // 9. _findClose() must be called when no additional searches are needed.
  1519. static UINT16 _findFirstFileRecord(LPCWSTR i_pszFileID, UINT8 uFileFlagsMask, 
  1520.    UINT8 uFileFlags, 
  1521.    struct DirFileRecord **o_pFileRecordPtr)
  1522. {
  1523. BOOL bSuccess;
  1524. BOOL bWildcardSearch;
  1525. UINT8  cbFirstRecordSize;
  1526. UINT16 uDirFileRecListSizeInCont;
  1527. UINT16 uDirNodePos;
  1528. UINT16 uSearchID;
  1529. DWORD dwCurrDirSize;
  1530. struct ReservedDirRecord *pRec;
  1531. DirectorySearchInfo dsiInfo;
  1533. // Find the size of the first record and the size of the entire directory.
  1534. // Load only the self descriptor and then save both sizes in local variables.
  1535. // After that there is no need to keep the self descriptor anymore.
  1536. pRec= (struct ReservedDirRecord *)malloc(sizeof(struct ReservedDirRecord));
  1537. if (NULL == pRec) {
  1538. tr_printf(("FATAL: _findFirstFileRecord() Failed [1]: Low system resourcesn"));
  1539. return NULL;
  1540. }
  1542. if (! AuxCache_GetBytes(g_pISO9660Info->dwCurrDirICB, 0, sizeof(struct ReservedDirRecord), 
  1543. (BYTE*)pRec))
  1544. {
  1545. dbg_printf(("WARNING: _findFirstFileRecord() Failed [2]n"));
  1546. free(pRec);
  1547. return NULL;
  1548. }
  1550. // Collect the Directory's Size and the size of the first record
  1551. dwCurrDirSize= BB_DWORD(pRec->dwDataLength);
  1552. cbFirstRecordSize= pRec->cbLengthOfDirRecord;
  1553. free(pRec);
  1555. // Check if the Directory has anything in it. I.e., if its size is larger
  1556. // than the length of the first Record (which is the self-descriptor).
  1557. if (dwCurrDirSize == (DWORD)cbFirstRecordSize) {
  1558. // If the Current Directory is Empty, there's no point in continuing the search
  1559. dbg_printf(("Empty Directory found.n"));
  1560. return NULL;
  1561. }
  1563. // Allocate space for the Records List Cache
  1564. uDirFileRecListSizeInCont= CONTAINER_COUNT(DIRECTORY_RECLIST_SZ);
  1565. dsiInfo.hDirFileRecordList= sc_Malloc(uDirFileRecListSizeInCont);
  1566. if (NULL_HANDLE == dsiInfo.hDirFileRecordList) {
  1567. tr_printf(("FATAL: _findFirstFileRecord() Failed [3]: Low system resourcesn"));
  1568. return NULL;
  1569. }
  1571. // Cache the beginning of the Directory's contents (Record-List)
  1572. if (! sc_CopyFromDisc(g_pISO9660Info->dwCurrDirICB, cbFirstRecordSize, DIRECTORY_RECLIST_SZ, 
  1573.   dsiInfo.hDirFileRecordList))
  1574. {
  1575. dbg_printf(("WARNING: _findFirstFileRecord() Failed [4]n"));
  1576. sc_Free(dsiInfo.hDirFileRecordList, uDirFileRecListSizeInCont);
  1577. return NULL;
  1578. }
  1580. // Copy the necessary information into the DirSearchInfo, and initialize it
  1581. dsiInfo.dwDirICB= g_pISO9660Info->dwCurrDirICB;
  1582. dsiInfo.dwDirectorySize= dwCurrDirSize;
  1584. // In case of a Wildcard search, use a static string for File-ID, instead of allocating
  1585. // memory.
  1586. bWildcardSearch= ((0 == i_pszFileID[0]) ? TRUE : FALSE);
  1588. if (bWildcardSearch) {
  1589. dsiInfo.pszFileID= (LPWSTR)g_pszWildcardSearch;
  1590. }
  1591. else {
  1592. dsiInfo.pszFileID= (LPWSTR)malloc((1 + wcslen(i_pszFileID)) * sizeof(WCHAR));
  1594. if (NULL == dsiInfo.pszFileID) {
  1595. tr_printf(("FATAL: _findFirstFileRecord() Failed [5]: Low system resourcesn"));
  1596. sc_Free(dsiInfo.hDirFileRecordList, uDirFileRecListSizeInCont);
  1597. return NULL;
  1598. }
  1600. wcscpy(dsiInfo.pszFileID, i_pszFileID);
  1601. }
  1603. // Continue to copy necessary information into the DirSearchInfo, and initialize it.
  1604. dsiInfo.uFileFlagsMask= uFileFlagsMask;
  1605. dsiInfo.uFileFlags= uFileFlags;
  1607. // Locate the Directory-Node corresponding to the Current Directory within 
  1608. // the Directory-Hierarchy Tree.
  1609. for (uDirNodePos=0; uDirNodePos < g_pISO9660Info->uDirectoryCnt; uDirNodePos++) {
  1610. DirectoryNode dnCurrDir;
  1612. // Retrieve the Current Directory-Node
  1613. if (! Array_getAt(g_pISO9660Info->hDirTree, uDirNodePos, (BYTE*)&dnCurrDir)) {
  1614. dbg_printf(("WARNING: _findFirstFileRecord() Failed [6]n"));
  1615. break;
  1616. }
  1618. if (g_pISO9660Info->dwCurrDirICB == dnCurrDir.dwDirICB) {
  1619. dsiInfo.uDirNumber= uDirNodePos;
  1620. break;
  1621. }
  1622. }
  1624. // Calculate the first Record to examine. This record is the Second record
  1625. // on the Record-List, since the first Record always describes the Current Directory
  1626. // and is not of interest.
  1627. dsiInfo.cbRecListOffset= cbFirstRecordSize;
  1628. dsiInfo.cbCurrRecOffset= 0;
  1630. // Allocate a Search-Info
  1631. uSearchID= _FileSys_allocateSearchInfo();
  1632. if (NULL == uSearchID) {
  1633. dbg_printf(("WARNING: _findFirstFileRecord() Failed [7]: No available Search-Info IDn"));
  1635. if (! bWildcardSearch)
  1636. free(dsiInfo.pszFileID);
  1638. sc_Free(dsiInfo.hDirFileRecordList, uDirFileRecListSizeInCont);
  1639. return NULL;
  1640. }
  1642. // Register the Directory-Search Info in the Search-Info Pool
  1643. bSuccess= _FileSys_setSearchInfo(uSearchID, (const BYTE*)&dsiInfo);
  1644. if (! bSuccess) {
  1645. dbg_printf(("FATAL: _findFirstFileRecord() Failed [8]: Cannot register new Searchn"));
  1646. }
  1648. // Now, the information in dsiInfo is stable and complete: perform the search
  1649. if (bSuccess && ! _findNextFileRecord(uSearchID, o_pFileRecordPtr)) {
  1650. dbg_printf(("WARNING: _findFirstFileRecord() Failed [9]: Could not find a matchn"));
  1651. bSuccess= FALSE;
  1652. }
  1654. if (! bSuccess) {
  1655. if (! bWildcardSearch)
  1656. free(dsiInfo.pszFileID);
  1658. sc_Free(dsiInfo.hDirFileRecordList, uDirFileRecListSizeInCont);
  1659. _FileSys_freeSearchInfo(uSearchID);
  1660. return NULL;
  1661. }
  1663. return uSearchID;
  1664. }
  1667. /////////////////////////////////////////////////////////////////////////////
  1668. // _findNextFileRecord()
  1669. //
  1670. // Description: Continues a search that was previously initiated via a call
  1671. // to _findFirstFileRecord().
  1672. //
  1673. // Input: uSearchID - The ID of a search, that was returned from a
  1674. // previous call to _findFirstFileRecord().
  1675. // Output: o_pFileRecordPtr - Points to a DirFileRecord Pointer, to receive
  1676. //    the File-Record of a matching File/Sub-Directory.
  1677. // In/Out: None
  1678. // Return: TRUE if the search succeeded, and an additional File-Record matching
  1679. // the criteria was found. In this case, the supplied o_pFileRecordPtr
  1680. // contains a valid pointer.
  1681. // FALSE is returned if no more Files/Sub-Directories matching the
  1682. // supplied criteria could be found. In this case, the supplied 
  1683. // o_pFileRecordPtr is invalid.
  1684. //
  1685. // Remarks:
  1686. // 1. This method continues a previous search from the point it left off.
  1687. // 2. The search relates to the Directory that was the current working-
  1688. //    directory at the time the search was initiated via _findFirstFileRecord().
  1689. // 3. The search uses the same criteria as were originally supplied  to 
  1690. //    _findFirstFileRecord().
  1691. // 4. The returned File-Record Pointer should be considered persistant
  1692. //    across calls. The caller has to make sure that o_pFileRecordPtr 
  1693. //    is freed when it is no longer needed.
  1694. // 5. _findClose() must be called when no additional searches are needed. 
  1696. static BOOL _findNextFileRecord(UINT16 uSearchID, struct DirFileRecord **o_pFileRecordPtr)
  1697. {
  1698. UINT8 uFileIDLength;
  1699. BOOL bFileRecFound;
  1700. BOOL bSearchIncludesDirs;
  1701. WCHAR szUnicodeFileID[(MAX_ID_LENGTH / sizeof(WCHAR)) + 1];
  1702. LPCWSTR pszFileID;
  1703. struct DirFileRecord *pCurrFileRec;
  1704. DirectorySearchInfo dsiInfo;
  1705. //<<<MikeX_1213_2004_A:compare the files' length when searching files.
  1706. UINT8 uFoundFileIDLength;
  1707. WCHAR* pwcFoundFileVersionChar;
  1708. BOOL bBlurredlySearch = FALSE;
  1709. //MikeX_1213_2004_A>>>
  1711. // Retrieve the Directory-Search Info from the Search-Pool
  1712. if ((NULL == uSearchID) ||
  1713. ! _FileSys_getSearchInfo(uSearchID, (BYTE*)&dsiInfo))
  1714. {
  1715. return FALSE;
  1716. }
  1718. uFileIDLength= wcslen(dsiInfo.pszFileID);
  1719. // MikeX_1213_2004_A: support blurred searching
  1720. if( FILESYS_BLURRED_SEARCH == dsiInfo.pszFileID[uFileIDLength-1] )
  1721. {
  1722. bBlurredlySearch = TRUE;
  1723. uFileIDLength --;
  1724. }
  1726. bSearchIncludesDirs= (dsiInfo.uFileFlags == (FILE_FLAGS_DIRECTORY & dsiInfo.uFileFlagsMask));
  1728. // Reset the result
  1729. *o_pFileRecordPtr= NULL;
  1731. // Prepare a descriptor-container
  1732. pCurrFileRec= (struct DirFileRecord *)malloc(MAX_FILEREC_SIZE);
  1734. if (NULL == pCurrFileRec) {
  1735. tr_printf(("FATAL: _findNextFileRecord() Failed [1]: Low system resourcesn"));
  1736. return FALSE;
  1737. }
  1739. // Scan the Directory, as long as it is not exhausted, and there is no match
  1740. bFileRecFound= FALSE;
  1742. while ( ((dsiInfo.cbRecListOffset + dsiInfo.cbCurrRecOffset) < dsiInfo.dwDirectorySize) &&
  1743. (! bFileRecFound) )
  1744. {
  1745. UINT8 cbRequiredDataSize;
  1747. // Extract the Length of the Current Record, which is the first Byte of the Record
  1748. sc_GetBytes(dsiInfo.hDirFileRecordList, dsiInfo.cbCurrRecOffset, 1, &cbRequiredDataSize);
  1750. // If the Length of the Current Record is Zero, then the required data is One Byte long
  1751. if (0 == cbRequiredDataSize)
  1752. cbRequiredDataSize++;
  1754. // Check if the remaining space until the end of the Record-List Cache is large enough
  1755. // to accomodate for the Current Record. If not, cache an additional Record-List chunk.
  1756. if ((DIRECTORY_RECLIST_SZ - dsiInfo.cbCurrRecOffset) < cbRequiredDataSize) {
  1757. dsiInfo.cbRecListOffset += dsiInfo.cbCurrRecOffset;
  1758. dsiInfo.cbCurrRecOffset= 0;
  1760. if (! sc_CopyFromDisc(dsiInfo.dwDirICB, dsiInfo.cbRecListOffset,
  1761.   DIRECTORY_RECLIST_SZ, dsiInfo.hDirFileRecordList))
  1762. {
  1763. dbg_printf(("WARNING: _findNextFileRecord() Failed [2]n"));
  1764. break;
  1765. }
  1767. // Set the Required Data Size to the Maximum Record size, in order to avoid
  1768. // having to read this size again from the Record-List Cache.
  1769. cbRequiredDataSize= MAX_FILEREC_SIZE;
  1770. }
  1772. // Collect the next DirFileRecord
  1773. sc_GetBytes(dsiInfo.hDirFileRecordList, dsiInfo.cbCurrRecOffset,
  1774. MIN(cbRequiredDataSize, MAX_FILEREC_SIZE), (BYTE*)pCurrFileRec);
  1776. // Check the Length of the current Record: if it is Zero, then either the End-Of-Directory
  1777. // was encountered, or a Sector-Boundary needs to be crossed.
  1778. if (0 == pCurrFileRec->cbLengthOfDirRecord) {
  1779. // ECMA-119 guarantees, that each Record shall end in the same Sector in which it was
  1780. // started. If there isn't enough space, the Record will be moved to the succeeding
  1781. // Sector, and the current Sector will be Zero-padded.
  1782. DWORD dwCurrSectorBoundary= 
  1783. ( ((dsiInfo.cbRecListOffset + dsiInfo.cbCurrRecOffset + LOGICAL_BLOCK_SIZE - 1) / 
  1784.    LOGICAL_BLOCK_SIZE) * LOGICAL_BLOCK_SIZE );
  1786. // If the Current Record-Offest is Zero, then move to the next closest Sector
  1787. if (0 == dsiInfo.cbCurrRecOffset)
  1788. dwCurrSectorBoundary += LOGICAL_BLOCK_SIZE;
  1790. // If the current Sector boundary exceeds the Directory's size, then End-Of-Directory
  1791. // was encountered.
  1792. if (dwCurrSectorBoundary >= dsiInfo.dwDirectorySize)
  1793. break;
  1795. // The Sector boundary must be crossed:
  1796. // Set cbCurrRecOffset to DIRECTORY_RECLIST_SZ, thus forcing caching of a Record-List
  1797. // chunk; adjust cbRecListOffset such, that the next caching will occur
  1798. // at the beginning of the succeeding Sector.
  1799. dsiInfo.cbRecListOffset= (dwCurrSectorBoundary - DIRECTORY_RECLIST_SZ);
  1800. dsiInfo.cbCurrRecOffset= DIRECTORY_RECLIST_SZ;
  1802. // Force collection of the next DirFileRecord from the freshly-loaded cache
  1803. continue;
  1804. }
  1806. // If the search includes Sub-Directories, and provided that the Current Directory-
  1807. // File Record is not reported as a Directory, cross-check this against the
  1808. // information from the Directory-Hierarchy Tree (Path table).
  1809. // This is a precaution required to overcome authoring-errors in the File-Flags field
  1810. // (which is the only criterion for determining the Type of this Record).
  1811. if (bSearchIncludesDirs && (0 == (pCurrFileRec->uFlags & FILE_FLAGS_DIRECTORY))) {
  1812. UINT16 uDirNodePos;
  1814. // Iterate over all the Directory-Tree, and try to locate this Record in it.
  1815. for (uDirNodePos=0; uDirNodePos < g_pISO9660Info->uDirectoryCnt; uDirNodePos++) {
  1816. DirectoryNode dnCurrDir;
  1818. // Retrieve the Current Directory-Node
  1819. if (! Array_getAt(g_pISO9660Info->hDirTree, uDirNodePos, (BYTE*)&dnCurrDir)) {
  1820. dbg_printf(("WARNING: _findNextFileRecord() Failed [3]n"));
  1821. break;
  1822. }
  1824. // Check if the Directory has the same location as this Record, and if
  1825. // its Parent is the current Directory.
  1826. if ( (BB_DWORD(pCurrFileRec->dwExtentLocation) == dnCurrDir.dwDirICB) &&
  1827.  (dsiInfo.uDirNumber == (dnCurrDir.uParentDirNumber - 1)) )
  1828. {
  1829. // A misreported directory was found: force this Record's Flags field to
  1830. // identify a Directory.
  1831. pCurrFileRec->uFlags= FILE_FLAGS_DIRECTORY;
  1832. }
  1833. }
  1834. }
  1836. // Collect the current File-ID
  1837. pszFileID= (LPCWSTR)szUnicodeFileID;
  1838. //<<<Hannah_0524_2005 Cut the file length properly according to the different system.
  1839. {
  1840. extern BOOL _fileID_Cut(UINT8 i_fileID_len, BYTE* i_pSourceBuffer, UINT8 o_fileID_len, BYTE* o_pDestBuffer);
  1842. if(!g_pISO9660Info->bIsUsingUnicode)  //ROMEO
  1843. {
  1844. if( pCurrFileRec->cbLengthOfFileID > MAX_ID_LENGTH/sizeof(WCHAR) )
  1845. {
  1846. BYTE* buff = NULL;
  1847. BYTE len = pCurrFileRec->cbLengthOfFileID+1;
  1849. buff=(BYTE*)malloc(len +1);
  1850. if(buff == NULL)
  1851. {
  1852. dbg_printf(("WARNING: _findNextFileRecord() Failed [5]:Low system resourcesn"));
  1853. break;
  1854. }
  1855. buff[0] = 0x08; //UNICODE_COMPRESSIONID_DOUBLE_BYTE 
  1856. sc_GetBytes(dsiInfo.hDirFileRecordList, dsiInfo.cbCurrRecOffset + sizeof(struct DirFileRecord),
  1857. len-1, buff+1);
  1858. _fileID_Cut(len, buff, MAX_ID_LENGTH/sizeof(WCHAR)+1, pCurrFileRec->sFileID-1);
  1859. pCurrFileRec->cbLengthOfFileID = MAX_ID_LENGTH/sizeof(WCHAR);
  1860. free(buff);
  1862. }
  1863. }
  1864. else
  1865. {
  1866. if( pCurrFileRec->cbLengthOfFileID > MAX_ID_LENGTH )
  1867. {
  1868. BYTE* buff = NULL;
  1869. BYTE len = pCurrFileRec->cbLengthOfFileID+1;
  1871. buff=(BYTE*)malloc(len + 2);
  1872. if(buff == NULL)
  1873. {
  1874. dbg_printf(("WARNING: _findNextFileRecord() Failed [6]:Low system resourcesn"));
  1875. break;
  1876. }
  1877. buff[0] = 0x10; //UNICODE_COMPRESSIONID_DOUBLE_BYTE 
  1878. sc_GetBytes(dsiInfo.hDirFileRecordList, dsiInfo.cbCurrRecOffset + sizeof(struct DirFileRecord),
  1879. len-1, buff+1);
  1880. _fileID_Cut(len, buff, MAX_ID_LENGTH+1, pCurrFileRec->sFileID-1);
  1881. pCurrFileRec->cbLengthOfFileID = MAX_ID_LENGTH;
  1882. free(buff);
  1883. }
  1884. }
  1887. }
  1888. //Hannah_0524_2005>>>
  1891.       //ZCH JC2003-7-17, limit pCurrFileRec->cbLengthOfFileID within MAX_ID_LENGTH, pCurrFileRec->cbLengthOfFileID is sometimes beyond MAX_ID_LENGTH because the addition of ";1"
  1892.       //if(pCurrFileRec->cbLengthOfFileID > MAX_ID_LENGTH)
  1893.         //pCurrFileRec->cbLengthOfFileID = MAX_ID_LENGTH;
  1896. // Convert the File-ID into UNICODE, if UNICODE is not in use or the current File-ID is
  1897. // one character long.
  1898. if (!g_pISO9660Info->bIsUsingUnicode || (1 == pCurrFileRec->cbLengthOfFileID)) {
  1899. // The File-ID is given in ANSI-ASCII: convert it into UNICODE
  1900. _str2wcs((LPCSTR)pCurrFileRec->sFileID, szUnicodeFileID,
  1901.  ((pCurrFileRec->cbLengthOfFileID + 1) * sizeof(WCHAR)));
  1902. }
  1903. else {
  1904. // The File-ID is given in UNICODE: manipulate as required
  1905. pCurrFileRec->sFileID[pCurrFileRec->cbLengthOfFileID]= 0;
  1906. pCurrFileRec->sFileID[pCurrFileRec->cbLengthOfFileID+1]= 0;
  1908. #ifdef MOTOROLA
  1909. pszFileID= (LPCWSTR)pCurrFileRec->sFileID;
  1910. #else
  1911. swab((LPSTR)pCurrFileRec->sFileID, (LPSTR)szUnicodeFileID,
  1912.  (pCurrFileRec->cbLengthOfFileID + 2));
  1913. #endif //MOTOROLA
  1914. }
  1916. // Check if an appropriate Directory-File Record was found, according to
  1917. // both the (UNICODE-normalized) File-ID and the File-Flags.
  1918. #if 0 // Robin_1112_2004, "*" mean any char/string, RB_TBD
  1919. if (dsiInfo.uFileFlags == (pCurrFileRec->uFlags & dsiInfo.uFileFlagsMask))
  1920. {
  1921. if ((0 != uFileIDLength && dsiInfo.pszFileID[uFileIDLength-1] == '*') && (0 == _wcsnicmp(dsiInfo.pszFileID, pszFileID, uFileIDLength-1)) )
  1922. bFileRecFound= TRUE;
  1923. else if ((uFileIDLength == wcslen(pszFileID) || 0 == uFileIDLength) && (0 == _wcsnicmp(dsiInfo.pszFileID, pszFileID, uFileIDLength)) )
  1924. bFileRecFound= TRUE;
  1925. }
  1926. #else
  1927. //<<<MikeX_1213_2004_A:compare the files' length when searching files.
  1928. if( g_pISO9660Info->bIsUsingUnicode )
  1929. uFoundFileIDLength = pCurrFileRec->cbLengthOfFileID/sizeof(WCHAR);
  1930. else
  1931. uFoundFileIDLength = pCurrFileRec->cbLengthOfFileID;
  1932. pwcFoundFileVersionChar = wcsrchr(pszFileID, L';');
  1933. if( 0 != pwcFoundFileVersionChar )
  1934. uFoundFileIDLength = (UINT8)(pwcFoundFileVersionChar - pszFileID);
  1935. if( 0 == uFoundFileIDLength || 0 == uFileIDLength )
  1936. uFoundFileIDLength = uFileIDLength;
  1937. //MikeX_1213_2004_A>>>
  1938. #ifdef MACESTROLINK_SUPPORT
  1939. if ( (dsiInfo.uFileFlags == (pCurrFileRec->uFlags & dsiInfo.uFileFlagsMask)) &&
  1940. (0 == _wcsnicmp(dsiInfo.pszFileID, pszFileID, uFileIDLength))&& //MikeX_1119_2003: convert the file ID lower-case to upper-case.
  1941. (bBlurredlySearch || (uFoundFileIDLength == uFileIDLength)||IS_PLAYING_MLNK)) //Hansen_2004_12_30 Macestrolink can not compare file's length
  1942. #else
  1943. if ( (dsiInfo.uFileFlags == (pCurrFileRec->uFlags & dsiInfo.uFileFlagsMask)) &&
  1944. (0 == _wcsnicmp(dsiInfo.pszFileID, pszFileID, uFileIDLength))&& //MikeX_1119_2003: convert the file ID lower-case to upper-case.
  1945. (bBlurredlySearch || (uFoundFileIDLength == uFileIDLength))) //MikeX_1213_2004_A:compare the files' length when searching files.
  1946. #endif
  1947. {
  1948. bFileRecFound= TRUE;
  1949. }
  1950. #endif
  1951. // Continue to the next Directory/File Record
  1952. dsiInfo.cbCurrRecOffset += pCurrFileRec->cbLengthOfDirRecord;
  1953. }//endof while
  1955. if (bFileRecFound) {
  1956. // Assign the result
  1957. *o_pFileRecordPtr= pCurrFileRec;
  1958. }
  1959. else {
  1960. // No match was found - this Directory has been exhausted: mark that the entire
  1961. // contents was read, so that future calls will return immediately.
  1962. dsiInfo.cbRecListOffset= dsiInfo.dwDirectorySize;
  1963. dsiInfo.cbCurrRecOffset= 0;
  1965. // Free the memory
  1966. free(pCurrFileRec);
  1967. }
  1969. // Update the Directory-Search Info in the Search-Pool
  1970. if (! _FileSys_setSearchInfo(uSearchID, (const BYTE*)&dsiInfo)) {
  1971. dbg_printf(("WARNING: _findNextFileRecord() Failed [4]n"));
  1972. }
  1974. return bFileRecFound;
  1975. }
  1978. /////////////////////////////////////////////////////////////////////////////
  1979. // _findClose()
  1980. //
  1981. // Description: Terminates a search.
  1982. //
  1983. // Input: uSearchID - The ID of a search, that was returned from a
  1984. // previous call to _findFirstFileRecord().
  1985. // Output: None
  1986. // In/Out: None
  1987. // Return: TRUE if the search was successfully terminated; FALSE othewise.
  1988. //
  1989. // Remarks:
  1990. // Any search that is initiated via _findFirstFileRecord() must be terminated
  1991. // using a call to this method, in order to allow for proper release of
  1992. // resources that were allocated for that search. 
  1993. //  If the call to _findFirstFileRecord() returned NULL, it is prohibited 
  1994. // to call _findClose().
  1996. static BOOL _findClose(UINT16 uSearchID)
  1997. {
  1998. DirectorySearchInfo dsiInfo;
  2000. // Retrieve the Directory-Search Info from the Search-Pool
  2001. if ((NULL == uSearchID) ||
  2002. ! _FileSys_getSearchInfo(uSearchID, (BYTE*)&dsiInfo))
  2003. {
  2004. return FALSE;
  2005. }
  2007. if (dsiInfo.pszFileID != g_pszWildcardSearch)
  2008. free(dsiInfo.pszFileID);
  2010. sc_Free(dsiInfo.hDirFileRecordList, CONTAINER_COUNT(DIRECTORY_RECLIST_SZ));
  2012. _FileSys_freeSearchInfo(uSearchID);
  2014. return TRUE;
  2015. }
  2018. /////////////////////////////////////////////////////////////////////////////
  2019. // _getFileAttributes()
  2020. //
  2021. // Description: Translates a native File-Record into a FindData structure.
  2022. //
  2023. // Input: i_pFileRec - Points to a DirFileRecord structure to translate.
  2024. // Output: o_pFindData - Points to a FindData structure to receive the
  2025. //   translated information.
  2026. // In/Out: None
  2027. // Return: None
  2028. // Remarks: None
  2030. static void _getFileAttributes(const struct DirFileRecord *i_pFileRec,
  2031.    FindData *o_pFindData)
  2032. {
  2033. LPWSTR pszSeparator2;
  2035. // Now it's safe to access the Record
  2036. o_pFindData->uFileType= ((i_pFileRec->uFlags & FILE_FLAGS_DIRECTORY) ? 
  2037.  FILETYPE_DIRECTORY : FILETYPE_NORMAL);
  2038. o_pFindData->dwStartAddr= BB_DWORD(i_pFileRec->dwExtentLocation);
  2039. o_pFindData->cbFileSizeHigh= 0;
  2040. o_pFindData->cbFileSizeLow= BB_DWORD(i_pFileRec->dwDataLength);
  2042. // Extract the File-ID
  2043. if (!g_pISO9660Info->bIsUsingUnicode || (1 == i_pFileRec->cbLengthOfFileID)) {
  2044. // The File-ID is given in ANSI-ASCII: convert it into UNICODE
  2045. _str2wcs((LPCSTR)i_pFileRec->sFileID, o_pFindData->szFileID,
  2046.  ((i_pFileRec->cbLengthOfFileID + 1) * sizeof(WCHAR)));
  2047. }
  2048. else {
  2049. // The File-ID is given in UNICODE: manipulate as required
  2050. #ifdef MOTOROLA
  2051. memcpy(o_pFindData->szFileID, i_pFileRec->sFileID, i_pFileRec->cbLengthOfFileID);
  2052. #else
  2053. swab((LPSTR)i_pFileRec->sFileID, (LPSTR)o_pFindData->szFileID, i_pFileRec->cbLengthOfFileID);
  2054. #endif //MOTOROLA
  2056. o_pFindData->szFileID[i_pFileRec->cbLengthOfFileID / sizeof(WCHAR)]= 0;
  2057. }
  2059. // Eliminate the SEPARATOR2 from the end
  2060. pszSeparator2= wcsrchr(o_pFindData->szFileID, SEPARATOR2);
  2062. if (NULL != pszSeparator2)
  2063. *pszSeparator2= 0;
  2065. return;
  2066. }