From 49636ad9c6e511591d340f6df068a3de8d51f7c8 Mon Sep 17 00:00:00 2001 From: Imanol-Mikel Barba Sabariego Date: Mon, 1 Jun 2020 01:42:02 +0100 Subject: [PATCH] Added error codes --- chunk.c | 70 +++++++++++++++++++++++++++------------------------------------------- chunk.h | 1 + compression.c | 24 ++++++++---------------- compression.h | 2 ++ nbt.c | 76 ++++++++++++++++++++++++++++++++++++++++++---------------------------------- nbt.h | 6 ++++-- 6 files changed, 84 insertions(+), 95 deletions(-) diff --git a/chunk.c b/chunk.c index 975ebed..8971253 100644 --- a/chunk.c +++ b/chunk.c @@ -35,57 +35,55 @@ int overwriteChunk(const char* regionFolder, ChunkID chunk, void* chunkData, siz sprintf(regionFilename,"%s/r.%d.%d.mca",regionFolder,region.x,region.z); if(access(regionFilename,R_OK | W_OK) == -1) { - fprintf(stderr,"Can't access file %s: %s\n",regionFilename,strerror(errno)); - return -1; + return ACCESS_ERROR; } int fd = open(regionFilename,O_RDWR); if(fd == -1) { - fprintf(stderr,"Unable to open region file %s: %s\n",regionFilename,strerror(errno)); - return -2; + return OPEN_ERROR; } free(regionFilename); uint32_t chunkHeaderOffset; if(pread(fd,&chunkHeaderOffset,sizeof(uint32_t),(relativeChunk.x + relativeChunk.z * CHUNK_OFFSET_LENGTH) * sizeof(uint32_t)) == -1) { close(fd); - fprintf(stderr,"Unable to read chunk header offset: %s\n",strerror(errno)); - return -3; + return READ_ERROR; } uint32_t totalChunkLength = (chunkHeaderOffset >> 24) * 4096; chunkHeaderOffset = (__bswap_32(chunkHeaderOffset & 0x00FFFFFF) >> 8) * CHUNK_SECTOR_SIZE; int pos = lseek(fd,chunkHeaderOffset,SEEK_SET); if(pos == -1) { close(fd); - fprintf(stderr,"Unable to seek to header offset: %s\n",strerror(errno)); - return -4; + return SEEK_ERROR; } ChunkHeader header; if(pread(fd,&header,sizeof(ChunkHeader),pos) <= 0) { close(fd); - fprintf(stderr,"Unable to read chunk header: %s\n",strerror(errno)); - return -5; + return READ_ERROR; } header.length = __bswap_32(header.length); void* compressedChunk; ssize_t compressedChunkLength = deflateGzip(chunkData,chunkLength,&compressedChunk,(header.compressionType == COMPRESSION_TYPE_ZLIB)); + if(compressedChunkLength < 0) { + // Compression error + close(fd); + return compressedChunkLength; + } if(compressedChunkLength > totalChunkLength) { // Haven't determined if we can just allocate a new 4KiB sector for the chunk // To avoid corrupting the region, let's just make the function fail and retry on another chunk that has // free space at the end close(fd); free(compressedChunk); - fprintf(stderr,"Not enough free space to overwrite the chunk.\n\nOriginal chunk size (with padding): %d\nNew chunk size:%d\n",totalChunkLength,(unsigned int)compressedChunkLength); - return -6; + return INSUFFICIENT_SPACE_FOR_CHUNK; } header.length = __bswap_32((uint32_t)compressedChunkLength+1); if(write(fd,&header,sizeof(ChunkHeader)) <= 0) { close(fd); free(compressedChunk); - fprintf(stderr,"Unable to read chunk header: %s\n",strerror(errno)); - return -7; + return WRITE_ERROR; } ssize_t nWritten = 0; size_t totalWritten = 0; @@ -95,16 +93,15 @@ int overwriteChunk(const char* regionFolder, ChunkID chunk, void* chunkData, siz if(errno == EINTR) { continue; } - fprintf(stderr,"Unable to write chunk: %s\n",strerror(errno)); close(fd); free(compressedChunk); - return -8; + return WRITE_ERROR; } totalWritten += nWritten; } close(fd); free(compressedChunk); - return 0; + return SUCCESS; } ssize_t loadChunk(const char* regionFolder, ChunkID chunk, void** chunkData) { @@ -117,53 +114,42 @@ ssize_t loadChunk(const char* regionFolder, ChunkID chunk, void** chunkData) { sprintf(regionFilename,"%s/r.%d.%d.mca",regionFolder,region.x,region.z); if(access(regionFilename,R_OK) == -1) { - fprintf(stderr,"Can't access file %s: %s\n",regionFilename,strerror(errno)); - return -1; + return ACCESS_ERROR; } int fd = open(regionFilename,O_RDONLY); if(fd == -1) { - fprintf(stderr,"Unable to open region file %s: %s\n",regionFilename,strerror(errno)); - return -2; + return OPEN_ERROR; } free(regionFilename); uint32_t chunkHeaderOffset; if(pread(fd,&chunkHeaderOffset,sizeof(uint32_t),(relativeChunk.x + relativeChunk.z * CHUNK_OFFSET_LENGTH) * sizeof(uint32_t)) == -1) { close(fd); - fprintf(stderr,"Unable to read chunk header offset: %s\n",strerror(errno)); - return -3; + return READ_ERROR; } chunkHeaderOffset = (__bswap_32(chunkHeaderOffset & 0x00FFFFFF) >> 8) * CHUNK_SECTOR_SIZE; if(chunkHeaderOffset == 0) { // Chunk not present. Hasn't been generated - close(fd); - return 0; + close(fd); + return CHUNK_NOT_PRESENT; } if(lseek(fd,chunkHeaderOffset,SEEK_SET) == -1) { close(fd); - fprintf(stderr,"Unable to seek to header offset: %s\n",strerror(errno)); - return -4; + return SEEK_ERROR; } ChunkHeader header; if(read(fd,&header,sizeof(ChunkHeader)) <= 0) { close(fd); - fprintf(stderr,"Unable to read chunk header: %s\n",strerror(errno)); - return -5; + return READ_ERROR; } header.length = __bswap_32(header.length); ssize_t chunkLength = header.length; - if(header.compressionType != COMPRESSION_TYPE_ZLIB && header.compressionType != COMPRESSION_TYPE_GZIP) { - fprintf(stderr, "Invalid compression method. Proably reading the wrong data for the header\n"); + if((header.compressionType != COMPRESSION_TYPE_ZLIB && header.compressionType != COMPRESSION_TYPE_GZIP) || header.length == 0) { close(fd); - return -6; - } - if(header.length == 0) { - fprintf(stderr, "Header length is 0. Probably reading the wrong data for the header\n"); - close(fd); - return -7; + return INVALID_HEADER; } void* compressedChunk = calloc(chunkLength,sizeof(char)); @@ -175,10 +161,9 @@ ssize_t loadChunk(const char* regionFolder, ChunkID chunk, void** chunkData) { if(errno == EINTR) { continue; } - fprintf(stderr,"Unable to read chunk: %s\n",strerror(errno)); close(fd); free(compressedChunk); - return -8; + return READ_ERROR; } totalRead += nRead; } @@ -186,11 +171,10 @@ ssize_t loadChunk(const char* regionFolder, ChunkID chunk, void** chunkData) { void *decompressedChunk; chunkLength = inflateGzip(compressedChunk,chunkLength,&decompressedChunk,(header.compressionType == COMPRESSION_TYPE_ZLIB)); - - if(chunkLength <= 0) { - fprintf(stderr,"Error while decompressing chunk\n"); + if(chunkLength < 0) { + // Error while decompressing chunk free(compressedChunk); - return -9; + return chunkLength; } free(compressedChunk); diff --git a/chunk.h b/chunk.h index f45a4f3..543bcf2 100644 --- a/chunk.h +++ b/chunk.h @@ -12,6 +12,7 @@ #include #include "compression.h" +#include "errors.h" #define BLOCKS_PER_CHUNK 16 #define CHUNKS_PER_REGION 32 diff --git a/compression.c b/compression.c index 6edfd2e..b4a4b20 100644 --- a/compression.c +++ b/compression.c @@ -21,9 +21,8 @@ ssize_t inflateGzip(void* compData, size_t compDataLen, void** unCompData, int h } if(err != Z_OK) { - fprintf(stderr, "Unable to initialize zlib zstream for decompression\n"); free(uncomp); - return -1; + return ZLIB_STREAM_INIT_ERROR; } do { @@ -32,10 +31,9 @@ ssize_t inflateGzip(void* compData, size_t compDataLen, void** unCompData, int h // Increase size of output buffer void* newptr = realloc(uncomp,uncompLength + increase); if(newptr == NULL) { - fprintf(stderr,"Unable to request memory realloc\n"); inflateEnd(&strm); free(uncomp); - return -2; + return MEMORY_ERROR; } uncomp = newptr; uncompLength += increase; @@ -47,18 +45,16 @@ ssize_t inflateGzip(void* compData, size_t compDataLen, void** unCompData, int h // Inflate another chunk. err = inflate(&strm, Z_SYNC_FLUSH); if(err != Z_OK && err != Z_STREAM_END) { - fprintf(stderr, "Error while inflating buffer: %d - %s.\n", err,strm.msg); inflateEnd(&strm); free(uncomp); - return -3; + return ZLIB_INFLATE_ERROR; } } while(err != Z_STREAM_END); uncompLength = strm.total_out; if(inflateEnd(&strm) != Z_OK) { - fprintf(stderr,"Error while deallocating libz zstream\n"); free(uncomp); - return -4; + return ZLIB_STREAM_FREE_ERROR; } *unCompData = uncomp; @@ -85,9 +81,8 @@ ssize_t deflateGzip(void* unCompData, size_t unCompDataLen, void** compData, int } if(err != Z_OK) { - fprintf(stderr, "Unable to initialize zlib zstream for compression\n"); free(comp); - return -1; + return ZLIB_STREAM_INIT_ERROR; } do { @@ -96,10 +91,9 @@ ssize_t deflateGzip(void* unCompData, size_t unCompDataLen, void** compData, int // Increase size of output buffer void* newptr = realloc(comp, compLength + increase); if(newptr == NULL) { - fprintf(stderr,"Unable to request memory realloc\n"); deflateEnd(&strm); free(comp); - return -2; + return MEMORY_ERROR; } comp = newptr; compLength += increase; @@ -111,18 +105,16 @@ ssize_t deflateGzip(void* unCompData, size_t unCompDataLen, void** compData, int // deflate another chunk err = deflate(&strm, Z_FINISH); if(err != Z_OK && err != Z_STREAM_END) { - fprintf(stderr, "Error while deflating buffer: %d - %s\n",err,strm.msg); deflateEnd(&strm); free(comp); - return -3; + return ZLIB_DEFLATE_ERROR; } } while(err != Z_STREAM_END); compLength = strm.total_out; if(deflateEnd(&strm) != Z_OK) { - fprintf(stderr,"Error while deallocating libz zstream\n"); free(comp); - return -4; + return ZLIB_STREAM_FREE_ERROR; } if(!headerless) { diff --git a/compression.h b/compression.h index cacedcc..45123ed 100644 --- a/compression.h +++ b/compression.h @@ -5,6 +5,8 @@ #include #include +#include "errors.h" + #define OS_FLAG_OFFSET 0x9 ssize_t deflateGzip(void* unCompData, size_t unCompDataLen, void** compData, int headerless); diff --git a/nbt.c b/nbt.c index 7b89f3b..c3eeb37 100644 --- a/nbt.c +++ b/nbt.c @@ -8,18 +8,17 @@ void destroyTagList(TagList* l); void destroyTagCompound(TagCompound* tc); size_t getTypeSize(uint8_t type); unsigned int parseList(void* addr, TagList* tl, uint8_t type); -unsigned int parseCompound(void* addr, TagCompound* tc); -unsigned int parsePayload(void* addr,Tag* t); -unsigned int parseTag(void* addr, Tag* t); -size_t composeCompound(TagCompound* tc, void** data); -size_t composeList(uint8_t listType, TagList* tl, void** data); -size_t composePayload(Tag t, void** data); -size_t composeTag(Tag t, void** data); +ssize_t parseCompound(void* addr, TagCompound* tc); +ssize_t parsePayload(void* addr,Tag* t); +ssize_t parseTag(void* addr, Tag* t); +ssize_t composeCompound(TagCompound* tc, void** data); +ssize_t composeList(uint8_t listType, TagList* tl, void** data); +ssize_t composePayload(Tag t, void** data); +ssize_t composeTag(Tag t, void** data); ssize_t loadDB(const char* filename, void** data) { if(access(filename,R_OK) == -1) { - perror("Can't access file"); - return -1; + return ACCESS_ERROR; } struct stat sb; @@ -27,8 +26,7 @@ ssize_t loadDB(const char* filename, void** data) { int fd = open(filename,O_RDONLY); if(fd == -1) { - perror("Can't open file"); - return -2; + return OPEN_ERROR; } fstat(fd, &sb); @@ -44,8 +42,7 @@ ssize_t loadDB(const char* filename, void** data) { if(errno == EINTR) { continue; } - perror("Error reading file"); - return -7; + return READ_ERROR; } totalRead += nRead; } @@ -144,7 +141,7 @@ unsigned int parseList(void* addr, TagList* tl, uint8_t type) { return pos - addr; } -unsigned int parseCompound(void* addr, TagCompound* tc) { +ssize_t parseCompound(void* addr, TagCompound* tc) { void* pos = addr; unsigned int numTags = 0; Tag* list = calloc(REALLOC_SIZE,sizeof(Tag)); @@ -152,8 +149,8 @@ unsigned int parseCompound(void* addr, TagCompound* tc) { if(numTags && !(numTags % REALLOC_SIZE)) { void* newptr = reallocarray(list, numTags + REALLOC_SIZE, sizeof(Tag)); if(!newptr) { - fprintf(stderr,"Unable to request memory realloc\n"); - break; + free(list); + return MEMORY_ERROR; } list = newptr; } @@ -162,7 +159,8 @@ unsigned int parseCompound(void* addr, TagCompound* tc) { void* newptr = reallocarray(list, numTags, sizeof(Tag)); if(!newptr) { - fprintf(stderr,"Unable to request memory realloc\n"); + free(list); + return MEMORY_ERROR; } list = newptr; @@ -171,9 +169,10 @@ unsigned int parseCompound(void* addr, TagCompound* tc) { return pos - addr; } -unsigned int parsePayload(void* addr,Tag* t) { +ssize_t parsePayload(void* addr,Tag* t) { void* pos = addr; t->payloadLength = getTypeSize(t->type); // initially, then particularly for lists/compounds/strings + ssize_t compoundTagPos = 0; TagCompound* tc; TagList *tl; uint16_t u16 = 0; @@ -218,7 +217,12 @@ unsigned int parsePayload(void* addr,Tag* t) { tc = (TagCompound*)calloc(1,sizeof(TagCompound)); t->payloadLength = sizeof(sizeof(TagCompound)); t->payload = tc; - pos += parseCompound(pos,tc); + compoundTagPos = parseCompound(pos,tc); + if(compoundTagPos < 0) { + // Memory error while parsing TAG_COMPOUND + return compoundTagPos; + } + pos += compoundTagPos; break; case TAG_LIST: case TAG_BYTEARRAY: @@ -232,7 +236,7 @@ unsigned int parsePayload(void* addr,Tag* t) { return pos - addr; } -unsigned int parseTag(void* addr, Tag* t) { +ssize_t parseTag(void* addr, Tag* t) { void* pos = addr; t->type = *((uint8_t*)pos); t->nameLength = 0; @@ -247,12 +251,16 @@ unsigned int parseTag(void* addr, Tag* t) { } pos += sizeof(uint16_t) + t->nameLength; } - pos += parsePayload(pos,t); + ssize_t payloadPos = parsePayload(pos,t); + if(payloadPos < 0) { + return payloadPos; + } + pos += payloadPos; return pos-addr; } -size_t composeCompound(TagCompound* tc, void** data) { +ssize_t composeCompound(TagCompound* tc, void** data) { size_t totalPayloadLength = 0; void* totalPayload = calloc(1,sizeof(char)); unsigned int pos = 0; @@ -263,10 +271,9 @@ size_t composeCompound(TagCompound* tc, void** data) { totalPayloadLength += childTagPayloadLength; void* newptr = realloc(totalPayload,totalPayloadLength); if(newptr == NULL) { - fprintf(stderr, "Unable to realloc memory for child tag\n"); free(totalPayload); free(childTagPayload); - return 0; + return MEMORY_ERROR; } totalPayload = newptr; memcpy(totalPayload+pos,childTagPayload,childTagPayloadLength); @@ -275,9 +282,8 @@ size_t composeCompound(TagCompound* tc, void** data) { } void* newptr = realloc(totalPayload,++totalPayloadLength); if(newptr == NULL) { - fprintf(stderr, "Unable to realloc memory for end tag\n"); free(totalPayload); - return 0; + return MEMORY_ERROR; } totalPayload = newptr; ((uint8_t*)totalPayload)[pos] = 0x00; @@ -285,7 +291,7 @@ size_t composeCompound(TagCompound* tc, void** data) { return totalPayloadLength; } -size_t composeList(uint8_t listType, TagList* tl, void** data) { +ssize_t composeList(uint8_t listType, TagList* tl, void** data) { size_t totalPayloadLength = 0; if(listType == TAG_LIST) { totalPayloadLength += sizeof(uint8_t); @@ -306,10 +312,9 @@ size_t composeList(uint8_t listType, TagList* tl, void** data) { totalPayloadLength += childTagPayloadLength; void* newptr = realloc(totalPayload,totalPayloadLength); if(newptr == NULL) { - fprintf(stderr, "Unable to realloc memory for child tag\n"); free(totalPayload); free(childTagPayload); - return 0; + return MEMORY_ERROR; } totalPayload = newptr; memcpy(totalPayload+pos,childTagPayload,childTagPayloadLength); @@ -321,7 +326,7 @@ size_t composeList(uint8_t listType, TagList* tl, void** data) { return totalPayloadLength; } -size_t composePayload(Tag t, void** data) { +ssize_t composePayload(Tag t, void** data) { size_t payloadLength = getTypeSize(t.type); // initially, then particularly for lists/compounds/strings void* payload; @@ -371,7 +376,7 @@ size_t composePayload(Tag t, void** data) { return payloadLength; } -size_t composeTag(Tag t, void** data) { +ssize_t composeTag(Tag t, void** data) { size_t headerSize = sizeof(uint8_t) + sizeof(uint16_t) + t.nameLength; void* tagHeader = calloc(headerSize,sizeof(char)); ((uint8_t*)tagHeader)[0] = t.type; @@ -379,13 +384,16 @@ size_t composeTag(Tag t, void** data) { memcpy(tagHeader+sizeof(uint8_t),&u16,sizeof(uint16_t)); memcpy(tagHeader+sizeof(uint8_t) + sizeof(uint16_t), t.name, t.nameLength); void* tagPayload; - size_t payloadSize = composePayload(t,&tagPayload); + ssize_t payloadSize = composePayload(t,&tagPayload); + if(payloadSize < 0) { + // Some error while composing payload + return payloadSize; + } void* tagData = realloc(tagHeader,headerSize + payloadSize); if(tagData == NULL) { - fprintf(stderr, "Unable to realloc memory to merge header and payload\n"); free(tagHeader); free(tagPayload); - return 0; + return MEMORY_ERROR; } memcpy(tagData + headerSize,tagPayload, payloadSize); free(tagPayload); diff --git a/nbt.h b/nbt.h index ce49e14..8deda21 100644 --- a/nbt.h +++ b/nbt.h @@ -13,6 +13,8 @@ #include #include +#include "errors.h" + #ifndef REALLOC_SIZE #define REALLOC_SIZE 10 #endif @@ -59,7 +61,7 @@ enum TAG { ssize_t loadDB(const char* filename, void** data); void destroyTag(Tag* t); -unsigned int parseTag(void* addr, Tag* t); -size_t composeTag(Tag t, void** data); +ssize_t parseTag(void* addr, Tag* t); +ssize_t composeTag(Tag t, void** data); #endif \ No newline at end of file -- libgit2 0.22.2