Merge branch 'master' into 8bitsound

Conflicts:
	source/nds/entry.cpp

1 files changed, 672 insertions, 0 deletions

diff --git a/sdk-modifications/libsrc/fs/fatdir.c b/sdk-modifications/libsrc/fs/fatdir.c
new file mode 100644
index 0000000..dc9b914
--- /dev/null
+++ b/sdk-modifications/libsrc/fs/fatdir.c
@@ -0,0 +1,672 @@
+/*

+ fatdir.c

+

+ Functions used by the newlib disc stubs to interface with

+ this library

+

+ Copyright (c) 2006 Michael "Chishm" Chisholm

+

+ Redistribution and use in source and binary forms, with or without modification,

+ are permitted provided that the following conditions are met:

+

+  1. Redistributions of source code must retain the above copyright notice,

+     this list of conditions and the following disclaimer.

+  2. Redistributions in binary form must reproduce the above copyright notice,

+     this list of conditions and the following disclaimer in the documentation and/or

+     other materials provided with the distribution.

+  3. The name of the author may not be used to endorse or promote products derived

+     from this software without specific prior written permission.

+

+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED

+ WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY

+ AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE

+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

+	2006-08-13 - Chishm

+		* Moved all externally visible directory related functions to fatdir

+		* Added _FAT_mkdir_r

+

+	2006-08-14 - Chishm

+		* Added directory iterator functions

+

+	2006-08-19 - Chishm

+		* Updated dirnext return values to return correctly

+

+	2006-10-01 - Chishm

+		* Now clears the whole cluster when creating a new directory, bug found by Hermes

+

+	2007-01-10 - Chishm

+		* Updated directory iterator functions for DevkitPro r20

+*/

+

+/*

+	2010.06.30

+		* Modify _FAT_diropen_r,

+*/

+

+#include <string.h>

+#include <errno.h>

+#include <ctype.h>

+#include <unistd.h>

+#include <sys/dir.h>

+

+#include "fatdir.h"

+

+#include "fs_cache.h"

+#include "file_allocation_table.h"

+#include "partition.h"

+#include "directory.h"

+#include "bit_ops.h"

+#include "filetime.h"

+#include "fs_unicode.h"

+

+

+int _FAT_stat_r (struct _reent *r, const char *path, struct stat *st) {

+	PARTITION* partition = NULL;

+

+	DIR_ENTRY dirEntry;

+

+	// Get the partition this file is on

+	partition = _FAT_partition_getPartitionFromPath (path);

+

+	if (partition == NULL) {

+		r->_errno = ENODEV;

+		return -1;

+	}

+

+	// Move the path pointer to the start of the actual path

+	if (strchr (path, ':') != NULL) {

+		path = strchr (path, ':') + 1;

+	}

+	if (strchr (path, ':') != NULL) {

+		r->_errno = EINVAL;

+		return -1;

+	}

+

+	// Search for the file on the disc

+	if (!_FAT_directory_entryFromPath (partition, &dirEntry, path, NULL)) {

+		r->_errno = ENOENT;

+		return -1;

+	}

+

+	// Fill in the stat struct

+	_FAT_directory_entryStat (partition, &dirEntry, st);

+

+	return 0;

+}

+

+int _FAT_getshortname_r (struct _reent *r, const char *name, char *outName) {

+	PARTITION* partition = NULL;

+	DIR_ENTRY DirEntry;

+	u32 dirCluster;

+

+	// Get the partition this directory is on

+	partition = _FAT_partition_getPartitionFromPath (name);

+

+	if (partition == NULL) {

+		r->_errno = ENODEV;

+		return 1;

+	}

+

+	// Move the path pointer to the start of the actual path

+	if (strchr (name, ':') != NULL) {

+		name = strchr (name, ':') + 1;

+	}

+	if (strchr (name, ':') != NULL) {

+		r->_errno = EINVAL;

+		return 1;

+	}

+

+	// Search for the file on the disc

+	if (!_FAT_directory_entryFromPath (partition, &DirEntry, name, NULL)) {

+		r->_errno = ENOENT;

+		return 1;

+	}

+

+	strcpy(outName, DirEntry.entryData);

+	return 1;

+}

+

+int _FAT_link_r (struct _reent *r, const char *existing, const char *newLink) {

+	r->_errno = ENOTSUP;

+	return -1;

+}

+

