fsys_affs.c

open source bios with linux platform, very good and can be reused.

	{
		disk_read_func = disk_read_hook;
		cblock = getBlock(block);
		disk_read_func = 0;
		block = AROS_BE2LONG(extensionBlock(cblock)->extension);
		togo--;
	}
	if (togo)
		return 1;
	fsysb->file.current.block = block;
	return 0;
}

int affs_read(char *buf, int len) {
struct CacheBlock *cblock;
unsigned short size;
unsigned int readbytes = 0;

	if (fsysb->file.current.offset != filepos)
	{
		if (seek(filepos))
			return ERR_FILELENGTH;
	}
	if (fsysb->file.current.block == 0)
		return 0;
	if (len>(fsysb->file.filesize-fsysb->file.current.offset))
		len=fsysb->file.filesize-fsysb->file.current.offset;
	disk_read_func = disk_read_hook;
	cblock = getBlock(fsysb->file.current.block);
	disk_read_func = 0;
	while (len)
	{
		disk_read_func = disk_read_hook;
		if (fsysb->file.current.filekey<0)
		{
			fsysb->file.current.filekey = 71;
			fsysb->file.current.block = AROS_BE2LONG(extensionBlock(cblock)->extension);
			if (fsysb->file.current.block)
			{
				cblock = getBlock(fsysb->file.current.block);
			}
#warning "else shouldn't occour"
		}
		size = 512;
		size -= fsysb->file.current.byte;
		if (size>len)
		{
			size = len;
			devread
				(
					AROS_BE2LONG
					(
						extensionBlock(cblock)->filekey_table
							[fsysb->file.current.filekey]
					)+blockoffset,
					fsysb->file.current.byte, size, (char *)((int)buf+readbytes)
				);
			fsysb->file.current.byte += size;
		}
		else
		{
			devread
				(
					AROS_BE2LONG
					(
						extensionBlock(cblock)->filekey_table
							[fsysb->file.current.filekey]
					)+blockoffset,
					fsysb->file.current.byte, size, (char *)((int)buf+readbytes)
				);
			fsysb->file.current.byte = 0;
			fsysb->file.current.filekey--;
		}
		disk_read_func = 0;
		len -= size;
		readbytes += size;
	}
	fsysb->file.current.offset += readbytes;
	filepos = fsysb->file.current.offset;
	return readbytes;
}

unsigned char capitalch(unsigned char ch, unsigned char flags) {

	if ((flags==0) || (flags==1))
		return (unsigned char)((ch>='a') && (ch<='z') ? ch-('a'-'A') : ch);
	else		// DOS\(>=2)
		return (unsigned char)(((ch>=224) && (ch<=254) && (ch!=247)) ||
				 ((ch>='a') && (ch<='z')) ? ch-('a'-'A') : ch);
}

// str2 is a BCPL string
int noCaseStrCmp(char *str1, char *str2, unsigned char flags) {
unsigned char length;

	length=str2++[0];
	do {
		if ((*str1==0) && (length==0))
			return 0;
		length--;
//		if ((*str1==0) && (*str2==0)) return 1;
	} while (capitalch(*str1++,flags)==capitalch(*str2++,flags));
	str1--;
	return (*str1) ? 1 : -1;
}

unsigned int getHashKey(char *name,unsigned int tablesize, unsigned char flags) {
unsigned int length;
	
	length=0;
	while (name[length] != 0)
	    length++;
	while (*name!=0)
		length=(length * 13 +capitalch(*name++,flags)) & 0x7FF;
	return length%tablesize;
}

