Implement sector reading.

src/read.c

@@ -32,9 +32,13 @@
 
 #include <dicformat.h>
 #include <errno.h>
+#include <malloc.h>
+#include <string.h>
 
 uint8_t *read_media_tag(void *context, int32_t tag, uint32_t *length)
 {
+    dicformatContext *ctx;
+    dataLinkedList   *item;
     *length = 0;
 
     if(context == NULL)
@@ -43,7 +47,7 @@ uint8_t *read_media_tag(void *context, int32_t tag, uint32_t *length)
         return NULL;
     }
 
-    dicformatContext *ctx = context;
+    ctx = context;
 
     // TODO: Cast this field without casting the whole structure, as this can buffer overflow
     // Not a libdicformat context
@@ -53,7 +57,7 @@ uint8_t *read_media_tag(void *context, int32_t tag, uint32_t *length)
         return NULL;
     }
 
-    dataLinkedList *item = ctx->mediaTagsHead;
+    item = ctx->mediaTagsHead;
 
     while(item != NULL)
     {
@@ -67,4 +71,119 @@ uint8_t *read_media_tag(void *context, int32_t tag, uint32_t *length)
     }
 
     return NULL;
+}
+
+uint8_t *read_sector(void *context, uint64_t sectorAddress, uint32_t *length)
+{
+    dicformatContext *ctx;
+    uint64_t         ddtEntry;
+    uint32_t         offsetMask;
+    uint64_t         offset;
+    uint64_t         blockOffset;
+    uint8_t          *sector;
+    BlockHeader      blockHeader;
+    uint8_t          *block;
+    size_t           readBytes;
+
+    *length = 0;
+
+    if(context == NULL)
+    {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    ctx = context;
+
+    // TODO: Cast this field without casting the whole structure, as this can buffer overflow
+    // Not a libdicformat context
+    if(ctx->magic != DIC_MAGIC)
+    {
+        errno = EINVAL;
+        return NULL;
+    }
+
+    if(sectorAddress > ctx->imageInfo.Sectors - 1)
+    {
+        errno = DICF_ERROR_SECTOR_OUT_OF_BOUNDS;
+        return NULL;
+    }
+
+    ddtEntry    = ctx->userDataDdt[sectorAddress];
+    offsetMask  = (uint32_t)((1 << ctx->shift) - 1);
+    offset      = ddtEntry & offsetMask;
+    blockOffset = ddtEntry >> ctx->shift;
+
+    // Partially written image... as we can't know the real sector size just assume it's common :/
+    if(ddtEntry == 0)
+    {
+        sector = (uint8_t *)malloc(ctx->imageInfo.SectorSize);
+
+        if(sector == NULL)
+        {
+            errno = ENOMEM;
+            return NULL;
+        }
+
+        memset(sector, 0, ctx->imageInfo.SectorSize);
+        *length = ctx->imageInfo.SectorSize;
+        return sector;
+    }
+
+    // Check if block is cached
+    // TODO: Caches
+
+    // Read block header
+    fseek(ctx->imageStream, blockOffset, SEEK_SET);
+    readBytes = fread(&blockHeader, sizeof(BlockHeader), 1, ctx->imageStream);
+
+    if(readBytes != sizeof(BlockHeader))
+    {
+        errno = DICF_ERROR_CANNOT_READ_HEADER;
+        return NULL;
+    }
+
+    // Decompress block
+    switch(blockHeader.compression)
+    {
+        case None:block = (uint8_t *)malloc(blockHeader.length);
+            if(block == NULL)
+            {
+                errno = ENOMEM;
+                return NULL;
+            }
+
+            readBytes = fread(block, blockHeader.length, 1, ctx->imageStream);
+
+            if(readBytes != blockHeader.length)
+            {
+                free(block);
+                errno = DICF_ERROR_CANNOT_READ_BLOCK;
+                return NULL;
+            }
+
+            break;
+        default:errno = DICF_ERROR_UNSUPPORTED_COMPRESSION;
+            return NULL;
+    }
+
+    // Check if cache needs to be emptied
+    // TODO: Caches
+
+    // Add block to cache
+    // TODO: Caches
+
+    sector = (uint8_t *)malloc(blockHeader.sectorSize);
+
+    if(sector == NULL)
+    {
+        free(block);
+        errno = ENOMEM;
+        return NULL;
+    }
+
+    memcpy(sector, block + offset, blockHeader.sectorSize);
+    *length = blockHeader.sectorSize;
+    free(block);
+    return sector;
 }