+int _FAT_unlink_r (struct _reent *r, const char *path) {

+	PARTITION* partition = NULL;

+	DIR_ENTRY dirEntry;

+	DIR_ENTRY dirContents;

+	u32 cluster;

+	bool nextEntry;

+	bool errorOccured = false;

+

+	// Get the partition this directory is on

+	partition = _FAT_partition_getPartitionFromPath (path);

+

+	if (partition == NULL) {

+		r->_errno = ENODEV;

+		return -1;

+	}

+

+	// Make sure we aren't trying to write to a read-only disc

+	if (partition->readOnly) {

+		r->_errno = EROFS;

+		return -1;

+	}

+

+	// Move the path pointer to the start of the actual path

+	if (strchr (path, ':') != NULL) {

+		path = strchr (path, ':') + 1;

+	}

+	if (strchr (path, ':') != NULL) {

+		r->_errno = EINVAL;

+		return -1;

+	}

+

+	// Search for the file on the disc

+	if (!_FAT_directory_entryFromPath (partition, &dirEntry, path, NULL)) {

+		r->_errno = ENOENT;

+		return -1;

+	}

+

+	cluster = _FAT_directory_entryGetCluster (dirEntry.entryData);

+

+

+	// If this is a directory, make sure it is empty

+	if (_FAT_directory_isDirectory (&dirEntry)) {

+		nextEntry = _FAT_directory_getFirstEntry (partition, &dirContents, cluster);

+

+		while (nextEntry) {

+			if (!_FAT_directory_isDot (&dirContents)) {

+				// The directory had something in it that isn't a reference to itself or it's parent

+				r->_errno = EPERM;

+				return -1;

+			}

+			nextEntry = _FAT_directory_getNextEntry (partition, &dirContents);

+		}

+	}

+

+	if (cluster != CLUSTER_FREE) {

+		// Remove the cluster chain for this file

+		if (!_FAT_fat_clearLinks (partition, cluster)) {

+			r->_errno = EIO;

+			errorOccured = true;

+		}

+	}

+

+	// Remove the directory entry for this file

+	if (!_FAT_directory_removeEntry (partition, &dirEntry)) {

+		r->_errno = EIO;

+		errorOccured = true;

+	}

+

+	// Flush any sectors in the disc cache

+	if (!_FAT_cache_flush(partition->cache)) {

+		r->_errno = EIO;

+		errorOccured = true;

+	}

+

+	if (errorOccured) {

+		return -1;

+	} else {

+		return 0;

+	}

+}

+

+int _FAT_chdir_r (struct _reent *r, const char *path) {

+	PARTITION* partition = NULL;

+

+	// Get the partition this directory is on

+	partition = _FAT_partition_getPartitionFromPath (path);

+

+	if (partition == NULL) {

+		r->_errno = ENODEV;

+		return -1;

+	}

+

+	// Move the path pointer to the start of the actual path

+	if (strchr (path, ':') != NULL) {

+		path = strchr (path, ':') + 1;

+	}

+	if (strchr (path, ':') != NULL) {

+		r->_errno = EINVAL;

+		return -1;

+	}

+

+	// Set the default device to match this one

+	if (!_FAT_partition_setDefaultPartition (partition)) {

+		r->_errno = ENOENT;

+		return -1;

+	}

+

+	// Try changing directory

+	if (_FAT_directory_chdir (partition, path)) {

+		// Successful

+		return 0;

+	} else {

+		// Failed

+		r->_errno = ENOTDIR;

+		return -1;

+	}

+}

+

