6502.org

Code: Select all

$ sudo dd if=/dev/sda of=cleanfmt bs=4096
125118+0 records in
125118+0 records out
512483328 bytes (512 MB, 489 MiB) copied, 53,8369 s, 9,5 MB/s

Code: Select all

$ fdisk -lu cleanfmt 
Disk cleanfmt: 488,74 MiB, 512483328 bytes, 1000944 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xc5980b8b

Device     Boot  Start    End Sectors  Size Id Type
cleanfmt1         2048 960511  958464  468M  b W95 FAT32
cleanfmt2       960512 999423   38912   19M 83 Linux

Code: Select all

$ sudo mount -o loop,offset=1048576 cleanfmt /media/barnacle/t

Code: Select all

void timeanddate (void)
{
	// put the current time and date into global mstime, msdate.
	// FAT32 requires hundredths of a second also, but we will set to zero
	time_t tadr;
	struct tm * tad;

	time (&tadr);					// get the linux epoch seconds count
	tad = localtime(&tadr);			// convert to time and day
	// we need to convert the tad values to ms compressed style.
	mstime = (tad->tm_sec/2) +		// we only count every second second
			(tad->tm_min << 5) +
			(tad->tm_hour << 11);
	msdate = tad->tm_mday +				// range 1-31
			((tad->tm_mon + 1) << 5) + 	// range 0-11 but we need 1-12
			((tad->tm_year - 80) << 9);	// epoch is 1900 but we need epoch 1980
}

Code: Select all

typedef struct {
    uint32_t    sector;				// lba sector address
    uint16_t    entry;				// pointer into transient to entry
    uint8_t		sec_in_cluster;		// which sector in this cluster are we in?
    uint32_t	cluster;			// what's the current cluster number?
} DIR_ENTRY;

Code: Select all

void fs_find_first (DIR_ENTRY * de)
{
	// find the first entry in the cwd which is neither deleted nor a long file
	// name, by preseting de and then calling fs_find_next.
    // works in the current cwd; sets de members on exit

    // note: we cannot simply return the first file; it will always be there
    // for a subdirectory (as '.') but in root may have been deleted, in which
    // case we should scan past it.
    // as fs_find_next starts by moving to the 'next' record, we fake the minus
    // oneth entry and then call fs_find_next to do the check.

    de->sector = cluster_to_1st_sector(cwd);
    de->entry = -32;
    de->sec_in_cluster = 0;
    de->cluster = next_cluster_number(cwd);
    fs_find_next(de);
}

Code: Select all

void fs_find_next (DIR_ENTRY * de)
{
	// using existing data in de, alter de to reflect the next directory entry
	// which is neither deleted nor has a long file name. de contains either a
	// pointer to a valid file, or to the first empty entry found (so first byte
	// of filename is 0x00)
	// Advances through successive sectors in a directory cluster, and if
	// necessary to subsequent clusters.
	// NOTE: we enter with de pointing at the last record found.

	read_sector(de->sector);
    while (1)
    {
		// move to next directory entry
		de->entry += 32;		// size of entry
		// increment the sector and cluster if necessary
		if (SECTOR_SIZE == de->entry)
		{
			// time for the next sector
			de->entry = 0;
			de->sector++;
			de->sec_in_cluster++;
			if (de->sec_in_cluster == sectors_per_cluster)
			{
				// we also need a new cluster
				de->sec_in_cluster = 0;
				if (0 != de->cluster)
				{
					// we are not looking at the end of the chain yet
					// so it's safe to use this next link
					de->sector = cluster_to_1st_sector(de->cluster);
					de->cluster = next_cluster_number(de->cluster);
				}
				else
				{
					// we need to allocate a new cluster
					de->sector = cluster_to_1st_sector(f_alloc());
					// this may be redundant since we know we're about to 
					// crash out on the new zero entry, but still...
					de->cluster = 0;
				}
			}
			read_sector(de->sector);
		}
		// now check the attribute byte to see if it's an LFN entry
		if (ATTR_LONG != transient[de->entry + DIR_ATTRIB])
		{
			// or is it perhaps deleted?
			if (0xe5 != transient[de->entry])
			{
				// nope, then we've found a valid entry
				// and de contains the pointers to it
				break;
			}
			// or zero, indicating no further entries?
			if (0 == transient[de->entry])
			{
				break;
			}
		}
	}
}