Subversion Repositories freemyipod

#include <stdio.h> 
#include <stdint.h>
#include <stdbool.h>
#include <fcntl.h>

static void mark_bad(uint32_t* bitmap, int sector)
{
    bitmap[sector >> 5] &= ~(1 << (sector & 31));
}

static bool is_good(uint32_t* bitmap, int sector)
{
    return bitmap[sector >> 5] & (1 << (sector & 31));
}

int main(int argc, char** argv)
{
    int sectors;
    sscanf(argv[3], "%i", &sectors);
    size_t bitmapsize = ((sectors + 65535) & ~0xffff) >> 3;
    uint32_t* bitmap = malloc(bitmapsize);
    memset(bitmap, 0xff, bitmapsize);
    FILE* in = fopen(argv[1], "r");
    if (!in)
    {
        perror("Failed to open input file");
        return 2;
    }
    char line[256];
    while (fgets(line, sizeof(line), in))
    {
        int sector;
        if (sscanf(line, "%i", &sector) == 1 && sector) mark_bad(bitmap, sector);
    }
    fclose(in);
    int l0count = (sectors + 0x7ffff) >> 19;
    int bbtpages = 64 + ((l0count + 0x3f) & ~0x3f);
    int bbtsize;
    uint16_t (*bbt)[0x20];
    bool success = false;
    while (bbtpages <= 32832)
    {
        bbtsize = bbtpages << 6;
        l0count = (sectors - bbtsize + 0xfffff) >> 19;
        bbt = malloc(bbtsize);
        memset(bbt, 0, bbtsize);
        int logical = 0;
        int physical = 1;
        int remapbase;
        int bbtgood;
        for (bbtgood = 0; bbtgood < (bbtpages >> 6) - 1; physical++)
            if (is_good(bitmap, physical))
            {
                ((uint32_t*)bbt)[0x200 + bbtgood] = physical;
                bbtgood++;
            }
        int bbtused = 64 + l0count;
        int level;
        uint16_t *l1, *l2, *l3;
        int l1count = 0, l2count = 0, l3count = 0;
        while (!success)
        {
            if (!(logical & 0x7fff)) level = 0;
            else if (!(logical & 0x3ff)) level = 1;
            else if (!(logical & 0x1f)) level = 2;
            else level = 3;
            if (!level) remapbase = ((physical - logical) >> 12) << 12;
            if (physical - logical - remapbase > 0x7fff || remapbase > 0xffff)
            {
                printf("Need to remap across too high distance!\n");
                return 5;
            }
            int clean;
            for (clean = 0; clean < (1 << ((3 - level) * 5)) && physical + clean < sectors; clean++)
                if (!is_good(bitmap, physical + clean))
                    break;
            if (clean >= 32768)
            {
                bbt[64][(logical >> 15) << 1] = physical - logical - remapbase;
                bbt[64][((logical >> 15) << 1) | 1] = remapbase >> 12;
                physical += 32768;
                logical += 32768;
            }
            else if (clean >= 1024)
            {
                if (level == 0)
                {
                    if (bbtused == bbtpages) break;
                    level = 1;
                    l1 = bbt[bbtused];
                    bbt[64][(logical >> 15) << 1] = 0x8000 | (bbtused - 64);
                    bbt[64][((logical >> 15) << 1) | 1] = remapbase >> 12;
                    bbtused++;
                    l1count++;
                }
                l1[(logical >> 10) & 0x1f] = physical - logical - remapbase;
                physical += 1024;
                logical += 1024;
            }
            else if (clean >= 32)
            {
                if (level == 0)
                {
                    if (bbtused == bbtpages) break;
                    level = 1;
                    l1 = bbt[bbtused];
                    bbt[64][(logical >> 15) << 1] = 0x8000 | (bbtused - 64);
                    bbt[64][((logical >> 15) << 1) | 1] = remapbase >> 12;
                    bbtused++;
                    l1count++;
                }
                if (level == 1)
                {
                    if (bbtused == bbtpages) break;
                    level = 2;
                    l2 = bbt[bbtused];
                    l1[(logical >> 10) & 0x1f] = 0x8000 | (bbtused - 64);
                    bbtused++;
                    l2count++;
                }
                l2[(logical >> 5) & 0x1f] = physical - logical - remapbase;
                physical += 32;
                logical += 32;
            }
            else if (clean >= 1)
            {
                if (level == 0)
                {
                    if (bbtused == bbtpages) break;
                    level = 1;
                    l1 = bbt[bbtused];
                    bbt[64][(logical >> 15) << 1] = 0x8000 | (bbtused - 64);
                    bbt[64][((logical >> 15) << 1) | 1] = remapbase >> 12;
                    bbtused++;
                    l1count++;
                }
                if (level == 1)
                {
                    if (bbtused == bbtpages) break;
                    level = 2;
                    l2 = bbt[bbtused];
                    l1[(logical >> 10) & 0x1f] = 0x8000 | (bbtused - 64);
                    bbtused++;
                    l2count++;
                }
                if (level == 2)
                {
                    if (bbtused == bbtpages) break;
                    level = 3;
                    l3 = bbt[bbtused];
                    l2[(logical >> 5) & 0x1f] = 0x8000 | (bbtused - 64);
                    bbtused++;
                    l3count++;
                }
                l3[logical & 0x1f] = physical - logical - remapbase;
                physical++;
                logical++;
            }
            else physical++;
            if (physical >= sectors) success = true;
        }
        if (success)
        {        
            printf("BBT using %d sectors (%d KiB)\n", bbtgood + 1, bbtsize >> 10);
            printf("Level 0: %d pages, Level 1: %d pages, Level 2: %d pages, Level 3: %d pages\n",
                   l0count, l1count, l2count, l3count);
            printf("User data sectors: %d (%d KiB)\n", logical, logical << 2);
            memcpy(bbt, "emBIbbth", 8);
            ((uint32_t*)bbt)[0x1fc] = logical;
            ((uint32_t*)bbt)[0x1ff] = (bbtpages >> 6) - 1;
            break;
        }
        free(bbt);
        bbtpages += 64;
    }
    if (success)
    {
        int out = open(argv[2], O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644);
        if (out < 0)
        {
            perror("Failed to open output file");
            return 3;
        }
        int rc;
        while (bbtsize && (rc = write(out, bbt, bbtsize)) >= 0) bbtsize -= rc;
        if (rc < 0)
        {
            perror("Failed to open output file");
            return 4;
        }
        close(out);
        return 0;
    }
    printf("Can't fit BBT into 2052 KiB!\n");
    return 1;
}