+int _FAT_rename_r (struct _reent *r, const char *oldName, const char *newName) {

+	PARTITION* partition = NULL;

+	DIR_ENTRY oldDirEntry;

+	DIR_ENTRY newDirEntry;

+	const char *pathEnd;

+	u32 dirCluster;

+

+	// Get the partition this directory is on

+	partition = _FAT_partition_getPartitionFromPath (oldName);

+

+	if (partition == NULL) {

+		r->_errno = ENODEV;

+		return -1;

+	}

+

+	// Make sure the same partition is used for the old and new names

+	if (partition != _FAT_partition_getPartitionFromPath (newName)) {

+		r->_errno = EXDEV;

+		return -1;

+	}

+

+	// Make sure we aren't trying to write to a read-only disc

+	if (partition->readOnly) {

+		r->_errno = EROFS;

+		return -1;

+	}

+

+	// Move the path pointer to the start of the actual path

+	if (strchr (oldName, ':') != NULL) {

+		oldName = strchr (oldName, ':') + 1;

+	}

+	if (strchr (oldName, ':') != NULL) {

+		r->_errno = EINVAL;

+		return -1;

+	}

+	if (strchr (newName, ':') != NULL) {

+		newName = strchr (newName, ':') + 1;

+	}

+	if (strchr (newName, ':') != NULL) {

+		r->_errno = EINVAL;

+		return -1;

+	}

+

+	// Search for the file on the disc

+	if (!_FAT_directory_entryFromPath (partition, &oldDirEntry, oldName, NULL)) {

+		r->_errno = ENOENT;

+		return -1;

+	}

+

+	// Make sure there is no existing file / directory with the new name

+	if (_FAT_directory_entryFromPath (partition, &newDirEntry, newName, NULL)) {

+		r->_errno = EEXIST;

+		return -1;

+	}

+

+	// Create the new file entry

+	// Get the directory it has to go in

+	pathEnd = strrchr (newName, DIR_SEPARATOR);

+	if (pathEnd == NULL) {

+		// No path was specified

+		dirCluster = partition->cwdCluster;

+		pathEnd = newName;

+	} else {

+		// Path was specified -- get the right dirCluster

+		// Recycling newDirEntry, since it needs to be recreated anyway

+		if (!_FAT_directory_entryFromPath (partition, &newDirEntry, newName, pathEnd) ||

+			!_FAT_directory_isDirectory(&newDirEntry)) {

+			r->_errno = ENOTDIR;

+			return -1;

+		}

+		dirCluster = _FAT_directory_entryGetCluster (newDirEntry.entryData);

+		// Move the pathEnd past the last DIR_SEPARATOR

+		pathEnd += 1;

+	}

+

+	// Copy the entry data

+	memcpy (&newDirEntry, &oldDirEntry, sizeof(DIR_ENTRY));

+

+	// Set the new name

+	strncpy (newDirEntry.d_name, pathEnd, MAX_FILENAME_LENGTH - 1);

+

+	// Write the new entry

+	if (!_FAT_directory_addEntry (partition, &newDirEntry, dirCluster)) {

+		r->_errno = ENOSPC;

+		return -1;

+	}

+

+	// Remove the old entry

+	if (!_FAT_directory_removeEntry (partition, &oldDirEntry)) {

+		r->_errno = EIO;

+		return -1;

+	}

+

+	// Flush any sectors in the disc cache

+	if (!_FAT_cache_flush (partition->cache)) {

+		r->_errno = EIO;

+		return -1;

+	}

+

+	return 0;

+}

+

+int _FAT_hideAttrib_r (struct _reent *r, const char *name, u8 hide) {

+	PARTITION* partition = NULL;

+	DIR_ENTRY oldDirEntry;

+	DIR_ENTRY newDirEntry;

+	u32 dirCluster;

+

+	// Get the partition this directory is on

+	partition = _FAT_partition_getPartitionFromPath (name);

+

+	if (partition == NULL) {

+		r->_errno = ENODEV;

+		return -1;

+	}

+

+	// Make sure we aren't trying to write to a read-only disc

+	if (partition->readOnly) {

+		r->_errno = EROFS;

+		return -1;

+	}

+

+	// Move the path pointer to the start of the actual path

+	if (strchr (name, ':') != NULL) {

+		name = strchr (name, ':') + 1;

+	}

+	if (strchr (name, ':') != NULL) {

+		r->_errno = EINVAL;

+		return -1;

+	}

+

+	// Search for the file on the disc

+	if (!_FAT_directory_entryFromPath (partition, &oldDirEntry, name, NULL)) {

+		r->_errno = ENOENT;

+		return -1;

+	}

+

+	// Create the new file entry

+	// Get the directory it has to go in

+	memcpy (&newDirEntry, &oldDirEntry, sizeof(DIR_ENTRY));

+

+	// No path was specified

+	dirCluster = partition->cwdCluster;

+

+	// Remove the old entry hopefully doesn't screw things up...

+	if (!_FAT_directory_removeEntry (partition, &oldDirEntry)) {

+		r->_errno = EIO;

+		return -1;

+	}

+

+	// Set the new attribute

+	if(hide)

+		newDirEntry.entryData[DIR_ENTRY_attributes] |= ATTRIB_HID;

+	else

+		newDirEntry.entryData[DIR_ENTRY_attributes] &= ~ATTRIB_HID;

+

+	// Write the new entry

+	if (!_FAT_directory_addEntry (partition, &newDirEntry, dirCluster)) {

+		r->_errno = ENOSPC;

+		return -1;

+	}

+

+	// Flush any sectors in the disc cache

+	if (!_FAT_cache_flush (partition->cache)) {

+		r->_errno = EIO;

+		return -1;

+	}

+

+	return 0;

+}

+

