image.c

WiiFuse is a FUSE filesystem module for Linux and Mac OS X. It will let you mount a Wii disc ISO an

}

struct image_file * image_init (const char *filename) {
        FILE *fp, *fp_key;
        struct image_file *image;
        struct part_header *header;

        u8 buffer[0x440];
        u8 key[16];

        fp = fopen (filename, "rb");
        if (fp == NULL) {
                perror (filename);
                return NULL;
        }

        image = (struct image_file *) malloc (sizeof (struct image_file));

        if (!image) {
                LOG_ERR ("out of memory");
                fclose (fp);
                return NULL;
        }

        memset (image, 0, sizeof (struct image_file));
        image->fp = fp;

        if (!io_read (buffer, 0x440, image, 0)) {
                perror ("reading header");
                fclose (image->fp);
                free (image);
                return NULL;
        }

        header = (struct part_header *) (malloc (sizeof (struct part_header)));

        if (!header) {
                fclose (image->fp);
                free (image);
                LOG_ERR ("out of memory");
                return NULL;
        }

        image_parse_header (header, buffer);

        if (!header->is_gc && !header->is_wii) {
                LOG_ERR ("unknown type for file: %s", filename);
                fclose (image->fp);
                free (header);
                free (image);
                return NULL;
        }

        if (!header->has_magic)
                LOG_ERR ("image has an invalid magic");

        image->is_wii = header->is_wii;
        free (header);

        if (image->is_wii) {
                fp_key = fopen (KEYFILE, "rb");

                if (fp_key == NULL) {
                        free (image);
                        perror (KEYFILE);
                        return NULL;
                }

                if (16 != fread (key, 1, 16, fp_key)) {
                        free (image);
                        fclose (fp_key);
                        perror (KEYFILE);
                        return NULL;
                }

                fclose (fp_key);

                AES_set_decrypt_key (key, 128, &image->key);
        }

        return image;
};

int image_parse (struct image_file *image) {
        u8 buffer[0x440];
        u8 *fst;
        u32 i;
        u8 j, valid, nvp;

        u32 nfiles;

        char str[64];
        struct tree *part_node;

        pthread_mutex_init (&image->mutex, NULL);

        if (image->is_wii) {
                LOG (1, "detected a wii image");

                get_partitions (image);
        } else {
                LOG (1, "detected a gamecube image");

                image->parts = (struct partition *)
                                malloc (sizeof (struct partition));
                memset (&image->parts[0], 0, sizeof (struct partition));
                image->nparts = 1;
                image->parts[0].type = PART_DATA;
        }

        fstat (fileno (image->fp), &image->st);

        image->tree = tree_empty ();

        nvp = 0;
        for (i = 0; i < image->nparts; ++i)
        {
                LOG (1, "processing partition: %u", i);

                sprintf (str, "partition%02u", i);
                part_node = tree_add_dir (i, image->tree, str);

                if (!io_read_part (buffer, 0x440, image, i, 0)) {
                        perror ("partition header");
                        return 1;
                }
#if 0
                valid = 1;
                for (j = 0; j < 6; ++j) {
                        if (!isprint (buffer[j])) {
                                valid = 0;
                                break;
                        }
                }

                if (!valid) {
                        tree_add_filler (i, part_node, "invalid");
                        LOG_ERR ("invalid header for partition: %u", i);
                        continue;
                }
#endif
                nvp++;

                LOG (1, "partition header: %c%c%c%c%c%c",
                     buffer[0], buffer[1], buffer[2],
                     buffer[3], buffer[4], buffer[5]);

                image_parse_header (&image->parts[i].header, buffer);

                io_read_part (buffer, 8, image, i, 0x2440 + 0x14);
                image->parts[i].appldr_size =
                        get_be32 (buffer) + get_be32 (&buffer[4]);
                if (image->parts[i].appldr_size > 0)
                        image->parts[i].appldr_size += 32;

                if (image->parts[i].header.dol_offset > 0) {
                        io_read_part (buffer, 0x100, image, i,
                                      image->parts[i].header.dol_offset);
                        image->parts[i].header.dol_size =
                                get_dol_size (buffer);
                } else
                        LOG (1, "partition has no main.dol");

                if (image->parts[i].header.fst_offset > 0 &&
                    image->parts[i].header.fst_size > 0) {

                        LOG (1, "fst offset: 0x%016llx",
                             image->parts[i].header.fst_offset);
                        LOG (1, "fst size: 0x%016llx",
                             image->parts[i].header.fst_size);

                        fst = (u8 *) (malloc (image->parts[i].header.fst_size));
                        if (io_read_part (fst, image->parts[i].header.fst_size,
                                          image, i,
                                          image->parts[i].header.fst_offset) !=
                            image->parts[i].header.fst_size) {
                                perror ("fst.bin");
				free (fst);
                                return 1;
                        }

                        nfiles = get_be32 (fst + 8);

                        if (12 * nfiles > image->parts[i].header.fst_size) {
                                LOG_ERR ("invalid fst for partition %u", i);
                        } else {
                                LOG (1, "parsing fst");
                                parse_fst (fst, (char *) (fst + 12 * nfiles), 0,
                                           tree_add_dir (i, part_node, "fs"),
                                           image, i);
                        }

                        free (fst);
                } else
                        LOG (1, "partition has no fst");

                meta_add_part (part_node, &image->parts[i], i);
        }

        if (!nvp) {
                LOG_ERR ("no valid partition were found, exiting");
                return 1;
        }

        meta_add_image (image->tree, image);

        return 0;
}

void image_deinit (struct image_file *image) {
        u32 i;

        if (image == NULL)
                return;

        if (image->tree)
                tree_free (image->tree);

        if (image->parts) {
                for (i = 0; i < image->nparts; ++i)
                        if (image->parts[i].tmd)
                                tmd_free (image->parts[i].tmd);
                        
                free (image->parts);
        }

        fclose (image->fp);

        pthread_mutex_destroy (&image->mutex);

        free (image);
}