usbloadergx/source/libwbfs/libwbfs.c

// Copyright 2009 Kwiirk
// Licensed under the terms of the GNU GPL, version 2
// http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt

// Modified by oggzee


#include "libwbfs.h"

#define likely(x)       __builtin_expect(!!(x), 1)
#define unlikely(x)     __builtin_expect(!!(x), 0)

#define ERROR(x) do {wbfs_error(x);goto error;}while(0)
#define ALIGN_LBA(x) (((x)+p->hd_sec_sz-1)&(~(p->hd_sec_sz-1)))

wbfs_t wbfs_iso_file;

static int force_mode=0;

void wbfs_set_force_mode(int force)
{
        force_mode = force;
}

static u8 size_to_shift(u32 size)
{
        u8 ret = 0;
        while(size)
        {
                ret++;
                size>>=1;
        }
        return ret-1;
}
#define read_le32_unaligned(x) ((x)[0]|((x)[1]<<8)|((x)[2]<<16)|((x)[3]<<24))


wbfs_t*wbfs_open_hd(rw_sector_callback_t read_hdsector,
                 rw_sector_callback_t write_hdsector,
                 void *callback_data,
                    int hd_sector_size, int num_hd_sector __attribute((unused)), int reset)
{
        int i=num_hd_sector,ret;
        u8 *ptr,*tmp_buffer = wbfs_ioalloc(hd_sector_size);
        u8 part_table[16*4];
        ret = read_hdsector(callback_data,0,1,tmp_buffer);
        if(ret)
                return 0;
        //find wbfs partition
        wbfs_memcpy(part_table,tmp_buffer+0x1be,16*4);
        ptr = part_table;
        for(i=0;i<4;i++,ptr+=16)
        {
                u32 part_lba = read_le32_unaligned(ptr+0x8);
                wbfs_head_t *head = (wbfs_head_t *)tmp_buffer;
                ret = read_hdsector(callback_data,part_lba,1,tmp_buffer);
                // verify there is the magic.
                if (head->magic == wbfs_htonl(WBFS_MAGIC))
                {
                        wbfs_t*p = wbfs_open_partition(read_hdsector,write_hdsector,
                                                callback_data,hd_sector_size,0,part_lba,reset);
                        wbfs_iofree(tmp_buffer);
                        return p;
                }
        }
        wbfs_iofree(tmp_buffer);
        if(reset)// XXX make a empty hd partition..
        {
        }
        return 0;
}
wbfs_t*wbfs_open_partition(rw_sector_callback_t read_hdsector,
                           rw_sector_callback_t write_hdsector,
                           void *callback_data,
                           int hd_sector_size, int num_hd_sector, u32 part_lba, int reset)
{
        wbfs_t *p = wbfs_malloc(sizeof(wbfs_t));
        
        wbfs_head_t *head = wbfs_ioalloc(hd_sector_size?hd_sector_size:512);

        //constants, but put here for consistancy
        p->wii_sec_sz = 0x8000;
        p->wii_sec_sz_s = size_to_shift(0x8000);
        p->n_wii_sec = (num_hd_sector/0x8000)*hd_sector_size;
        p->n_wii_sec_per_disc = 143432*2;//support for double layers discs..
        p->head = head;
        p->part_lba = part_lba;
        // init the partition
        if (reset)
        {
                u8 sz_s;
                wbfs_memset(head,0,hd_sector_size);
                head->magic = wbfs_htonl(WBFS_MAGIC);
                head->hd_sec_sz_s = size_to_shift(hd_sector_size);
                head->n_hd_sec = wbfs_htonl(num_hd_sector);
                // choose minimum wblk_sz that fits this partition size
                for(sz_s=6;sz_s<11;sz_s++)
                {
                        // ensure that wbfs_sec_sz is big enough to address every blocks using 16 bits
                        if(p->n_wii_sec <((1U<<16)*(1<<sz_s)))
                                break;
                }
                head->wbfs_sec_sz_s = sz_s+p->wii_sec_sz_s;
        }else
                read_hdsector(callback_data,p->part_lba,1,head);
        if (head->magic != wbfs_htonl(WBFS_MAGIC))
                ERROR("bad magic");
        if(!force_mode && hd_sector_size && head->hd_sec_sz_s !=  size_to_shift(hd_sector_size))
                ERROR("hd sector size doesn't match");
        if(!force_mode && num_hd_sector && head->n_hd_sec != wbfs_htonl(num_hd_sector))
                ERROR("hd num sector doesn't match");
        p->hd_sec_sz = 1<<head->hd_sec_sz_s;
        p->hd_sec_sz_s = head->hd_sec_sz_s;
        p->n_hd_sec = wbfs_ntohl(head->n_hd_sec);

        p->n_wii_sec = (p->n_hd_sec/p->wii_sec_sz)*(p->hd_sec_sz);
        
        p->wbfs_sec_sz_s = head->wbfs_sec_sz_s;
        p->wbfs_sec_sz = 1<<p->wbfs_sec_sz_s;
        p->n_wbfs_sec = p->n_wii_sec >> (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
        p->n_wbfs_sec_per_disc = p->n_wii_sec_per_disc >> (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
        p->disc_info_sz = ALIGN_LBA(sizeof(wbfs_disc_info_t) + p->n_wbfs_sec_per_disc*2);

        //printf("hd_sector_size %X wii_sector size %X wbfs sector_size %X\n",p->hd_sec_sz,p->wii_sec_sz,p->wbfs_sec_sz);
        p->read_hdsector = read_hdsector;
        p->write_hdsector = write_hdsector;
        p->callback_data = callback_data;

        p->freeblks_lba = (p->wbfs_sec_sz - p->n_wbfs_sec/8)>>p->hd_sec_sz_s;
        
        if(!reset)
                p->freeblks = 0; // will alloc and read only if needed
        else
        {
                // init with all free blocks
                p->freeblks = wbfs_ioalloc(ALIGN_LBA(p->n_wbfs_sec/8));
                wbfs_memset(p->freeblks,0xff,p->n_wbfs_sec/8);
        }
        p->max_disc = (p->freeblks_lba-1)/(p->disc_info_sz>>p->hd_sec_sz_s);
        if(p->max_disc > p->hd_sec_sz - sizeof(wbfs_head_t))
                p->max_disc = p->hd_sec_sz - sizeof(wbfs_head_t);

        p->tmp_buffer = wbfs_ioalloc(p->hd_sec_sz);
        p->n_disc_open = 0;
        return p;
error:
        wbfs_free(p);
        wbfs_iofree(head);
        return 0;
            
}

void wbfs_sync(wbfs_t*p)
{
        // copy back descriptors
        if(p->write_hdsector){
                p->write_hdsector(p->callback_data,p->part_lba+0,1, p->head);
                
                if(p->freeblks)
                        p->write_hdsector(p->callback_data,p->part_lba+p->freeblks_lba,ALIGN_LBA(p->n_wbfs_sec/8)>>p->hd_sec_sz_s, p->freeblks);
        }
}

void wbfs_close(wbfs_t*p)
{
        wbfs_sync(p);

        if(p->n_disc_open)
                ERROR("trying to close wbfs while discs still open");

        wbfs_iofree(p->head);
        wbfs_iofree(p->tmp_buffer);
        if(p->freeblks)
                wbfs_iofree(p->freeblks);
        
        wbfs_free(p);
        
error:
        return;
}

wbfs_disc_t *wbfs_open_disc(wbfs_t* p, u8 *discid)
{
        u32 i;
        int disc_info_sz_lba = p->disc_info_sz>>p->hd_sec_sz_s;
        wbfs_disc_t *d = 0;
        for(i=0;i<p->max_disc;i++)
        {
                if (p->head->disc_table[i]){
                        p->read_hdsector(p->callback_data,
                                         p->part_lba+1+i*disc_info_sz_lba,1,p->tmp_buffer);
                        if(wbfs_memcmp(discid,p->tmp_buffer,6)==0){
                                d = wbfs_malloc(sizeof(*d));
                                if(!d)
                                        ERROR("allocating memory");
                                d->p = p;
                                d->i = i;
                                d->header = wbfs_ioalloc(p->disc_info_sz);
                                if(!d->header)
                                        ERROR("allocating memory");
                                p->read_hdsector(p->callback_data,
                                                  p->part_lba+1+i*disc_info_sz_lba,
                                                  disc_info_sz_lba,d->header);
                                p->n_disc_open ++;
//                                for(i=0;i<p->n_wbfs_sec_per_disc;i++)
//                                        printf("%d,",wbfs_ntohs(d->header->wlba_table[i]));
                                return d;
                        }
                }
        }
        return 0;
error:
        if(d)
                wbfs_iofree(d);
        return 0;
        
}
void wbfs_close_disc(wbfs_disc_t*d)
{
        d->p->n_disc_open --;
        wbfs_iofree(d->header);
        wbfs_free(d);
}
// offset is pointing 32bit words to address the whole dvd, although len is in bytes
int wbfs_disc_read(wbfs_disc_t*d,u32 offset, u32 len, u8 *data)
{
	if (d->p == &wbfs_iso_file) {
		return wbfs_iso_file_read(d, offset, data, len);
	}
 
        wbfs_t *p = d->p;
        u16 wlba = offset>>(p->wbfs_sec_sz_s-2);
        u32 iwlba_shift = p->wbfs_sec_sz_s - p->hd_sec_sz_s;
        u32 lba_mask = (p->wbfs_sec_sz-1)>>(p->hd_sec_sz_s);
        u32 lba = (offset>>(p->hd_sec_sz_s-2))&lba_mask;
        u32 off = offset&((p->hd_sec_sz>>2)-1);
        u16 iwlba = wbfs_ntohs(d->header->wlba_table[wlba]);
        u32 len_copied;
        int err = 0;
        u8  *ptr = data;
        if(unlikely(iwlba==0))
                return 1;
        if(unlikely(off)){
                off*=4;
                err = p->read_hdsector(p->callback_data,
                                       p->part_lba + (iwlba<<iwlba_shift) + lba, 1, p->tmp_buffer);
                if(err)
                        return err;
                len_copied = p->hd_sec_sz - off;
                if(likely(len < len_copied))
                        len_copied = len;
                wbfs_memcpy(ptr, p->tmp_buffer + off, len_copied);
                len -= len_copied;
                ptr += len_copied;
                lba++;
                if(unlikely(lba>lba_mask && len)){
                        lba=0;
                        iwlba =  wbfs_ntohs(d->header->wlba_table[++wlba]);
                        if(unlikely(iwlba==0))
                                return 1;
                }
        }
        while(likely(len>=p->hd_sec_sz))
        {
                u32 nlb = len>>(p->hd_sec_sz_s);
                
                if(unlikely(lba + nlb > p->wbfs_sec_sz)) // dont cross wbfs sectors..
                        nlb = p->wbfs_sec_sz-lba;
                err = p->read_hdsector(p->callback_data,
                                 p->part_lba + (iwlba<<iwlba_shift) + lba, nlb, ptr);
                if(err)
                        return err;
                len -= nlb<<p->hd_sec_sz_s;
                ptr += nlb<<p->hd_sec_sz_s;
                lba += nlb;
                if(unlikely(lba>lba_mask && len)){
                        lba = 0;
                        iwlba =wbfs_ntohs(d->header->wlba_table[++wlba]);
                        if(unlikely(iwlba==0))
                                return 1;
                }
        }
        if(unlikely(len)){
                err = p->read_hdsector(p->callback_data,
                                 p->part_lba + (iwlba<<iwlba_shift) + lba, 1, p->tmp_buffer);
                if(err)
                        return err;
                wbfs_memcpy(ptr, p->tmp_buffer, len);
        }     
        return 0;
}

// disc listing
u32 wbfs_count_discs(wbfs_t*p)
{
        u32 i,count=0;
        for(i=0;i<p->max_disc;i++)
                if (p->head->disc_table[i])
                        count++;
        return count;
        
}

u32 wbfs_sector_used(wbfs_t *p,wbfs_disc_info_t *di)
{
        u32 tot_blk=0,j;
        for(j=0;j<p->n_wbfs_sec_per_disc;j++)
                if(wbfs_ntohs(di->wlba_table[j]))
                        tot_blk++;
        return tot_blk;
}

u32 wbfs_sector_used2(wbfs_t *p, wbfs_disc_info_t *di, u32 *last_blk)
{
        u32 tot_blk=0,j;
        for(j=0;j<p->n_wbfs_sec_per_disc;j++)
                if(wbfs_ntohs(di->wlba_table[j])) {
                        if (last_blk) *last_blk = j;
                        tot_blk++;
                }
        return tot_blk;
}

u32 wbfs_get_disc_info(wbfs_t*p, u32 index,u8 *header,int header_size,u32 *size)//size in 32 bit
{
        u32 i,count=0;
        if (!p) return 1;
        int disc_info_sz_lba = p->disc_info_sz>>p->hd_sec_sz_s;
		
        for(i=0;i<p->max_disc;i++)
                if (p->head->disc_table[i]){
                        if(count++==index)
                        {
                             p->read_hdsector(p->callback_data,
                                                 p->part_lba+1+i*disc_info_sz_lba,1,p->tmp_buffer);
                                if(header_size > (int)p->hd_sec_sz)
                                        header_size = p->hd_sec_sz;
                                u32 magic = wbfs_ntohl(*(u32*)(p->tmp_buffer+24));
                                if(magic!=0x5D1C9EA3){
                                        p->head->disc_table[i]=0;
                                        return 1;
                                }
                                memcpy(header,p->tmp_buffer,header_size);
                                if(size)
                                {
                                        u8 *header = wbfs_ioalloc(p->disc_info_sz);
                                        p->read_hdsector(p->callback_data,
                                                         p->part_lba+1+i*disc_info_sz_lba,disc_info_sz_lba,header);
                                        u32 sec_used = wbfs_sector_used(p,(wbfs_disc_info_t *)header);
                                        wbfs_iofree(header);
                                        *size = sec_used<<(p->wbfs_sec_sz_s-2);
                                }
                                return 0;
                        }
                }
        return 1;
}

static void load_freeblocks(wbfs_t*p)
{
        if(p->freeblks)
                return;
        // XXX should handle malloc error..
        p->freeblks = wbfs_ioalloc(ALIGN_LBA(p->n_wbfs_sec/8));
        p->read_hdsector(p->callback_data,p->part_lba+p->freeblks_lba,ALIGN_LBA(p->n_wbfs_sec/8)>>p->hd_sec_sz_s, p->freeblks);
        
}
u32 wbfs_count_usedblocks(wbfs_t*p)
{
        u32 i,j,count=0;
        load_freeblocks(p);
        for(i=0;i<p->n_wbfs_sec/(8*4);i++)
        {
                u32 v = wbfs_ntohl(p->freeblks[i]);
                if(v == ~0U)
                     count+=32;
                else if(v!=0)
                        for(j=0;j<32;j++)
                                if (v & (1<<j))
                                        count++;
        }
        return count;
}


// write access


//static
int block_used(u8 *used,u32 i,u32 wblk_sz)
{
        u32 k;
        i*=wblk_sz;
        for(k=0;k<wblk_sz;k++)
                if(i+k<143432*2 && used[i+k])
                        return 1;
        return 0;
}

static u32 alloc_block(wbfs_t*p)
{
        u32 i,j;
        for(i=0;i<p->n_wbfs_sec/(8*4);i++)
        {
                u32 v = wbfs_ntohl(p->freeblks[i]);
                if(v != 0)
                {
                        for(j=0;j<32;j++)
                                if (v & (1<<j))
                                {
                                        p->freeblks[i] = wbfs_htonl(v & ~(1<<j));
                                        return (i*32)+j+1;
                                }
                }
        }
        return ~0;
}
static void free_block(wbfs_t *p,int bl)
{
        int i = (bl-1)/(32);
        int j = (bl-1)&31;
        u32 v = wbfs_ntohl(p->freeblks[i]);
        p->freeblks[i] = wbfs_htonl(v | 1<<j);
}

u32 wbfs_add_disc(wbfs_t*p, read_wiidisc_callback_t read_src_wii_disc,
		void *callback_data,progress_callback_t spinner,partition_selector_t sel,int copy_1_1)
{
	int i,discn;
	u32 tot,cur;
	u32 wii_sec_per_wbfs_sect = 1<<(p->wbfs_sec_sz_s-p->wii_sec_sz_s);
	wiidisc_t *d = 0;
	u8 *used = 0;
	wbfs_disc_info_t *info = 0;
	u8* copy_buffer = 0;
	int retval = -1;
	int num_wbfs_sect_to_copy;
	u32 last_used;
	used = wbfs_malloc(p->n_wii_sec_per_disc);

	if(!used)
		ERROR("unable to alloc memory");
	// copy_1_1 needs disk usage for layers detection
	//if(!copy_1_1)
	{
		d = wd_open_disc(read_src_wii_disc,callback_data);
		if(!d)
			ERROR("unable to open wii disc");
		wd_build_disc_usage(d,sel,used);
		wd_close_disc(d);
		d = 0;
	}

	for(i=0;i<p->max_disc;i++)// find a free slot.
		if(p->head->disc_table[i]==0)
			break;
	if(i==p->max_disc)
		ERROR("no space left on device (table full)");
	p->head->disc_table[i] = 1;
	discn = i;
	load_freeblocks(p);

	// build disc info
	info = wbfs_ioalloc(p->disc_info_sz);
	read_src_wii_disc(callback_data,0,0x100,info->disc_header_copy);

	copy_buffer = wbfs_ioalloc(p->wii_sec_sz);
	if(!copy_buffer)
		ERROR("alloc memory");
	tot=0;
	cur=0;
	num_wbfs_sect_to_copy = p->n_wbfs_sec_per_disc;
	// count total number of sectors to write
	last_used = 0;
	for(i=0; i<num_wbfs_sect_to_copy; i++) {
		if(block_used(used,i,wii_sec_per_wbfs_sect)) {
			tot += wii_sec_per_wbfs_sect;
			last_used = i;
		}
	}
	if (copy_1_1) {
		// detect single or dual layer
		if ( (last_used + 1) > (p->n_wbfs_sec_per_disc / 2) ) {
			// dual layer
			num_wbfs_sect_to_copy = p->n_wbfs_sec_per_disc;
		} else {
			// single layer
			num_wbfs_sect_to_copy = p->n_wbfs_sec_per_disc / 2;
		}
		tot = num_wbfs_sect_to_copy * wii_sec_per_wbfs_sect;
	}
	/*
	// num of hd sectors to copy could be specified directly
	if (copy_1_1 > 1) {
		u32 hd_sec_per_wii_sec = p->wii_sec_sz / p->hd_sec_sz;
		num_wbfs_sect_to_copy = copy_1_1 / hd_sec_per_wii_sec / wii_sec_per_wbfs_sect;
		tot = num_wbfs_sect_to_copy * wii_sec_per_wbfs_sect;
	}*/
	int ret = 0;
	if(spinner) spinner(0,tot);
	for(i=0; i<num_wbfs_sect_to_copy; i++){
		u16 bl = 0;
		if(copy_1_1 || block_used(used,i,wii_sec_per_wbfs_sect)) {
			u16 j;

			bl = alloc_block(p);
			if (bl==0xffff)
				ERROR("no space left on device (disc full)");
			for(j=0; j<wii_sec_per_wbfs_sect;j++) {
				u32 offset = (i*(p->wbfs_sec_sz>>2)) + (j*(p->wii_sec_sz>>2));

				ret = read_src_wii_disc(callback_data,offset,p->wii_sec_sz,copy_buffer);
				if (ret) {
					if (copy_1_1 && i > p->n_wbfs_sec_per_disc / 2) {
						// end of dual layer data
						if (j > 0) {
							info->wlba_table[i] = wbfs_htons(bl);
						}
						spinner(tot,tot);
						break;
					}
					//ERROR("read error");
					printf("\rWARNING: read (%u) error (%d)\n", offset, ret);
				}

				//fix the partition table
				if(offset == (0x40000>>2))
					wd_fix_partition_table(d, sel, copy_buffer);
				p->write_hdsector(p->callback_data,
						p->part_lba+bl*(p->wbfs_sec_sz/p->hd_sec_sz) + j*(p->wii_sec_sz/p->hd_sec_sz),
						p->wii_sec_sz/p->hd_sec_sz, copy_buffer);
				cur++;
				if(spinner)
					spinner(cur,tot);
			}
		}
		if (ret) break;
		info->wlba_table[i] = wbfs_htons(bl);
	}
	// write disc info
	int disc_info_sz_lba = p->disc_info_sz>>p->hd_sec_sz_s;
	p->write_hdsector(p->callback_data,p->part_lba+1+discn*disc_info_sz_lba,disc_info_sz_lba,info);
	wbfs_sync(p);
	retval = 0;
error:
	if(d)
		wd_close_disc(d);
	if(used)
		wbfs_free(used);
	if(info)
		wbfs_iofree(info);
	if(copy_buffer)
		wbfs_iofree(copy_buffer);
	// init with all free blocks

	return retval;
}

u32 wbfs_rm_disc(wbfs_t*p, u8* discid)
{
	wbfs_disc_t *d = wbfs_open_disc(p,discid);
	int i;
	int discn = 0;
	int disc_info_sz_lba = p->disc_info_sz>>p->hd_sec_sz_s;
	if(!d)
		return 1;
	load_freeblocks(p);
	discn = d->i;
	for( i=0; i< p->n_wbfs_sec_per_disc; i++)
	{
		u32 iwlba = wbfs_ntohs(d->header->wlba_table[i]);
		if (iwlba)
			free_block(p,iwlba);
	}
	memset(d->header,0,p->disc_info_sz);
	p->write_hdsector(p->callback_data,p->part_lba+1+discn*disc_info_sz_lba,disc_info_sz_lba,d->header);
	p->head->disc_table[discn] = 0;
	wbfs_close_disc(d);
	wbfs_sync(p);
	return 0;
}

u32 wbfs_ren_disc(wbfs_t*p, u8* discid, u8* newname)
{
	wbfs_disc_t *d = wbfs_open_disc(p,discid);
	int disc_info_sz_lba = p->disc_info_sz>>p->hd_sec_sz_s;

	if(!d)
		return 1;

	memset(d->header->disc_header_copy+0x20, 0, 0x40);
	strncpy((char *) d->header->disc_header_copy+0x20, (char *) newname, 0x39);

	p->write_hdsector(p->callback_data,p->part_lba+1+d->i*disc_info_sz_lba,disc_info_sz_lba,d->header);
	wbfs_close_disc(d);
	return 0;
}

u32 wbfs_rID_disc(wbfs_t*p, u8* discid, u8* newID)
{
	wbfs_disc_t *d = wbfs_open_disc(p,discid);
	int disc_info_sz_lba = p->disc_info_sz>>p->hd_sec_sz_s;

	if(!d)
		return 1;

	memset(d->header->disc_header_copy, 0, 0x10);
	strncpy((char *) d->header->disc_header_copy, (char *) newID, 0x9);

	p->write_hdsector(p->callback_data,p->part_lba+1+d->i*disc_info_sz_lba,disc_info_sz_lba,d->header);
	wbfs_close_disc(d);
	return 0;
}

// trim the file-system to its minimum size
u32 wbfs_trim(wbfs_t*p)
{
        u32 maxbl;
        load_freeblocks(p);
        maxbl = alloc_block(p);
        p->n_hd_sec = maxbl<<(p->wbfs_sec_sz_s-p->hd_sec_sz_s);
        p->head->n_hd_sec = wbfs_htonl(p->n_hd_sec);
        // make all block full
        memset(p->freeblks,0,p->n_wbfs_sec/8);
        wbfs_sync(p);
        // os layer will truncate the file.
        return maxbl;
}

// data extraction
u32 wbfs_extract_disc(wbfs_disc_t*d, rw_sector_callback_t write_dst_wii_sector,void *callback_data,progress_callback_t spinner)
{
        wbfs_t *p = d->p;
        u8* copy_buffer = 0;
        int i;
        int src_wbs_nlb=p->wbfs_sec_sz/p->hd_sec_sz;
        int dst_wbs_nlb=p->wbfs_sec_sz/p->wii_sec_sz;
        copy_buffer = wbfs_ioalloc(p->wbfs_sec_sz);
        if(!copy_buffer)
                ERROR("alloc memory");

        for( i=0; i< p->n_wbfs_sec_per_disc; i++)
        {
                u32 iwlba = wbfs_ntohs(d->header->wlba_table[i]);
                if (iwlba)
                {
                        
                        if(spinner)
                                spinner(i,p->n_wbfs_sec_per_disc);
                        p->read_hdsector(p->callback_data, p->part_lba + iwlba*src_wbs_nlb, src_wbs_nlb, copy_buffer);
                        write_dst_wii_sector(callback_data, i*dst_wbs_nlb, dst_wbs_nlb, copy_buffer);
                }
        }
        wbfs_iofree(copy_buffer);
        return 0;
error:
        return 1;
}

float wbfs_estimate_disc
(
		wbfs_t *p, read_wiidisc_callback_t read_src_wii_disc,
		void *callback_data,
		partition_selector_t sel)
{
	u8 *b;
	int i;
	u32 tot;
	u32 wii_sec_per_wbfs_sect = 1 << (p->wbfs_sec_sz_s-p->wii_sec_sz_s);
	wiidisc_t *d = 0;
	u8 *used = 0;
	wbfs_disc_info_t *info = 0;

	tot = 0;

	used = wbfs_malloc(p->n_wii_sec_per_disc);
	if (!used)
	{
		ERROR("unable to alloc memory");
	}

	d = wd_open_disc(read_src_wii_disc, callback_data);
	if (!d)
	{
		ERROR("unable to open wii disc");
	}

	wd_build_disc_usage(d,sel,used);
	wd_close_disc(d);
	d = 0;

	info = wbfs_ioalloc(p->disc_info_sz);
	b = (u8 *)info;
	read_src_wii_disc(callback_data, 0, 0x100, info->disc_header_copy);

	//fprintf(stderr, "estimating %c%c%c%c%c%c %s...\n",b[0], b[1], b[2], b[3], b[4], b[5], b + 0x20);

	for (i = 0; i < p->n_wbfs_sec_per_disc; i++)
	{
		if (block_used(used, i, wii_sec_per_wbfs_sect))
		{
			tot++;
		}
	}
	//memcpy(header, b,0x100);

error:
	if (d)
		wd_close_disc(d);

	if (used)
		wbfs_free(used);

	if (info)
		wbfs_iofree(info);

	return tot * (((p->wbfs_sec_sz*1.0) / p->hd_sec_sz) * 512);
}
u32 wbfs_size_disc(wbfs_t*p,read_wiidisc_callback_t read_src_wii_disc,
                  void *callback_data,partition_selector_t sel,
				  u32 *comp_size, u32 *real_size)
{
        int i;
        u32 tot = 0, last = 0;
        u32 wii_sec_per_wbfs_sect = 1<<(p->wbfs_sec_sz_s-p->wii_sec_sz_s);
        wiidisc_t *d = 0;
        u8 *used = 0;
        used = wbfs_malloc(p->n_wii_sec_per_disc);
        if(!used)
                ERROR("unable to alloc memory");
		d = wd_open_disc(read_src_wii_disc,callback_data);
		if(!d)
				ERROR("unable to open wii disc");
		wd_build_disc_usage(d,sel,used);
		wd_close_disc(d);
		d = 0;

		// count total number to write for spinner
		for(i=0; i<p->n_wbfs_sec_per_disc;i++) {
			if(block_used(used,i,wii_sec_per_wbfs_sect)) {
				tot += wii_sec_per_wbfs_sect;
				last = i * wii_sec_per_wbfs_sect;
			}
		}

error:
        if(d)
                wd_close_disc(d);
        if(used)
                wbfs_free(used);

		*comp_size = tot;
		*real_size = last;
        
        return 0;
}

// offset is pointing 32bit words to address the whole dvd, although len is in bytes
//int wbfs_disc_read(wbfs_disc_t*d,u32 offset, u8 *data, u32 len)

// offset points 32bit words, count counts bytes
//int (*read_wiidisc_callback_t)(void*fp,u32 offset,u32 count,void*iobuf);

// connect wiidisc to wbfs_disc
int read_wiidisc_wbfsdisc(void*fp,u32 offset,u32 count,void*iobuf)
{
        return wbfs_disc_read((wbfs_disc_t*)fp, offset, count, iobuf);
}

int wbfs_extract_file(wbfs_disc_t*d, char *path, void **data)
{
        wiidisc_t *wd = 0;
        int ret = 0;

        wd = wd_open_disc(read_wiidisc_wbfsdisc, d);
        if (!wd) {
                ERROR("opening wbfs disc");
				return -1;
        }
        wd->extracted_size = 0;
        *data = wd_extract_file(wd, ONLY_GAME_PARTITION, path);
        ret = wd->extracted_size;
        if (!*data) {
                //ERROR("file not found");
                ret = -1;
        }
        wd_close_disc(wd);
error:
        return ret;
}

int wbfs_get_fragments(wbfs_disc_t *d, _frag_append_t append_fragment, void *callback_data)
{
	if (!d) return -1;
	wbfs_t *p = d->p;
	int src_wbs_nlb = p->wbfs_sec_sz / p->hd_sec_sz;
	int i, ret, last = 0;
	for( i=0; i< p->n_wbfs_sec_per_disc; i++)
	{
		u32 iwlba = wbfs_ntohs(d->header->wlba_table[i]);
		if (iwlba)
		{
			ret = append_fragment(callback_data,
					i * src_wbs_nlb, // offset
					p->part_lba + iwlba * src_wbs_nlb, // sector
					src_wbs_nlb); // count
			if (ret) return ret; // error
			last = i;
		}
	}
	if (last < p->n_wbfs_sec_per_disc / 2) {
		last = p->n_wbfs_sec_per_disc / 2;
	}
	u32 size = last * src_wbs_nlb;
	append_fragment(callback_data, size, 0, 0); // set size
	return 0;
}

// wrapper for reading .iso files using wbfs apis

#include <unistd.h>
#include <sys/stat.h>

// offset is pointing 32bit words to address the whole dvd, although len is in bytes
int wbfs_iso_file_read(wbfs_disc_t*d,u32 offset, u8 *data, u32 len)
{
	if (!d || d->p != &wbfs_iso_file) return -1;
	int fd = (int)d->header;
	off_t off = ((u64)offset) << 2;
	off_t ret_off;
	int ret;
	ret_off = lseek(fd, off, SEEK_SET);
	if (ret_off != off) return -1;
	ret = read(fd, data, len);
	if (ret != len) return -2;
	return 0;
}

u32 wbfs_disc_sector_used(wbfs_disc_t *d, u32 *num_blk)
{
	if (d->p == &wbfs_iso_file) {
		int fd = (int)d->header;
		struct stat st;
		if (fstat(fd, &st) == -1) return 0;
		if (num_blk) {
			*num_blk = (st.st_size >> 9); // in 512 units
		}
		return st.st_blocks; // in 512 units (can be sparse)
	}
	u32 last_blk = 0;
	u32 ret;
	ret = wbfs_sector_used2(d->p, d->header, &last_blk);
	if (num_blk) {
		*num_blk = last_blk + 1;
	}
	return ret;
}