lib3ddevil1/main.c

#include "devil1pld.h"
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void unpackpld(const char *buffer, struct PldHeader *pldh) {
    unsigned int i     = 0;
    char *wbuffer      = NULL; // write buffer that will change.
    unsigned int wsize = 0;    // size of wbuffer.
    for (i; (i + 1) < (pldh -> numOffset); i++) {
        printf("start: %x - end: %x\n", 
            pldh -> offsets[i], 
            pldh -> offsets[i + 1]);
/*         wsize   = offsets[i + 1] - offsets[i];
        wbuffer = (char*)malloc(sizeof(char) * wsize);
        memcpy(wbuffer, buffer[offsets[i]], wsize); */
    }
    free(wbuffer);
}

void disp_pldheader(struct PldHeader *x) {
    printf("number of offsets = %i\n", x -> numOffset);
    unsigned int i;
    for (i = 0; i < x -> numOffset; i++) {
        printf("offset %i = %x\n", i, x -> offsets[i]);
    }
}

bool read_pldheader(const char *buffer) {
    if (buffer == NULL) {
        return false;
    }
    int32_t *n = (int32_t*)buffer;
    struct PldHeader *ph      = (struct PldHeader*)malloc(
        sizeof(struct PldHeader)
    );   
    uint32_t size_offsets = sizeof(uint32_t) * n[0];
    ph -> offsets             = (uint32_t*)malloc(size_offsets);
    if (ph -> offsets == NULL) {
        perror("Error 4: ");
        free(ph);
        free(ph -> offsets);
        return false;
    }
    // set data of struct.
    ph -> numOffset = n[0];
    memcpy(ph -> offsets, buffer + sizeof(int32_t), size_offsets);
    disp_pldheader(ph);
    unpackpld(buffer, ph);
    free(ph -> offsets);
    free(ph);
    return true;
}

bool readpld(const char *fname, char *buf) {
    FILE *f           = fopen(fname, "rb");
    unsigned int size = 0; // number of elements to buffer;
    unsigned int rcnt = 0; // number of char's read by fread(...)
    if (f == NULL) {
        perror("Error 1: ");
        return false;
    }
    // this method of determining file size doesn't work until 2 GB.
    fseek(f, 0, SEEK_END);
    size = ftell(f);
    rewind(f);
    buf = (char*)malloc(sizeof(char) * size);
    if (buf == NULL) {
        perror("Error 2: ");
        free(buf);
        return false;
    }
    rcnt = fread(buf, sizeof(char), size, f);
    if (rcnt < size) {
        perror("Error 3: ");
        free(buf);
        return false;
    }
    read_pldheader(buf);
    fclose(f);
    return true;
}

int main(int argc, char ** argv) {
    char *filename  = argv[1];
    char *filedata    = NULL;
    bool status     = readpld(filename, filedata);
    if (status) {
        printf("Read OK");
    } else {
        printf("Read not-OK");
    }
    free(filedata);
    return 0;
}