par2check.c

Go to the documentation of this file.

/*
 Copyright (C) 2005-2007 Erik van Pienbroek

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#ifdef _MSC_VER
#include 
#else
#include 
#endif

#include "par2check.h"

typedef struct _par2_packet_hdr {
    unsigned char magic[8];
    guint64 length;
    unsigned char md5_hash[16];         // md5 sum of the whole PAR2 packet (from this point on)
    unsigned char recovery_id[16];      // This should be the same for all the PAR2 packets in a set
    unsigned char type[16];
} PAR2PacketHDR;

typedef struct _par2_file_descriptor {
    unsigned char file_id[16];
    unsigned char md5_hash[16];         // hash from the entire file
    unsigned char md5_16k_hash[16];     // hash from the first 16KB of the file
    guint64  length;                    // file size
} PAR2FileDescriptor;

typedef struct _par2_file_slice_checksum {
    unsigned char file_id[16];
} PAR2FileSliceChecksum;

typedef struct _par2_main {
    guint64 blocksize;
    guint32 num_files;
} PAR2Main;

#ifdef WIN32
#pragma pack(push, 1)
#define PACKED
#else
#define PACKED __attribute__ ((packed))
#endif

typedef struct MAGIC MAGIC;
typedef struct PACKETTYPE PACKETTYPE;

struct MAGIC      {guint8 magic[8];} PACKED;
struct PACKETTYPE {guint8 type[16];} PACKED;

MAGIC      magic_hdr                   = {{'P', 'A', 'R', '2', '\0','P', 'K', 'T'}};
PACKETTYPE fileverificationpacket_type = {{'P', 'A', 'R', ' ', '2', '.', '0', '\0', 'I', 'F', 'S', 'C', '\0','\0','\0','\0'}};
PACKETTYPE filedescriptionpacket_type  = {{'P', 'A', 'R', ' ', '2', '.', '0', '\0', 'F', 'i', 'l', 'e', 'D', 'e', 's', 'c' }};
PACKETTYPE mainpacket_type             = {{'P', 'A', 'R', ' ', '2', '.', '0', '\0', 'M', 'a', 'i', 'n', '\0','\0','\0','\0'}};
PACKETTYPE recoveryblockpacket_type    = {{'P', 'A', 'R', ' ', '2', '.', '0', '\0', 'R', 'e', 'c', 'v', 'S', 'l', 'i', 'c' }};
PACKETTYPE creatorpacket_type          = {{'P', 'A', 'R', ' ', '2', '.', '0', '\0', 'C', 'r', 'e', 'a', 't', 'o', 'r', '\0'}};

#if 0
#define PRINT(...) g_print(__VA_ARGS__)
#else
#define PRINT(x, ...) 
#endif

gboolean
test_par2_packet_hdr(const unsigned char *data)
{
    if (!memcmp(data, &magic_hdr, sizeof(magic_hdr))) {
        return TRUE;
    } else {
        return FALSE;
    }
}

gboolean
test_par2_is_file_description_type(const unsigned char *data)
{
    if (!memcmp(data, &filedescriptionpacket_type, sizeof(filedescriptionpacket_type))) {
        return TRUE;
    } else {
        return FALSE;
    }
}

gboolean
test_par2_is_file_verification_type(const unsigned char *data)
{
    if (!memcmp(data, &fileverificationpacket_type, sizeof(fileverificationpacket_type))) {
        return TRUE;
    } else {
        return FALSE;
    }
}

gboolean
test_par2_is_main_packet_type(const unsigned char *data)
{
    if (!memcmp(data, &mainpacket_type, sizeof(mainpacket_type))) {
        return TRUE;
    } else {
        return FALSE;
    }
}

gboolean
test_par2_is_recovery_block_packet_type(const unsigned char *data)
{
    if (!memcmp(data, &recoveryblockpacket_type, sizeof(recoveryblockpacket_type))) {
        return TRUE;
    } else {
        return FALSE;
    }
}

gboolean
test_par2_is_creator_packet_type(const unsigned char *data)
{
    if (!memcmp(data, &creatorpacket_type, sizeof(creatorpacket_type))) {
        return TRUE;
    } else {
        return FALSE;
    }
}

gboolean
par2_get_md5_chunks(const char *par2file, guint64 *block_size, GList **files)
{
    int fp;
    PAR2File *file = NULL;

    g_assert(block_size);
    g_assert(par2file);
    g_assert(files);

    *files = NULL;

#ifdef WIN32
    fp = open(par2file, O_RDONLY | O_BINARY);
#else
    fp = open(par2file, O_RDONLY);
#endif
    if (!fp) {
        return FALSE;
    }

    do {
        PAR2PacketHDR hdr;
        int len_remaining_data;
        int len;
        void *data;

        len = read(fp, &hdr, sizeof(hdr));
        if (len == 0) {
            // end of file
            close(fp);
            return TRUE;
        }

        if (len != sizeof(hdr)) {
            close(fp);
            return FALSE;
        }

        if (!test_par2_packet_hdr(hdr.magic)) {
            PRINT("File is not a PAR2 file\n");
            close(fp);
            return FALSE;
        }

        if (test_par2_is_file_description_type(hdr.type)) {
            PAR2FileDescriptor desc;
            guint64 len_filename;
            char *filename;

            PRINT("File description found\n");

            if (read(fp, &desc, sizeof(desc)) != sizeof(desc)) {
                close(fp);
                return FALSE;
            }

            PRINT("file size = %lli\n", desc.length);

            len_filename = hdr.length - sizeof(hdr) - sizeof(desc);
            filename = g_slice_alloc0((int) len_filename + 1);
            if (read(fp, filename, (unsigned int) len_filename) != (unsigned int) len_filename) {
                close(fp);
                g_slice_free1((int) len_filename + 1, filename);
                return FALSE;
            }

            PRINT("filename = %s\n", filename);

            g_assert(file == NULL);
            file = g_slice_new0(PAR2File);

            strncpy((char*) file->filename, filename, sizeof(file->filename));
            memcpy(&file->file_id, desc.file_id, sizeof(desc.file_id));
            memcpy(&file->md5_hash_total, desc.md5_hash, sizeof(desc.md5_hash));
            memcpy(&file->md5_hash_16k, desc.md5_16k_hash, sizeof(desc.md5_hash));
            file->file_size = desc.length;

            *files = g_list_append(*files, file);

            g_slice_free1((int) len_filename + 1, filename);

            continue;
        }

        if (test_par2_is_file_verification_type(hdr.type)) {
            PAR2FileSliceChecksum checksum;
            int num_slices;
            int i;

            PRINT("File verification found\n");

            if (read(fp, &checksum, sizeof(checksum)) != sizeof(checksum)) {
                close(fp);
                return FALSE;
            }

            num_slices = (int) hdr.length - sizeof(hdr) - sizeof(checksum);

            g_assert(num_slices % 20 == 0);

            num_slices /= 20;

            for (i = 0; i 00259                 PAR2FileSliceChecksumPart slice;
                PAR2FileSliceChecksumPart *slice_dup;
                int j;

                if (read(fp, &slice, sizeof(slice)) != sizeof(slice)) {
                    close(fp);
                    return FALSE;
                }

                g_assert(file != NULL);

                slice_dup = g_slice_new0(PAR2FileSliceChecksumPart);
                memcpy(slice_dup, &slice, sizeof(PAR2FileSliceChecksumPart));

                file->slices = g_list_append(file->slices, slice_dup);

                PRINT("MD5 = ", slice.md5_hash);
                for (j = 0; j 00277                     PRINT("%02x", slice.md5_hash[j]);
                }
                PRINT("\n");
            }

            file = NULL;

            continue;
        }

        if (test_par2_is_main_packet_type(hdr.type)) {
            PAR2Main main_data;
            guint64 len;
            char *data;

            if (read(fp, &main_data, sizeof(main_data)) != sizeof(main_data)) {
                close(fp);
                return FALSE;
            }

            PRINT("num files = %i\n", main_data.num_files);
            PRINT("blocksize = %lli\n", main_data.blocksize);

            *block_size = main_data.blocksize;

            // Ignore the rest of this packet
            len = hdr.length - sizeof(hdr) - sizeof(main_data);
            data = g_slice_alloc0((int) len);
            if (read(fp, data, (int) len) != (int) len) {
                close(fp);
                g_slice_free1((int) len, data);
                return FALSE;
            }

            g_slice_free1((int) len, data);

            continue;
        }

        if (test_par2_is_recovery_block_packet_type(hdr.type)) {
            // We aren't interested in this part of the PAR2 file
            int len_remaining_data = (int) hdr.length - sizeof(hdr);
            void *data = g_slice_alloc0(len_remaining_data);
            if (read(fp, data, len_remaining_data) != len_remaining_data) {
                close(fp);
                g_slice_free1(len_remaining_data, data);
                return FALSE;
            }

            g_slice_free1(len_remaining_data, data);

            continue;
        }

        if (test_par2_is_creator_packet_type(hdr.type)) {
            // We aren't interested in this part of the PAR2 file
            int len_remaining_data = (int) hdr.length - sizeof(hdr);
            void *data = g_slice_alloc0(len_remaining_data);
            if (read(fp, data, len_remaining_data) != len_remaining_data) {
                close(fp);
                g_slice_free1(len_remaining_data, data);
                return FALSE;
            }

            g_slice_free1(len_remaining_data, data);

            continue;
        }

        PRINT("Unknown PAR2 type: %s\n", hdr.type + 8);

        // We aren't interested in the other parts of the PAR2 file
        len_remaining_data = (int) hdr.length - sizeof(hdr);
        data = g_slice_alloc0(len_remaining_data);
        if (read(fp, data, len_remaining_data) != len_remaining_data) {
            close(fp);
            g_slice_free1(len_remaining_data, data);
            return FALSE;
        }
        g_slice_free1(len_remaining_data, data);
    } while (TRUE);

    PRINT("\n\n");

    close(fp);
    return TRUE;
}

gboolean
par2_test_file(const char *directory, PAR2File *par2file, guint64 blocksize, int *num_blocks_found, int *num_blocks_missing)
{
    int fp;
    char *filename;
    char data[4];
    int count = 0;
    MD5_CTX ctx;
    int pos = 0;

    g_assert(num_blocks_found);
    g_assert(num_blocks_missing);

    *num_blocks_found = 0;
    *num_blocks_missing = 0;

    filename = g_build_filename(directory, G_DIR_SEPARATOR_S, par2file->filename, NULL);
#ifdef WIN32
    fp = open(filename, O_RDONLY | O_BINARY);
#else
    fp = open(filename, O_RDONLY);
#endif
    if (!fp) {
        return FALSE;
    }

    if (!MD5_Init(&ctx)) {
        g_print("MD5_Init FAILED\n");
        return FALSE;
    }

    // Keep on reading blocks of 4 bytes until we've reached the blocksize
    do {
        int len;

        memset(&data, 0, sizeof(data));
        len = read(fp, &data, sizeof(data));
        if (len == -1) {    // Error occured
            close(fp);
            return FALSE;
        }

        if (len sizeof(data)) {
            if (len == 0 && count == 0) {
                // No need to pad
                break;
            }

            // Padding required
            len = sizeof(data);
        }

        if (!MD5_Update(&ctx, data, sizeof(data))) {
            g_print("MD5_Update FAILED\n");
            return FALSE;
        }

        count += len;
        if (count == blocksize) {
            // Enough data read, verify the MD5
            unsigned char md5[16];
            PAR2FileSliceChecksumPart *slice;
            int j;

            if (!MD5_Final((unsigned char*) &md5, &ctx)) {
                g_print("MD5_Final FAILED\n");
                return FALSE;
            }

            slice = (PAR2FileSliceChecksumPart*) g_list_nth(par2file->slices, pos)->data;

            if (!memcmp(slice->md5_hash, md5, sizeof(md5))) {
                // Good part found!
                *num_blocks_found += 1;
            } else {
                // Bad part found
                *num_blocks_missing += 1;
            }

            PRINT("\tMD5 detected = ");

            for (j = 0; j 00447                 PRINT("%02x", md5[j]);
            }
            PRINT("\n");

            pos++;
            count = 0;
            MD5_Init(&ctx);
        }
    } while (TRUE);

    close(fp);

    return TRUE;
}

---