+int _FAT_mkdir_r (struct _reent *r, const char *path, int mode) {

+	PARTITION* partition = NULL;

+	bool fileExists;

+	DIR_ENTRY dirEntry;

+	const char* pathEnd;

+	u32 parentCluster, dirCluster;

+	u8 newEntryData[DIR_ENTRY_DATA_SIZE];

+

+	partition = _FAT_partition_getPartitionFromPath (path);

+	if (partition == NULL) {

+		r->_errno = ENODEV;

+		return -1;

+	}

+

+	// Move the path pointer to the start of the actual path

+	if (strchr (path, ':') != NULL) {

+		path = strchr (path, ':') + 1;

+	}

+	if (strchr (path, ':') != NULL) {

+		r->_errno = EINVAL;

+		return -1;

+	}

+

+	// Search for the file/directory on the disc

+	fileExists = _FAT_directory_entryFromPath (partition, &dirEntry, path, NULL);

+

+	// Make sure it doesn't exist

+	if (fileExists) {

+		r->_errno = EEXIST;

+		return -1;

+	}

+

+	if (partition->readOnly) {

+		// We can't write to a read-only partition

+		r->_errno = EROFS;

+		return -1;

+	}

+

+	// Get the directory it has to go in

+	pathEnd = strrchr (path, DIR_SEPARATOR);

+	if (pathEnd == NULL) {

+		// No path was specified

+		parentCluster = partition->cwdCluster;

+		pathEnd = path;

+	} else {

+		// Path was specified -- get the right parentCluster

+		// Recycling dirEntry, since it needs to be recreated anyway

+		if (!_FAT_directory_entryFromPath (partition, &dirEntry, path, pathEnd) ||

+			!_FAT_directory_isDirectory(&dirEntry)) {

+			r->_errno = ENOTDIR;

+			return -1;

+		}

+		parentCluster = _FAT_directory_entryGetCluster (dirEntry.entryData);

+		// Move the pathEnd past the last DIR_SEPARATOR

+		pathEnd += 1;

+	}

+

+	// Create the entry data

+	strncpy (dirEntry.d_name, pathEnd, MAX_FILENAME_LENGTH - 1);

+	memset (dirEntry.entryData, 0, DIR_ENTRY_DATA_SIZE);

+

+	// Set the creation time and date

+	dirEntry.entryData[DIR_ENTRY_cTime_ms] = 0;

+	u16_to_u8array (dirEntry.entryData, DIR_ENTRY_cTime, _FAT_filetime_getTimeFromRTC());

+	u16_to_u8array (dirEntry.entryData, DIR_ENTRY_cDate, _FAT_filetime_getDateFromRTC());

+

+	// Set the directory attribute

+	dirEntry.entryData[DIR_ENTRY_attributes] = ATTRIB_DIR;

+

+	// Get a cluster for the new directory

+	dirCluster = _FAT_fat_linkFreeClusterCleared (partition, CLUSTER_FREE);

+	if (dirCluster == CLUSTER_FREE) {

+		// No space left on disc for the cluster

+		r->_errno = ENOSPC;

+		return -1;

+	}

+	u16_to_u8array (dirEntry.entryData, DIR_ENTRY_cluster, dirCluster);

+	u16_to_u8array (dirEntry.entryData, DIR_ENTRY_clusterHigh, dirCluster >> 16);

+

+	// Write the new directory's entry to it's parent

+	if (!_FAT_directory_addEntry (partition, &dirEntry, parentCluster)) {

+		r->_errno = ENOSPC;

+		return -1;

+	}

+

+	// Create the dot entry within the directory

+	memset (newEntryData, 0, DIR_ENTRY_DATA_SIZE);

+	memset (newEntryData, ' ', 11);

+	newEntryData[DIR_ENTRY_name] = '.';

+	newEntryData[DIR_ENTRY_attributes] = ATTRIB_DIR;

+	u16_to_u8array (newEntryData, DIR_ENTRY_cluster, dirCluster);

+	u16_to_u8array (newEntryData, DIR_ENTRY_clusterHigh, dirCluster >> 16);

+

+	// Write it to the directory, erasing that sector in the process

+	_FAT_cache_eraseWritePartialSector ( partition->cache, newEntryData,

+		_FAT_fat_clusterToSector (partition, dirCluster), 0, DIR_ENTRY_DATA_SIZE);

+

+

+	// Create the double dot entry within the directory

+	newEntryData[DIR_ENTRY_name + 1] = '.';

+	u16_to_u8array (newEntryData, DIR_ENTRY_cluster, parentCluster);

+	u16_to_u8array (newEntryData, DIR_ENTRY_clusterHigh, parentCluster >> 16);

+

+	// Write it to the directory

+	_FAT_cache_writePartialSector ( partition->cache, newEntryData,

+		_FAT_fat_clusterToSector (partition, dirCluster), DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE);

+

+	// Flush any sectors in the disc cache

+	if (!_FAT_cache_flush(partition->cache)) {

+		r->_errno = EIO;

+		return -1;

+	}

+

+	return 0;

+}