grub_error_t getHeaderBlock(char *name, struct CacheBlock **dirh) {
int key;

	key = getHashKey(name, 72, 1);
	if (!dirHeader(*dirh)->hashtable[key])
		return ERR_FILE_NOT_FOUND;
	*dirh = getBlock(AROS_BE2LONG(dirHeader(*dirh)->hashtable[key]));
	if (calcChkSum(128, (*dirh)->blockbuffer))
	{
#ifdef DEBUG_AFFS
printf("ghb: %d\n", (*dirh)->blocknum);
#endif
		return ERR_FSYS_CORRUPT;
	}
	if (AROS_BE2LONG(dirHeader(*dirh)->p_type) != T_SHORT)
		return ERR_BAD_FILETYPE;
	while (noCaseStrCmp(name,dirHeader(*dirh)->name,1) != 0)
	{
		if (!dirHeader(*dirh)->hashchain)
			return ERR_FILE_NOT_FOUND;
		*dirh = getBlock(AROS_BE2LONG(dirHeader(*dirh)->hashchain));
		if (calcChkSum(128, (*dirh)->blockbuffer))
		{
#ifdef DEBUG_AFFS
printf("ghb2: %d\n", (*dirh)->blocknum);
#endif
			return ERR_FSYS_CORRUPT;
		}
		if (AROS_BE2LONG(dirHeader(*dirh)->p_type) != T_SHORT)
			return ERR_BAD_FILETYPE;
	}
	return 0;
}

char *copyPart(char *src, char *dst) {

	while ((*src != '/') && (*src))
		*dst++ = *src++;
	if (*src == '/')
		src++;
	*dst-- = 0;
	/* cut off spaces at the end */
	while (*dst == ' ')
		*dst-- = 0;
	return src;
}

grub_error_t findBlock(char *name, struct CacheBlock **dirh) {
char dname[32];
int block;

	name++;	/* skip "/" */
	/* partition table part */
	if (rdbb < RDB_LOCATION_LIMIT)
	{
	int bpc;

		blockoffset = 0;
		*dirh = getBlock(rdbb);
		if (*name==0)
			return 0;
		name = copyPart(name, dname);
		bpc = AROS_BE2LONG(rdsk(*dirh)->rdb_Sectors)*AROS_BE2LONG(rdsk(*dirh)->rdb_Heads);
		block = AROS_BE2LONG(rdsk(*dirh)->rdb_PartitionList);
		while (block != -1)
		{
			*dirh = getBlock(block);
			if (noCaseStrCmp(dname, part(*dirh)->pb_DriveName, 1) == 0)
				break;
			block = AROS_BE2LONG(part(*dirh)->pb_Next);
		}
		if (block == -1)
			return ERR_FILE_NOT_FOUND;
		if	(
				((AROS_BE2LONG(part(*dirh)->pb_Environment[DE_DOSTYPE]) & 0xFFFFFF00)!=0x444F5300) ||
				((AROS_BE2LONG(part(*dirh)->pb_Environment[DE_DOSTYPE]) & 0xFF)==0)
			)
			return ERR_BAD_FILETYPE;
		blockoffset = AROS_BE2LONG(part(*dirh)->pb_Environment[DE_LOWCYL]);
		rootb = AROS_BE2LONG(part(*dirh)->pb_Environment[DE_HIGHCYL]);
		rootb = rootb-blockoffset+1; /* highcyl-lowcyl+1 */
		rootb *= bpc;
		rootb = rootb-1+AROS_BE2LONG(part(*dirh)->pb_Environment[DE_RESERVEDBLKS]);
		rootb /= 2;
		blockoffset *= bpc;
	}

	/* filesystem part */
	*dirh = getBlock(rootb);
	while (*name)
	{
		if (
				(AROS_BE2LONG(dirHeader(*dirh)->s_type) != ST_ROOT) &&
				(AROS_BE2LONG(dirHeader(*dirh)->s_type) != ST_USERDIR)
			)
			return ERR_BAD_FILETYPE;
		name = copyPart(name, dname);
		errnum = getHeaderBlock(dname, dirh);
		if (errnum)
			return errnum;
	}
	return 0;
}

