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

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

DVD

开发平台：

Others

FX_DS.C：源码内容
  1. /**************************************************************************/ 
  2. /*                                                                        */ 
  3. /*            Copyright (c) 1996-2002 by Express Logic Inc.               */ 
  4. /*                                                                        */ 
  5. /*  This software is copyrighted by and is the sole property of Express   */ 
  6. /*  Logic, Inc.  All rights, title, ownership, or other interests         */ 
  7. /*  in the software remain the property of Express Logic, Inc.  This      */ 
  8. /*  software may only be used in accordance with the corresponding        */ 
  9. /*  license agreement.  Any unauthorized use, duplication, transmission,  */ 
  10. /*  distribution, or disclosure of this software is expressly forbidden.  */ 
  11. /*                                                                        */
  12. /*  This Copyright notice may not be removed or modified without prior    */ 
  13. /*  written consent of Express Logic, Inc.                                */ 
  14. /*                                                                        */ 
  15. /*  Express Logic, Inc. reserves the right to modify this software        */ 
  16. /*  without notice.                                                       */ 
  17. /*                                                                        */ 
  18. /*  Express Logic, Inc.                     info@expresslogic.com         */
  19. /*  11423 West Bernardo Court               http://www.expresslogic.com   */
  20. /*  San Diego, CA  92127                                                  */
  21. /*                                                                        */
  22. /**************************************************************************/
  25. /**************************************************************************/
  26. /**************************************************************************/
  27. /**                                                                       */ 
  28. /** FileX Component                                                       */ 
  29. /**                                                                       */
  30. /**   Directory (DIR)                                                     */
  31. /**                                                                       */
  32. /**************************************************************************/
  33. /**************************************************************************/
  35. #include "Config.h" // Global Configuration - do not remove!
  37. #ifdef ENABLE_FILEX
  39. #ifdef _DEBUG
  40. #undef IFTRACE
  41. #define IFTRACE if (gTraceFileSys)
  42. #include "DebugDbgMain.h"
  43. #endif //_DEBUG
  45. #define FX_SOURCE_CODE
  48. /* Include necessary system files.  */
  50. #include "PlaycoreFileSysFileXfx_api.h"
  51. #include "PlaycoreFileSysFileXfx_sys.h"
  52. #include "PlaycoreFileSysFileXfx_dir.h"
  53. #include "PlaycoreFileSysFileXfx_uti.h"
  56. #ifndef FX_NO_LOCAL_PATH
  57. extern TX_THREAD *_tx_thread_current_ptr;
  58. #endif
  60. /**************************************************************************/ 
  61. /*                                                                        */ 
  62. /*  FUNCTION                                               RELEASE        */ 
  63. /*                                                                        */ 
  64. /*    _fx_directory_search                                PORTABLE C      */ 
  65. /*                                                           3.0          */ 
  66. /*  AUTHOR                                                                */ 
  67. /*                                                                        */ 
  68. /*    William E. Lamie, Express Logic, Inc.                               */ 
  69. /*                                                                        */ 
  70. /*  DESCRIPTION                                                           */ 
  71. /*                                                                        */ 
  72. /*    This function searches the media for the supplied name.  The search */ 
  73. /*    routine will find files as well as directory names.                 */ 
  74. /*                                                                        */ 
  75. /*  INPUT                                                                 */ 
  76. /*                                                                        */ 
  77. /*    media_ptr                             Media control block pointer   */ 
  78. /*    name_ptr                              Name pointer (8 chars + ext)  */ 
  79. /*    entry_ptr                             Pointer to directory entry    */ 
  80. /*                                            record                      */ 
  81. /*    last_dir_ptr                          Pointer to destination for    */ 
  82. /*                                            the last directory entry    */ 
  83. /*    last_name_ptr                         Pointer to the last name      */ 
  84. /*                                            token that was searched for */ 
  85. /*                                                                        */ 
  86. /*  OUTPUT                                                                */ 
  87. /*                                                                        */ 
  88. /*    return status                                                       */ 
  89. /*                                                                        */ 
  90. /*  CALLS                                                                 */ 
  91. /*                                                                        */ 
  92. /*    _fx_directory_name_extract            Extract directory name from   */ 
  93. /*                                            input string                */ 
  94. /*    _fx_directory_entry_read              Read entries from root dir    */ 
  95. /*    _fx_utlity_FAT_entry_read             Read FAT entries to calculate */ 
  96. /*                                            the sub-directory size      */ 
  97. /*                                                                        */ 
  98. /*  CALLED BY                                                             */ 
  99. /*                                                                        */ 
  100. /*    FileX System Functions                                              */ 
  101. /*                                                                        */ 
  102. /*  RELEASE HISTORY                                                       */ 
  103. /*                                                                        */ 
  104. /*    DATE              NAME                      DESCRIPTION             */ 
  105. /*                                                                        */ 
  106. /*  01-01-1999     William E. Lamie         Initial Version 1.0           */ 
  107. /*  03-01-2000     William E. Lamie         Modified comment(s), and      */ 
  108. /*                                            added logic to properly     */ 
  109. /*                                            handle ".." searches from   */ 
  110. /*                                            sub-directories off of the  */ 
  111. /*                                            root directory, resulting   */ 
  112. /*                                            in version 1.0b.            */ 
  113. /*  01-28-2001     William E. Lamie         Modified comment(s), added    */ 
  114. /*                                            local path logic, and       */ 
  115. /*                                            deleted old directory cache */ 
  116. /*                                            invalidate code, resulting  */ 
  117. /*                                            in version 2.0.             */
  118. /*  03-01-2002     Mohammad N. Minhaz       Modified comment(s),          */ 
  119. /*                                            changed to 32 bit variables,*/ 
  120. /*                                            changed FAT32 root directory*/ 
  121. /*                                            logic, and added logic for  */ 
  122. /*                                            long file names, resulting  */ 
  123. /*                                            in version 3.0.             */ 
  124. /*                                                                        */ 
  125. /**************************************************************************/ 
  126. UINT  _fx_directory_search(FX_MEDIA *media_ptr, CHAR *name_ptr, FX_DIR_ENTRY *entry_ptr, 
  127.                                     FX_DIR_ENTRY *last_dir_ptr, CHAR **last_name_ptr)
  128. {
  130. ULONG           i;
  131. UINT            found;
  132. UINT            status;
  133. ULONG           cluster, next_cluster;
  134. ULONG           directory_size;
  135. CHAR            *dir_name_ptr;
  136. CHAR            *work_ptr;
  137. FX_DIR_ENTRY    search_dir;
  138. FX_DIR_ENTRY    *search_dir_ptr;
  139. CHAR            name[FX_MAX_LONG_NAME_LEN];
  140. ULONG           fat_reserved;
  143.     /* Determine the type of FAT and setup variables accordingly.  */
  144.     if (media_ptr -> fx_media_32_bit_FAT) fat_reserved = FX_RESERVED_1_32;
  145.     else fat_reserved = FX_RESERVED_1;
  147.     /* Setup the last directory, if required.  */
  148.     if (last_dir_ptr)
  149.     {
  151.         /* Set the first character of the directory entry to NULL to 
  152.            indicate root or no directory.  */
  153.         last_dir_ptr -> fx_dir_entry_name[0] =  0;
  154.     }
  156.     /* Determine if the file name has a full directory path.  */
  157.     if (*name_ptr == '\')
  158.     {
  159.         
  160.         /* Directory name has full path, set the search pointer to NULL.  */
  161.         search_dir_ptr =  FX_NULL;
  162.     }
  163.     else
  164.     {
  166.         /* Set the initial search directory to the current working 
  167.            directory - if there is one.  */
  169.         /* First check for a local path pointer stored in the thread control block.  This
  170.            is only available in ThreadX Version 4 and above.  */
  171. #ifndef FX_NO_LOCAL_PATH
  172.         if (_tx_thread_current_ptr -> tx_filex_ptr)
  173.         {
  175.             /* Determine if the local directory is not the root directory.  */
  176.             if ( ((FX_PATH *) _tx_thread_current_ptr -> tx_filex_ptr) -> fx_path_directory.fx_dir_entry_name[0])
  177.             {
  179.                 /* Start at the current working directory of the media.  */
  180.                 search_dir =   ((FX_PATH *) _tx_thread_current_ptr -> tx_filex_ptr) -> fx_path_directory;
  182.                 /* Set the internal pointer to the search directory as well.  */
  183.                 search_dir_ptr =  &search_dir;
  184.             }
  185.             else
  186.             {
  188.                 /* We are searching in the root directory.  */
  189.                 search_dir_ptr =  FX_NULL;
  190.             }
  191.         } else
  192. #endif
  193.         if (media_ptr -> fx_media_default_path.fx_path_directory.fx_dir_entry_name[0])
  194.         {
  195.         
  196.             /* Start at the current working directory of the media.  */
  197.             search_dir =  media_ptr -> fx_media_default_path.fx_path_directory;
  198.             
  199.             /* Set the internal pointer to the search directory as well.  */
  200.             search_dir_ptr =  &search_dir;
  201.         }
  202.         else
  203.         {
  205.             /* The current default directory is the root so just set the
  206.                search directory pointer to NULL.  */
  207.             search_dir_ptr =  FX_NULL;
  208.         }
  209.     }
  211.     /* Loop to traverse the directory paths to find the specified file.  */
  212.     do
  213.     {
  215.         /* Remember the last name pointer, if required.  */
  216.         if (last_name_ptr)
  217.         {
  219.             /* Just set the last name to initial name string.  */
  220.             *last_name_ptr =  name_ptr;
  221.         }
  223.         /* Extract file name.  */
  224.         name_ptr =  _fx_directory_name_extract(name_ptr, name);
  225.         /* Calculate the directory size.  */
  226.         if (search_dir_ptr)
  227.         {
  229.             /* Calculate the directory size by counting the allocated
  230.                clusters for it.  */
  231.             i =        0;
  232.             cluster =  search_dir_ptr -> fx_dir_entry_cluster;
  233.             while ((cluster >= FX_FAT_ENTRY_START) &&
  234.                     (cluster < fat_reserved))
  235.             {
  237.                 /* Increment the cluster count.  */
  238.                 i++;
  240.                 /* Read the next FAT entry.  */
  241.                 status =  _fx_utility_FAT_entry_read(media_ptr, cluster, &next_cluster);
  243.                 /* Check the return status.  */
  244.                 if (status != FX_SUCCESS)
  245.                 {
  247.                     /* Return the bad status.  */
  248.                     return(status);
  250.                 }                
  253.                 if ((cluster == next_cluster) || (i > media_ptr -> fx_media_total_clusters)) 
  254.                 {
  256.                     /* Return the bad status.  */
  257.                     return(FX_FAT_READ_ERROR);
  258.                 }
  260.                 cluster = next_cluster;
  261.             }
  263.             /* Now we can calculate the directory size.  */
  264.             directory_size =  (((ULONG) media_ptr -> fx_media_bytes_per_sector) *
  265.                                ((ULONG) media_ptr -> fx_media_sectors_per_cluster) * i)
  266.                                 / (ULONG) FX_DIR_ENTRY_SIZE;
  268.             /* Also save this in the directory entry so we don't have to 
  269.                calculate it later.  */
  270.             search_dir_ptr -> fx_dir_entry_file_size =  directory_size;
  272.             /* If required, copy the last search directory entry into the 
  273.                destination.  */
  274.             if ((last_dir_ptr) && (search_dir_ptr))
  275.             {
  277.                 /* Copy the last search directory into the destination.  */
  278.                 *last_dir_ptr =  *search_dir_ptr;
  279.             }
  280.         }
  281.         else
  282.         {
  284.             /* Directory size is the number of entries in the root directory.  */
  285.             directory_size =  (ULONG) media_ptr -> fx_media_root_directory_entries;
  286.         }
  288.         /* Loop through entries in the directory.  Yes, this is a 
  289.            linear search!  */
  290.         i =      0;
  291.         found =  FX_FALSE;
  292.         do
  293.         {
  295.             /* Read an entry from the directory.  */
  296.             status =  _fx_directory_entry_read(media_ptr, search_dir_ptr, &i, entry_ptr);
  297.             i++;
  299.             /* Check for error status.  */
  300.             if (status != FX_SUCCESS)
  301.                 return(status);
  303.             /* Determine if this is an empty entry.  */
  304.             if (((BYTE)entry_ptr->fx_dir_entry_name[0]) == FX_DIR_ENTRY_FREE)
  305.                 continue;
  307.             /* Determine if this is the last directory entry.  */
  308. //JERRYC_2004AUG25            if (entry_ptr -> fx_dir_entry_name[0] == FX_DIR_ENTRY_DONE)
  309.             if (entry_ptr -> fx_dir_entry_name[0] == FX_DIR_ENTRY_DONE && i > 1)
  310.                 break;
  312.             /* Compare the input name and extension with the directory
  313.                entry.  */
  314.             work_ptr =      name;
  315.             dir_name_ptr =  entry_ptr -> fx_dir_entry_name;
  316.            
  317.             do 
  318.             {
  320.                 /* Compare name with directory name.  */
  321.                 if (*work_ptr != *dir_name_ptr)
  322.                     break;
  324.                 /* Otherwise, move the name pointers and increment the
  325.                    count.  */
  326.                 work_ptr++;
  327.                 dir_name_ptr++;
  329.             } while (*dir_name_ptr);
  331.             /* Determine if the requested name has been found.  If so,
  332.                return success to the caller.  */
  333.             if ((*dir_name_ptr == 0) && (*work_ptr == *dir_name_ptr))
  334.             {
  336.                 /* Yes, the name was located.  All pertinent directory
  337.                    information is in the directory entry field.  */
  338.                 found =  FX_TRUE;
  339.             }
  341.         } while ((i < directory_size) && (!found));
  343.         /* Now determine if we have a match.  */
  344.         if (!found)
  345.         {
  347.             /* Return a "not found" status to the caller.  */
  348.             return(FX_NOT_FOUND);
  349.         }
  351.         /* Determine if the found entry is indeed a sub-directory.  */
  352.         if (entry_ptr -> fx_dir_entry_attributes & FX_DIRECTORY)
  353.         {
  355.             /* Move the directory search pointer to this entry.  */
  356.             search_dir =      *entry_ptr;
  357.             search_dir_ptr =  &search_dir;
  359.             /* Now determine if the new search directory is the root 
  360.                directory.  */
  361.             if (!search_dir_ptr -> fx_dir_entry_cluster)
  362.             {
  364.                 /* This is a backward link to the root directory.  Make
  365.                    sure this is indicated in the search directory 
  366.                    information.  */
  367.                 search_dir_ptr -> fx_dir_entry_name[0] =  0;
  369.                 /* Determine if we need to remember this in the last
  370.                    directory searched return area.  */
  371.                 if (last_dir_ptr)
  372.                 {
  374.                     /* Yes, return this value to the caller.  */
  375.                     *last_dir_ptr =  *search_dir_ptr;
  376.                 }
  378.                 /* Set the search directory pointer to NULL to indicate
  379.                    we are at the root directory.  */
  380.                 search_dir_ptr =  FX_NULL;
  381.             }
  382.         }
  383.         else
  384.         {
  386.             /* This is not a directory, we better return not found
  387.                since we can't continue the search.  */
  388.             if (name_ptr)
  389.             {
  391.                 /* Return not-found status to caller.  */
  392.                 return(FX_NOT_FOUND);
  393.             }
  394.         }
  396.     } while(name_ptr);
  398.     /* Return status to the caller.  */
  399.     if (found)
  400.         return(FX_SUCCESS);
  401.     else
  402.         return(FX_NOT_FOUND);
  403. }
  405. #endif