+

+DIR_STATE_STRUCT* _FAT_diropen_r(struct _reent *r, DIR_STATE_STRUCT *dirState, const char *path) {

+	DIR_ENTRY dirEntry;

+	DIR_STATE_STRUCT* state = dirState;

+	bool fileExists;

+	const char* root_path= "/";

+

+	state->partition = _FAT_partition_getPartitionFromPath (path);

+	if (state->partition == NULL) {

+		r->_errno = ENODEV;

+		return NULL;

+	}

+

+	// Move the path pointer to the start of the actual path

+	if (strchr (path, ':') != NULL) {

+		path = strchr (path, ':') + 1;

+	}

+	if (strchr (path, ':') != NULL) {

+		r->_errno = EINVAL;

+		return NULL;

+	}

+

+	if('\0' == path[0]) path = root_path;

+

+	// Get the start cluster of the directory

+	fileExists = _FAT_directory_entryFromPath (state->partition, &dirEntry, path, NULL);

+	if (!fileExists) {

+		r->_errno = ENOENT;

+		return NULL;

+	}

+

+	// Make sure it is a directory

+	if (! _FAT_directory_isDirectory (&dirEntry)) {

+		r->_errno = ENOTDIR;

+		return NULL;

+	}

+

+	// Save the start cluster for use when resetting the directory data

+	state->startCluster = _FAT_directory_entryGetCluster (dirEntry.entryData);

+

+	//Entry location pointer

+	state->posEntry = 0;

+

+//	// Get the first entry for use with a call to dirnext

+//	state->validEntry =

+//		_FAT_directory_getFirstEntry (state->partition, &(state->currentEntry), state->startCluster);

+	state->validEntry = false;

+

+	// We are now using this entry

+	state->inUse = true;

+	return state;

+}

+

+int _FAT_dirreset_r (struct _reent *r, DIR_STATE_STRUCT *dirState) {

+	DIR_STATE_STRUCT* state = dirState;

+

+	// Make sure we are still using this entry

+	if (!state->inUse) {

+		r->_errno = EBADF;

+		return -1;

+	}

+

+	// Get the first entry for use with a call to dirnext

+//	state->validEntry =

+//		_FAT_directory_getFirstEntry (state->partition, &(state->currentEntry), state->startCluster);

+

+	state->posEntry = 0;

+

+	return 0;

+}

+

+int _FAT_dirnext_r (struct _reent *r, DIR_STATE_STRUCT *dirState, struct stat *filestat) {

+	DIR_STATE_STRUCT* state = dirState;

+

+	// Make sure we are still using this entry

+	if (!state->inUse) {

+		r->_errno = EBADF;

+		return -1;

+	}

+

+	// Make sure there is another file to report on

+//	if (!state->validEntry) {

+//		r->_errno = ENOENT;

+//		return -1;

+//	}

+

+	if(0 == state->posEntry) {

+		state->validEntry = _FAT_directory_getFirstEntry (state->partition, &(state->currentEntry), state->startCluster);

+	}

+	else

+		state->validEntry = _FAT_directory_getNextEntry (state->partition, &(state->currentEntry));

+

+	state->posEntry += 1;

+

+	if(!state->validEntry)

+	{

+		r->_errno = ENOENT;

+		return -1;

+	}

+

+	if (filestat != NULL) {

+		_FAT_directory_entryStat (state->partition, &(state->currentEntry), filestat);

+	}

+

+	return 0;

+/*

+	// Get the filename

+	strncpy (filename, state->currentEntry.d_name, MAX_FILENAME_LENGTH);

+	// Get the stats, if requested

+	if (filestat != NULL) {

+		_FAT_directory_entryStat (state->partition, &(state->currentEntry), filestat);

+	}

+

+	// Look for the next entry for use next time

+	state->validEntry =

+		_FAT_directory_getNextEntry (state->partition, &(state->currentEntry));

+

+	return 0;

+*/

+}

+

+int _FAT_dirclose_r (struct _reent *r, DIR_STATE_STRUCT *dirState) {

+	DIR_STATE_STRUCT* state = dirState;

+

+	// We are no longer using this entry

+	state->inUse = false;

+

+	return 0;

+}