void checkPossibility(char *filename, char *bstr) {

#ifndef STAGE1_5
	char cstr[32];

	if (noCaseStrCmp(filename, bstr, 1)<=0)
	{
		if (print_possibilities>0)
			print_possibilities = -print_possibilities;
		memcpy(cstr, bstr+1, bstr[0]);
		cstr[bstr[0]]=0;
		print_a_completion(cstr);
	}
#endif
}

int affs_dir(char *dirname)
{
    struct CacheBlock *buffer1;
    struct CacheBlock *buffer2;
    char *current = dirname;
    char filename[128];
    char *fname = filename;
    int i,block;

    if (print_possibilities)
    {
	while (*current)
	    current++;
	while (*current != '/')
	    current--;
	current++;
	while (*current)
	{
	    *fname++ = *current;
	    *current++ = 0;
	}
	*fname=0;
	errnum = findBlock(dirname, &buffer1);
	if (errnum)
	    return 0;
	if (AROS_BE2LONG(dirHeader(buffer1)->p_type) == IDNAME_RIGIDDISK)
	{
	    block = AROS_BE2LONG(rdsk(buffer1)->rdb_PartitionList);
	    while (block != -1)
	    {
		buffer1 = getBlock(block);
		checkPossibility(filename, part(buffer1)->pb_DriveName);
		block = AROS_BE2LONG(part(buffer1)->pb_Next);
	    }
#ifndef STAGE1_5
	    if (*filename == 0)
		if (print_possibilities>0)
		    print_possibilities = -print_possibilities;
#endif
	}
	else if (AROS_BE2LONG(dirHeader(buffer1)->p_type) == T_SHORT)
	{
	    LockBuffer(buffer1);
	    for (i=0;i<72;i++)
	    {
		block = dirHeader(buffer1)->hashtable[i];
		while (block)
		{
		    buffer2 = getBlock(AROS_BE2LONG(block));
		    if (calcChkSum(128, buffer2->blockbuffer))
		    {
			errnum = ERR_FSYS_CORRUPT;
			return 0;
		    }
		    if (AROS_BE2LONG(dirHeader(buffer2)->p_type) != T_SHORT)
		    {
			errnum = ERR_BAD_FILETYPE;
			return 0;
		    }
		    checkPossibility(filename, dirHeader(buffer2)->name);
		    block = dirHeader(buffer2)->hashchain;
		}
	    }
	    UnLockBuffer(buffer1);
#ifndef STAGE1_5
	    if (*filename == 0)
		if (print_possibilities>0)
		    print_possibilities = -print_possibilities;
#endif
	}	
	else
	{
	    errnum = ERR_BAD_FILETYPE;
	    return 0;
	}
	while (*current != '/')
	    current--;
	current++;
	fname = filename;
	while (*fname)
	    *current++ = *fname++;
#warning "TODO: add some more chars until posibilities differ"
	if (print_possibilities>0)
	    errnum = ERR_FILE_NOT_FOUND;
	return (print_possibilities<0);
    }
    else
    {
	while (*current && !isspace(*current))
	    *fname++ = *current++;
	*fname = 0;
	    
	errnum = findBlock(filename, &buffer2);
	if (errnum)
	    return 0;
	if (AROS_BE2LONG(fileHeader(buffer2)->s_type)!=ST_FILE)
	{
	    errnum = ERR_BAD_FILETYPE;
	    return 0;
	}
	fsysb->file.header_block = AROS_BE2LONG(fileHeader(buffer2)->own_key);
	fsysb->file.current.block = AROS_BE2LONG(fileHeader(buffer2)->own_key);
	fsysb->file.current.filekey = 71;
	fsysb->file.current.byte = 0;
	fsysb->file.current.offset = 0;
	fsysb->file.filesize = AROS_BE2LONG(fileHeader(buffer2)->bytesize);
	filepos = 0;
	filemax = fsysb->file.filesize;
	return 1;
    }
}
#endif