_mfs_error MFS_Set_volume
(
MFS_DRIVE_STRUCT_PTR drive_ptr,
char *volume_name /*[IN] name to use for the volune */
)
{
MFS_DIR_ENTRY_PTR dir_entry_ptr;
_mfs_error error_code;
uint32_t vol_cluster, vol_index;
uint32_t prev_cluster= CLUSTER_INVALID;
if ( volume_name == NULL )
{
return( MFS_INVALID_PARAMETER );
}
if ( *volume_name == '\0' )
{
return( MFS_INVALID_PARAMETER );
}
#if MFSCFG_READ_ONLY_CHECK
if (MFS_is_read_only (drive_ptr))
{
return MFS_DISK_IS_WRITE_PROTECTED;
}
#endif
error_code = MFS_lock_dos_disk(drive_ptr);
if ( !error_code )
{
vol_cluster = ROOT_CLUSTER(drive_ptr);
vol_index = 0;
dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, NULL, &vol_cluster, &vol_index, &prev_cluster, MFS_ATTR_VOLUME_NAME, &error_code);
if ( dir_entry_ptr )
{
MFS_Expand_dotfile(volume_name, dir_entry_ptr->NAME);
*dir_entry_ptr->ATTRIBUTE = MFS_ATTR_VOLUME_NAME;
drive_ptr->DIR_SECTOR_DIRTY = TRUE;
}
else if ( !error_code )
{
vol_cluster = ROOT_CLUSTER(drive_ptr);
vol_index = 0;
dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &vol_cluster, &vol_index, &prev_cluster, MFS_ATTR_ANY, &error_code);
if ( dir_entry_ptr )
{
MFS_Expand_dotfile(volume_name, dir_entry_ptr->NAME);
*dir_entry_ptr->ATTRIBUTE = MFS_ATTR_VOLUME_NAME;
drive_ptr->DIR_SECTOR_DIRTY = TRUE;
}
}
}
MFS_unlock(drive_ptr,TRUE);
return( error_code );
}
MFS_DIR_ENTRY_PTR MFS_Find_directory_entry
(
MFS_DRIVE_STRUCT_PTR drive_ptr, /*[IN] drive context */
char *file_ptr, /*[IN] specific name to search for, if NULL then first dir entry */
uint32_t *start_cluster_ptr, /*[IN] start searching in this cluster
**[OUT] set to the cluster number in which search was satisfied */
uint32_t *dir_index_ptr, /*[IN] start searching at this directory entry
**[OUT] if entry is found the index of the next entry is returned */
uint32_t *prev_cluster_ptr, /* [IN] set to the cluster number previous to start_cluster
** [OUT] set to the cluster number previous to *dir_cluster_ptr */
unsigned char attribute, /*[IN] search attribute, as per Find_first_file */
_mfs_error_ptr error_ptr /* The pointer carries the error infomation */
)
{
MFS_DIR_ENTRY_PTR dir_entry_ptr = NULL;
char *lfn_ptr = NULL;
bool found;
bool lfn_flag;
bool maybe = FALSE;
bool found_lfn = FALSE;
uint32_t current_cluster, current_index;
_mfs_error error_code;
uint32_t lfn_len = 0;
uint16_t entries_per_sector;
uint16_t k, i;
char lfn_entry[40]; /* LFN entry contains up to 13 UTF16 characters, up to 40 bytes including null term are necessary when encoded using UTF8 */
char fs_file[SFILENAME_SIZE + 1];
uint32_t prev_cluster = *prev_cluster_ptr;
uint32_t dirname = 0;
error_code = MFS_NO_ERROR;
entries_per_sector = drive_ptr->ENTRIES_PER_SECTOR;
current_cluster = *start_cluster_ptr;
current_index = *dir_index_ptr;
found = FALSE;
lfn_flag = FALSE;
/* If the name is a LFN, it will be treated differently */
if ( file_ptr && *file_ptr && !MFS_Dirname_valid(file_ptr) )
{
lfn_flag = TRUE;
lfn_len = _strnlen(file_ptr, PATHNAME_SIZE);
/* Set pointer just behind the end of the filename */
lfn_ptr = file_ptr + lfn_len;
maybe = TRUE;
found_lfn = FALSE;
/* We also need special treatement for a directory name */
if ( attribute == (ATTR_EXCLUSIVE | MFS_ATTR_DIR_NAME) )
{
attribute = MFS_ATTR_LFN;
dirname = 1;
}
}
else if ( file_ptr && *file_ptr )
{
MFS_Expand_dotfile(file_ptr, fs_file);
}
/*
** Search in all clusters within this directory
*/
do
{
/*
** Search in all sectors within this cluster
*/
for ( k = (uint16_t) INDEX_TO_SECTOR(current_index);
((current_cluster == 0) || (k < drive_ptr->BPB.SECTORS_PER_CLUSTER)) && found == FALSE && current_cluster != CLUSTER_EOF;
k++ )
{
dir_entry_ptr = MFS_Read_directory_sector(drive_ptr,current_cluster, k, &error_code);
if ( dir_entry_ptr == NULL )
{
break;
}
/*
** Search in all entries within this sector
*/
for ( i = (uint16_t) INDEX_TO_OFFSET(current_index), dir_entry_ptr += i ; i < entries_per_sector && found == FALSE; i++ )
{
if ( *dir_entry_ptr->NAME == '\0' ) /* if NEVER USED entry */
{
if ( file_ptr ) /* If not NULL */
{
if ( !*file_ptr ) /* but "" */
{
/* we found it */
found = TRUE;
break;
}
}
return(NULL); /* Anyway, stop here-never used entry */
/* if the entry is relevant at all */
}
else if ( (unsigned char) *dir_entry_ptr->NAME == MFS_DEL_FILE )
{
/* If DELETED */
if ( file_ptr ) /* If not NULL */
{
if ( !*file_ptr ) /* but "" */
{
found = TRUE; /* we found it */
break;
}
}
}
else /* If REGULAR ENTRY */
{
if ( file_ptr == NULL || *file_ptr )
{
if ( MFS_Attribute_match(mqx_dtohc(dir_entry_ptr->ATTRIBUTE),
attribute) == TRUE )
{
if ( !file_ptr )
{
found = TRUE;
break;
}
else if ( lfn_flag ) /* Searching for a long name */
{
if ( found_lfn )
{
found = TRUE;
break;
}
if ( !MFS_Attribute_match(mqx_dtohc(dir_entry_ptr->ATTRIBUTE),
MFS_ATTR_LFN) )
{
maybe = TRUE; /* Reset maybe */
dir_entry_ptr++;
current_index++;
continue; /* Not an LFN entry, skip it */
}
if ( !maybe )
{
dir_entry_ptr++;
current_index++;
continue;
}
int chunk_len;
chunk_len = MFS_lfn_extract((MFS_LNAME_ENTRY_PTR)dir_entry_ptr, lfn_entry);
if(lfn_ptr >= (file_ptr + chunk_len))
{
lfn_ptr -= chunk_len;
if ( strncmp(lfn_entry, lfn_ptr, chunk_len) )
{
lfn_ptr = file_ptr + lfn_len; /* reset ptr */
maybe = FALSE;
dir_entry_ptr++;
current_index++;
continue; /* Strings don't match */
}
if ( lfn_ptr == file_ptr )
{
found_lfn = TRUE;
if ( dirname )
{
attribute = ATTR_EXCLUSIVE | MFS_ATTR_DIR_NAME;
}
}
}
else
{
maybe = FALSE;
lfn_ptr = file_ptr + lfn_len; /* reset ptr */
}
}
else /* Searching for a short name */
{
found = MFS_Wildcard_match(fs_file, dir_entry_ptr->NAME);
}
}
else
{
if ( lfn_flag )
{
attribute = MFS_ATTR_LFN;
lfn_ptr = file_ptr + lfn_len; /* reset ptr */
maybe = TRUE;
found_lfn = FALSE;
}
}
}
}
if ( found == FALSE )
{
dir_entry_ptr++;
current_index++;
}
}
}
if ( found == FALSE )
{
error_code = MFS_Increment_dir_index(drive_ptr, ¤t_cluster, ¤t_index, &prev_cluster);
if ( error_code )
{
break;
}
}
} while ( found == FALSE && dir_entry_ptr && current_cluster != CLUSTER_EOF && current_cluster != CLUSTER_INVALID );
if ( found == FALSE )
{
dir_entry_ptr = NULL;
}
else
{
*start_cluster_ptr = current_cluster;
*prev_cluster_ptr = prev_cluster;
*dir_index_ptr = current_index;
}
if ( error_ptr )
{
*error_ptr = error_code;
}
return(dir_entry_ptr);
}
MFS_DIR_ENTRY_PTR MFS_Create_directory_entry
(
MFS_DRIVE_STRUCT_PTR drive_ptr, /*[IN] the drive on which to operate */
char_ptr filename_ptr, /*[IN] pointer to the file's name */
char attribute, /*[IN] attribute to be assigned to the file */
uint_32_ptr dir_cluster_ptr, /*[IN/OUT] indicates cluster in which the entry was put.*/
uint_32_ptr dir_index_ptr, /*[IN/OUT] index of the location of new file within the directory */
uint_32_ptr error_ptr /*[IN/OUT] error_return_address */
)
{
MFS_DIR_ENTRY_PTR dir_entry_ptr, dir_entry_ptr1;
MFS_DIR_ENTRY_PTR temp_entry_ptr;
TIME_STRUCT time;
DATE_STRUCT clk_time;
uint_32 dir_index, saved_index, temp_index;
uint_32 entry_cluster, saved_cluster, temp_cluster;
uint_32 needed_entries, i;
int_32 length;
boolean found_all = FALSE;
char temp_name[SFILENAME_SIZE+1], short_name[SFILENAME_SIZE+1];
uchar checksum = 0;
uint_32 prev_cluster= CLUSTER_INVALID, saved_prev_cluster, temp_prev_cluster;
dir_entry_ptr = NULL;
entry_cluster = *dir_cluster_ptr;
dir_index = 0;
/*
** Check for duplicate file
*/
if ( filename_ptr == NULL )
{
*error_ptr = MFS_INVALID_PARAMETER;
}
else if ( *filename_ptr == '\0' )
{
*error_ptr = MFS_FILE_NOT_FOUND;
}
#if MFSCFG_READ_ONLY_CHECK
else if (MFS_is_read_only (NULL, drive_ptr))
{
*error_ptr = MFS_DISK_IS_WRITE_PROTECTED;
}
#endif
else if ( (dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, filename_ptr,
&entry_cluster, &dir_index, &prev_cluster, MFS_ATTR_ANY, error_ptr)) != NULL )
{
*error_ptr = MFS_FILE_EXISTS;
}
else
{
/*
** Search for an empty slot
*/
dir_index = 0;
dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, attribute, error_ptr);
if ( MFS_Dirname_valid(filename_ptr) )
{
found_all = TRUE;
}
if ( dir_entry_ptr == NULL && !*error_ptr )
{
found_all = TRUE;
}
/*
** Save it now because we might not go into the while loop
** If we don't go into while, we lose original values when these
** variables are restored after the while loop
*/
saved_cluster = entry_cluster;
saved_index = dir_index;
while ( !found_all )
{
/* Calculate the amount of extra entries needed for LFN's */
saved_cluster = entry_cluster;
saved_index = dir_index;
for ( needed_entries = (strlen(filename_ptr) + 12) / 13; needed_entries >= 1 && !found_all; needed_entries-- )
{
*error_ptr = MFS_Increment_dir_index(drive_ptr, &entry_cluster, &dir_index, NULL);
if ( entry_cluster == CLUSTER_EOF && !*error_ptr )
{
/* This means the LFN will span a cluster. */
found_all = TRUE;
break;
}
temp_index = dir_index;
temp_cluster = entry_cluster;
temp_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, MFS_ATTR_ANY,error_ptr);
if ( *error_ptr )
{
return NULL;
}
if ( !temp_entry_ptr )
{
found_all = TRUE;
dir_entry_ptr = NULL;
break;
}
else if ( dir_index == temp_index && temp_cluster == entry_cluster )
{
continue;
}
else
{
break;
}
}
if ( needed_entries == 0 )
{
found_all = TRUE;
}
if ( found_all )
{
dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &saved_cluster, &saved_index, &saved_prev_cluster, MFS_ATTR_ANY,error_ptr);
}
}
entry_cluster = saved_cluster;
dir_index = saved_index;
if ( dir_entry_ptr == NULL && !*error_ptr )
{
/*
** Empty spot not found... get a new cluster and use the first entry.
*/
dir_index = 0;
if ( entry_cluster == 0 )
{
*error_ptr = MFS_ROOT_DIR_FULL;
return(NULL);
}
else
{
*error_ptr = MFS_Add_cluster_to_chain(drive_ptr, entry_cluster, &entry_cluster);
if ( *error_ptr == MFS_NO_ERROR )
{
*error_ptr = MFS_Clear_cluster(drive_ptr, entry_cluster);
if ( *error_ptr )
{
return(NULL);
}
dir_entry_ptr = (pointer) drive_ptr->DIR_SECTOR_PTR;
*error_ptr = MFS_Write_back_fat(drive_ptr);
if ( *error_ptr )
{
return(NULL);
}
}
}
}
}
if ( *error_ptr == MFS_NO_ERROR )
{
/* At this point we have one of the following cases
**
** 1. We have a normal 8.3 filename and an empty slot for it
** 2. We have a LFN, and a slot which has enough consecutive free slots
** to store the LFN, followed by the actual entry
*/
/* If the file is a normal 8.3 file */
if ( MFS_Dirname_valid(filename_ptr) )
{
_mem_zero(dir_entry_ptr, sizeof (MFS_DIR_ENTRY));
htodc(dir_entry_ptr->ATTRIBUTE, attribute);
MFS_Expand_dotfile(filename_ptr, dir_entry_ptr->NAME);
_time_get(&time);
_time_to_date(&time, &clk_time);
NORMALIZE_DATE(&clk_time);
htods(dir_entry_ptr->TIME, PACK_TIME(clk_time));
htods(dir_entry_ptr->DATE, PACK_DATE(clk_time));
drive_ptr->DIR_SECTOR_DIRTY = TRUE;
}
else
{
/* Case where the file is a LFN */
length = strlen(filename_ptr);
/* Get the 8.3 name and calculate the checksum */
temp_index = 0;
temp_cluster = *dir_cluster_ptr;
*error_ptr = MFS_lfn_to_sfn(filename_ptr, temp_name);
if ( !*error_ptr )
{
do
{
dir_entry_ptr1 = MFS_Find_directory_entry(drive_ptr, temp_name, &temp_cluster, &temp_index, &temp_prev_cluster, MFS_ATTR_ANY, error_ptr);
if ( !*error_ptr && dir_entry_ptr1 != NULL )
{
MFS_increment_lfn(temp_name);
temp_index = 0;
}
} while ( !*error_ptr && dir_entry_ptr1 != NULL );
dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, attribute, error_ptr);
/*
** The memory should be cleared after finding the directory entry.
*/
_mem_zero(dir_entry_ptr, sizeof (MFS_DIR_ENTRY));
/* Setup the final slot */
((MFS_LNAME_ENTRY_PTR) dir_entry_ptr)->ID |= MFS_LFN_END;
drive_ptr->DIR_SECTOR_DIRTY = TRUE;
MFS_Expand_dotfile(temp_name,short_name);
checksum = MFS_lfn_checksum(short_name);
}
while ( length && !*error_ptr )
{
i = length - ((length -1) % 13 + 1);
*error_ptr = MFS_lfn_name_to_entry(filename_ptr + i, (MFS_LNAME_ENTRY_PTR) dir_entry_ptr);
/* Set the entry number, the checksum value and the attribute */
((MFS_LNAME_ENTRY_PTR) dir_entry_ptr)->ID |= (length + 12) / 13;
((MFS_LNAME_ENTRY_PTR) dir_entry_ptr)->ALIAS_CHECKSUM= checksum;
((MFS_LNAME_ENTRY_PTR) dir_entry_ptr)->ATTR = MFS_ATTR_LFN;
drive_ptr->DIR_SECTOR_DIRTY = TRUE;
length -= (length - i);
if ( length < 0 )
{
length = 0;
}
if ( length && !*error_ptr )
{
dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, attribute, error_ptr);
if ( dir_entry_ptr == NULL && !*error_ptr )
{
/* No empty spots... We need to get a new cluster */
dir_index = 0;
if ( entry_cluster == 0 )
{
*error_ptr = MFS_ROOT_DIR_FULL;
return(NULL);
}
else
{
*error_ptr = MFS_Add_cluster_to_chain( drive_ptr, entry_cluster, &entry_cluster);
if ( *error_ptr == MFS_NO_ERROR )
{
*error_ptr = MFS_Clear_cluster(drive_ptr, entry_cluster);
if ( *error_ptr )
{
return(NULL);
}
dir_entry_ptr = (pointer) drive_ptr->DIR_SECTOR_PTR;
*error_ptr = MFS_Write_back_fat(drive_ptr);
if ( *error_ptr )
{
return(NULL);
}
}
}
}
_mem_zero(dir_entry_ptr, sizeof (MFS_DIR_ENTRY));
drive_ptr->DIR_SECTOR_DIRTY = TRUE;
}
}
/* LFN is written, so write the actual entry */
if ( !*error_ptr )
{
dir_entry_ptr = MFS_Find_directory_entry(drive_ptr, "", &entry_cluster, &dir_index, &prev_cluster, attribute, error_ptr);
if ( dir_entry_ptr == NULL && !*error_ptr )
{
dir_index = 0;
if ( entry_cluster == 0 )
{
*error_ptr = MFS_ROOT_DIR_FULL;
return(NULL);
}
else
{
*error_ptr = MFS_Add_cluster_to_chain( drive_ptr, entry_cluster, &entry_cluster);
if ( *error_ptr == MFS_NO_ERROR )
{
*error_ptr = MFS_Clear_cluster(drive_ptr, entry_cluster);
if ( *error_ptr )
{
return(NULL);
}
dir_entry_ptr = (pointer) drive_ptr->DIR_SECTOR_PTR;
*error_ptr = MFS_Write_back_fat(drive_ptr);
if ( *error_ptr )
{
return(NULL);
}
}
}
}
_mem_zero(dir_entry_ptr, sizeof (MFS_DIR_ENTRY));
htodc(dir_entry_ptr->ATTRIBUTE, attribute);
MFS_Expand_dotfile(temp_name, dir_entry_ptr->NAME);
_time_get(&time);
_time_to_date(&time, &clk_time);
NORMALIZE_DATE(&clk_time);
htods(dir_entry_ptr->TIME, PACK_TIME(clk_time));
htods(dir_entry_ptr->DATE, PACK_DATE(clk_time));
drive_ptr->DIR_SECTOR_DIRTY = TRUE;
}
}
if ( *error_ptr )
{
return(NULL);
}
}
*dir_cluster_ptr = entry_cluster;
*dir_index_ptr = dir_index;
return(dir_entry_ptr);
}
