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;
}