diff --git a/src/xmount.c b/src/xmount.c
index cae2851..bac6ddc 100755
--- a/src/xmount.c
+++ b/src/xmount.c
@@ -1,2170 +1,2168 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * xmount is a small tool to "fuse mount" various harddisk image formats as dd, *
 * vdi, vhd or vmdk files and enable virtual write access to them.              *
 *                                                                              *
 * 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 3 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, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #include <config.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 #include <inttypes.h> // For PRI*
 #include <errno.h>
 #include <dlfcn.h> // For dlopen, dlclose, dlsym
 #include <dirent.h> // For opendir, readdir, closedir
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h> // For fstat
 #include <sys/types.h>
 #ifdef HAVE_LINUX_FS_H
   #include <linux/fs.h> // For SEEK_* ??
 #endif
 #if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
   #include <grp.h> // For getgrnam, struct group
   #include <pwd.h> // For getpwuid, struct passwd
 #endif
 #include <pthread.h>
 #include <time.h> // For time
 
 #include "xmount.h"
 #include "xmount_fuse.h"
 #include "md5.h"
 #include "macros.h"
 #include "../libxmount/libxmount.h"
 
 #define XMOUNT_COPYRIGHT_NOTICE \
   "xmount v%s Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>"
 
 #define LOG_WARNING(...) {            \
   LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
 }
 #define LOG_ERROR(...) {            \
   LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
 }
 #define LOG_DEBUG(...) {                              \
   LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
 }
 
 #define HASH_AMOUNT (1024*1024)*10 // Amount of data used to construct a
                                    // "unique" hash for every input image
                                    // (10MByte)
 
 /*******************************************************************************
  * Forward declarations
  ******************************************************************************/
 /*
  * Misc
  */
 static void InitResources();
 static void FreeResources();
 static void PrintUsage(char*);
 static void CheckFuseSettings();
 static int ParseCmdLine(const int, char**);
 static int ExtractOutputFileNames(char*);
 static int CalculateInputImageHash(uint64_t*, uint64_t*);
 /*
  * Info file
  */
 static int InitInfoFile();
 /*
  * Lib related
  */
 static int LoadLibs();
 static int FindInputLib(pts_InputImage);
 static int FindMorphingLib();
 static int FindOutputLib();
 static int SplitLibraryParameters(char*, uint32_t*, pts_LibXmountOptions**);
 /*
  * Functions exported to LibXmount_Morphing
  */
 static int LibXmount_Morphing_ImageCount(uint64_t*);
 static int LibXmount_Morphing_Size(uint64_t, uint64_t*);
 static int LibXmount_Morphing_Read(uint64_t, char*, off_t, size_t, size_t*);
 /*
  * Functions exported to LibXmount_Output
  */
 static int LibXmount_Output_Size(uint64_t*);
 static int LibXmount_Output_Read(char*, off_t, size_t, size_t*);
 static int LibXmount_Output_Write(char*, off_t, size_t, size_t*);
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 //! Print usage instructions (cmdline options etc..)
 /*!
  * \param p_prog_name Program name (argv[0])
  */
 static void PrintUsage(char *p_prog_name) {
   char *p_buf;
   int first;
   int ret;
 
   printf("\n" XMOUNT_COPYRIGHT_NOTICE "\n",XMOUNT_VERSION);
   printf("\nUsage:\n");
   printf("  %s [fopts] <xopts> <mntp>\n\n",p_prog_name);
   printf("Options:\n");
   printf("  fopts:\n");
   printf("    -d : Enable FUSE's and xmount's debug mode.\n");
   printf("    -h : Display this help message.\n");
   printf("    -s : Run single threaded.\n");
   printf("    -o no_allow_other : Disable automatic addition of FUSE's "
            "allow_other option.\n");
   printf("    -o <fopts> : Specify fuse mount options. Will also disable "
            "automatic addition of FUSE's allow_other option!\n");
   printf("\n");
   printf("  xopts:\n");
   printf("    --cache <cfile> : Enable virtual write support.\n");
   printf("      <cfile> specifies the cache file to use.\n");
   printf("    --in <itype> <ifile> : Input image format and source file(s). "
            "May be specified multiple times.\n");
   printf("      <itype> can be ");
 
   // List supported input formats
   first=1;
   for(uint32_t i=0;i<glob_xmount.input.libs_count;i++) {
     p_buf=glob_xmount.input.pp_libs[i]->p_supported_input_types;
     while(*p_buf!='\0') {
       if(first==1) {
         printf("\"%s\"",p_buf);
         first=0;
       } else printf(", \"%s\"",p_buf);
       p_buf+=(strlen(p_buf)+1);
     }
   }
   printf(".\n");
 
   printf("      <ifile> specifies the source file. If your image is split into "
            "multiple files, you have to specify them all!\n");
   printf("    --inopts <iopts> : Specify input library specific options.\n");
   printf("      <iopts> specifies a comma separated list of key=value options. "
            "See below for details.\n");
   printf("    --info : Print out infos about used compiler and libraries.\n");
   printf("    --morph <mtype> : Morphing function to apply to input image(s). "
            "If not specified, defaults to \"combine\".\n");
   printf("      <mtype> can be ");
 
   // List supported morphing functions
   first=1;
   for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
     p_buf=glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types;
     while(*p_buf!='\0') {
       if(first==1) {
         printf("\"%s\"",p_buf);
         first=0;
       } else printf(", \"%s\"",p_buf);
       p_buf+=(strlen(p_buf)+1);
     }
   }
   printf(".\n");
 
   printf("    --morphopts <mopts> : Specify morphing library specific "
            "options.\n");
   printf("      <mopts> specifies a comma separated list of key=value options. "
            "See below for details.\n");
   printf("    --offset <off> : Move the output image data start <off> bytes "
            "into the input image(s).\n");
   printf("    --out <otype> : Output image format. If not specified, "
            "defaults to ");
 #ifdef __APPLE__
   printf("\"dmg\".\n");
 #else
   printf("\"raw\".\n");
 #endif
   printf("      <otype> can be ");
 
   // List supported output formats
   first=1;
   for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
     p_buf=glob_xmount.output.pp_libs[i]->p_supported_output_formats;
     while(*p_buf!='\0') {
       if(first==1) {
         printf("\"%s\"",p_buf);
         first=0;
       } else printf(", \"%s\"",p_buf);
       p_buf+=(strlen(p_buf)+1);
     }
   }
   printf(".\n");
 
   printf("    --outopts <oopts> : Specify output library specific "
            "options.\n");
   printf("    --owcache <file> : Same as --cache <file> but overwrites "
            "existing cache file.\n");
   printf("    --sizelimit <size> : The data end of input image(s) is set to no "
            "more than <size> bytes after the data start.\n");
   printf("    --version : Same as --info.\n");
   printf("\n");
   printf("  mntp:\n");
   printf("    Mount point where output image should be located.\n");
   printf("\n");
   printf("Infos:\n");
   printf("  * One --in option and a mount point are mandatory!\n");
   printf("  * If you specify --in multiple times, data from all images is "
            "morphed into one output image using the specified morphing "
            "function.\n");
   printf("  * For VMDK emulation, you have to uncomment \"user_allow_other\" "
            "in /etc/fuse.conf or run xmount as root.\n");
   printf("\n");
   printf("Input / Morphing library specific options:\n");
   printf("  Input / Morphing libraries might support an own set of "
            "options to configure / tune their behaviour.\n");
   printf("  Libraries supporting this feature (if any) and their "
            "options are listed below.\n");
   printf("\n");
 
   // List input, morphing and output lib options
   for(uint32_t i=0;i<glob_xmount.input.libs_count;i++) {
     ret=glob_xmount.input.pp_libs[i]->
           lib_functions.OptionsHelp((const char**)&p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to get options help for library '%s': %s!\n",
                 glob_xmount.input.pp_libs[i]->p_name,
                 glob_xmount.input.pp_libs[i]->
                   lib_functions.GetErrorMessage(ret));
     }
     if(p_buf==NULL) continue;
     printf("  - %s\n",glob_xmount.input.pp_libs[i]->p_name);
     printf("%s",p_buf);
     printf("\n");
     ret=glob_xmount.input.pp_libs[i]->lib_functions.FreeBuffer(p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to free options help text from library '%s': %s!\n",
                 glob_xmount.input.pp_libs[i]->p_name,
                 glob_xmount.input.pp_libs[i]->
                   lib_functions.GetErrorMessage(ret));
     }
   }
   for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
     ret=glob_xmount.morphing.pp_libs[i]->
           lib_functions.OptionsHelp((const char**)&p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to get options help for library '%s': %s!\n",
                 glob_xmount.morphing.pp_libs[i]->p_name,
                 glob_xmount.morphing.pp_libs[i]->
                   lib_functions.GetErrorMessage(ret));
     }
     if(p_buf==NULL) continue;
     printf("  - %s\n",glob_xmount.morphing.pp_libs[i]->p_name);
     printf("%s",p_buf);
     printf("\n");
   }
   for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
     ret=glob_xmount.output.pp_libs[i]->
           lib_functions.OptionsHelp((const char**)&p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to get options help for library '%s': %s!\n",
                 glob_xmount.output.pp_libs[i]->p_name,
                 glob_xmount.output.pp_libs[i]->
                   lib_functions.GetErrorMessage(ret));
     }
     if(p_buf==NULL) continue;
     printf("  - %s\n",glob_xmount.output.pp_libs[i]->p_name);
     printf("%s",p_buf);
     printf("\n");
   }
 }
 
 //! Check fuse settings
 /*!
  * Check if FUSE allows us to pass the -o allow_other parameter. This only works
  * if we are root or user_allow_other is set in /etc/fuse.conf.
  *
  * In addition, this function also checks if the user is member of the fuse
  * group which is generally needed to use fuse at all.
  */
 static void CheckFuseSettings() {
 #if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
   struct group *p_group;
   struct passwd *p_passwd;
 #endif
   int found;
   FILE *h_fuse_conf;
   char line[256];
 
   glob_xmount.may_set_fuse_allow_other=FALSE;
 
   if(geteuid()==0) {
     // Running as root, there should be no problems
     glob_xmount.may_set_fuse_allow_other=TRUE;
     return;
   }
 
 #if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
   // Check if a fuse group exists and if so, make sure user is a member of it.
   // Makes only sense on Linux because as far as I know osxfuse has no own group
   p_group=getgrnam("fuse");
   if(p_group!=NULL) {
     // Get effective user name
     p_passwd=getpwuid(geteuid());
     if(p_passwd==NULL) {
       printf("\nWARNING: Unable to determine your effective user name. If "
              "mounting works, you can ignore this message.\n\n");
       return;
     }
     // Check if user is member of fuse group
     found=FALSE;
     while(*(p_group->gr_mem)!=NULL) {
       if(strcmp(*(p_group->gr_mem),p_passwd->pw_name)==0) {
         found=TRUE;
         break;
       }
       p_group->gr_mem++;
     }
     if(found==FALSE) {
       printf("\nWARNING: You are not a member of the \"fuse\" group. This will "
                "prevent you from mounting images using xmount. Please add "
                "yourself to the \"fuse\" group using the command "
                "\"sudo usermod -a -G fuse %s\" and reboot your system or "
                "execute xmount as root.\n\n",
              p_passwd->pw_name);
       return;
     }
   } else {
     printf("\nWARNING: Your system does not seem to have a \"fuse\" group. If "
              "mounting works, you can ignore this message.\n\n");
   }
 #endif
 
   // Read FUSE's config file /etc/fuse.conf and check for set user_allow_other
   h_fuse_conf=(FILE*)FOPEN("/etc/fuse.conf","r");
   if(h_fuse_conf!=NULL) {
     // Search conf file for set user_allow_others
     found=FALSE;
     while(fgets(line,sizeof(line),h_fuse_conf)!=NULL) {
       // TODO: This works as long as there is no other parameter beginning with
       // "user_allow_other" :)
       if(strncmp(line,"user_allow_other",16)==0) {
         found=TRUE;
         break;
       }
     }
     fclose(h_fuse_conf);
     if(found==TRUE) {
       glob_xmount.may_set_fuse_allow_other=TRUE;
     } else {
       printf("\nWARNING: FUSE will not allow other users nor root to access "
                "your virtual harddisk image. To change this behavior, please "
                "add \"user_allow_other\" to /etc/fuse.conf or execute xmount "
                "as root.\n\n");
     }
   } else {
     printf("\nWARNING: Unable to open /etc/fuse.conf. If mounting works, you "
              "can ignore this message. If you encounter issues, please create "
              "the file and add a single line containing the string "
              "\"user_allow_other\" or execute xmount as root.\n\n");
     return;
   }
 }
 
 //! Parse command line options
 /*!
  * \param argc Number of cmdline params
  * \param pp_argv Array containing cmdline params
  * \return TRUE on success, FALSE on error
  */
 static int ParseCmdLine(const int argc, char **pp_argv) {
   int i=1;
   int FuseMinusOControl=TRUE;
   int FuseAllowOther=TRUE;
   int first;
   char *p_buf;
   pts_InputImage p_input_image=NULL;
   int ret;
 
   // add pp_argv[0] to FUSE's argv
   XMOUNT_MALLOC(glob_xmount.pp_fuse_argv,char**,sizeof(char*));
   XMOUNT_STRSET(glob_xmount.pp_fuse_argv[0],pp_argv[0]);
   glob_xmount.fuse_argc=1;
 
   // Parse options
   while(i<argc && *pp_argv[i]=='-') {
     if(strlen(pp_argv[i])>1 && *(pp_argv[i]+1)!='-') {
       // Options beginning with one - are mostly FUSE specific
       if(strcmp(pp_argv[i],"-d")==0) {
         // Enable FUSE's and xmount's debug mode
         XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                        char**,
                        (glob_xmount.fuse_argc+1)*sizeof(char*));
         XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
                       pp_argv[i])
         glob_xmount.fuse_argc++;
         glob_xmount.debug=TRUE;
       } else if(strcmp(pp_argv[i],"-h")==0) {
         // Print help message
         PrintUsage(pp_argv[0]);
         exit(0);
       } else if(strcmp(pp_argv[i],"-o")==0) {
         // Next parameter specifies fuse mount options
         if((i+1)<argc) {
           i++;
           // As the user specified the -o option, we assume he knows what he is
           // doing. We won't append allow_other automatically. And we allow him
           // to disable allow_other by passing a single "-o no_allow_other"
           // which won't be passed to FUSE as it is xmount specific.
           if(strcmp(pp_argv[i],"no_allow_other")!=0) {
             glob_xmount.fuse_argc+=2;
             XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                            char**,
                            glob_xmount.fuse_argc*sizeof(char*));
             XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-2],
                           pp_argv[i-1]);
             XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                           pp_argv[i]);
             FuseMinusOControl=FALSE;
           } else FuseAllowOther=FALSE;
         } else {
           LOG_ERROR("Couldn't parse fuse mount options!\n")
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"-s")==0) {
         // Enable FUSE's single threaded mode
         XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                        char**,
                        (glob_xmount.fuse_argc+1)*sizeof(char*));
         XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
                       pp_argv[i]);
         glob_xmount.fuse_argc++;
       } else if(strcmp(pp_argv[i],"-V")==0) {
         // Display FUSE version info
         XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                        char**,
                        (glob_xmount.fuse_argc+1)*sizeof(char*));
         XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
                       pp_argv[i]);
         glob_xmount.fuse_argc++;
       } else {
         LOG_ERROR("Unknown command line option \"%s\"\n",pp_argv[i]);
         return FALSE;
       }
     } else {
       // Options beginning with -- are xmount specific
       if(strcmp(pp_argv[i],"--cache")==0 /*|| strcmp(pp_argv[i],"--rw")==0*/) {
         // Emulate writable access to mounted image
         // Next parameter must be cache file to read/write changes from/to
         if((i+1)<argc) {
           i++;
-          XMOUNT_STRSET(glob_xmount.cache.p_cache_file,pp_argv[i])
+          XMOUNT_STRSET(glob_xmount.args.p_cache_file,pp_argv[i])
           glob_xmount.output.writable=TRUE;
         } else {
           LOG_ERROR("You must specify a cache file!\n")
           return FALSE;
         }
         LOG_DEBUG("Enabling virtual write support using cache file \"%s\"\n",
-                  glob_xmount.cache.p_cache_file)
+                  glob_xmount.args.p_cache_file)
       } else if(strcmp(pp_argv[i],"--in")==0) {
         // Specify input image type and source files
         if((i+2)<argc) {
           i++;
           // Alloc and init new ts_InputImage struct
           XMOUNT_MALLOC(p_input_image,pts_InputImage,sizeof(ts_InputImage));
           XMOUNT_STRSET(p_input_image->p_type,pp_argv[i]);
           p_input_image->pp_files=NULL;
           p_input_image->p_functions=NULL;
           p_input_image->p_handle=NULL;
           // Parse input image filename(s) and add to p_input_image->pp_files
           i++;
           p_input_image->files_count=0;
           while(i<(argc-1) && strncmp(pp_argv[i],"--",2)!=0) {
             p_input_image->files_count++;
             XMOUNT_REALLOC(p_input_image->pp_files,
                            char**,
                            p_input_image->files_count*sizeof(char*));
             XMOUNT_STRSET(p_input_image->pp_files[p_input_image->files_count-1],
                           pp_argv[i]);
             i++;
           }
           i--;
           if(p_input_image->files_count==0) {
             LOG_ERROR("No input files specified for \"--in %s\"!\n",
                       p_input_image->p_type)
             free(p_input_image->p_type);
             free(p_input_image);
             return FALSE;
           }
           // Add input image struct to input image array
           glob_xmount.input.images_count++;
           XMOUNT_REALLOC(glob_xmount.input.pp_images,
                          pts_InputImage*,
                          glob_xmount.input.images_count*
                            sizeof(pts_InputImage));
           glob_xmount.input.pp_images[glob_xmount.input.images_count-1]=
             p_input_image;
         } else {
           LOG_ERROR("You must specify an input image type and source file!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--inopts")==0) {
         // Set input lib options
         if((i+1)<argc) {
           i++;
           if(glob_xmount.input.pp_lib_params==NULL) {
             if(SplitLibraryParameters(pp_argv[i],
                                       &(glob_xmount.input.lib_params_count),
                                       &(glob_xmount.input.pp_lib_params)
                                      )==FALSE)
             {
               LOG_ERROR("Unable to parse input library options '%s'!\n",
                         pp_argv[i]);
               return FALSE;
             }
           } else {
             LOG_ERROR("You can only specify --inopts once!")
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify special options!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--morph")==0) {
         // Set morphing lib to use
         if((i+1)<argc) {
           i++;
           if(glob_xmount.morphing.p_morph_type==NULL) {
             XMOUNT_STRSET(glob_xmount.morphing.p_morph_type,pp_argv[i]);
           } else {
             LOG_ERROR("You can only specify --morph once!")
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify morphing type!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--morphopts")==0) {
         // Set morphing lib options
         if((i+1)<argc) {
           i++;
           if(glob_xmount.morphing.pp_lib_params==NULL) {
             if(SplitLibraryParameters(pp_argv[i],
                                       &(glob_xmount.morphing.lib_params_count),
                                       &(glob_xmount.morphing.pp_lib_params)
                                      )==FALSE)
             {
               LOG_ERROR("Unable to parse morphing library options '%s'!\n",
                         pp_argv[i]);
               return FALSE;
             }
           } else {
             LOG_ERROR("You can only specify --morphopts once!")
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify special morphing lib params!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--offset")==0) {
         // Set input image offset
         if((i+1)<argc) {
           i++;
           glob_xmount.input.image_offset=StrToUint64(pp_argv[i],&ret);
           if(ret==0) {
             LOG_ERROR("Unable to convert '%s' to a number!\n",pp_argv[i])
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify an offset!\n")
           return FALSE;
         }
         LOG_DEBUG("Setting input image offset to \"%" PRIu64 "\"\n",
                   glob_xmount.input.image_offset)
       } else if(strcmp(pp_argv[i],"--out")==0) {
         // Set output lib to use
         if((i+1)<argc) {
           i++;
           if(glob_xmount.output.p_output_format==NULL) {
             XMOUNT_STRSET(glob_xmount.output.p_output_format,pp_argv[i]);
           } else {
             LOG_ERROR("You can only specify --out once!")
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify an output format!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--outopts")==0) {
         // Set output lib options
         if((i+1)<argc) {
           i++;
           if(glob_xmount.output.pp_lib_params==NULL) {
             if(SplitLibraryParameters(pp_argv[i],
                                       &(glob_xmount.output.lib_params_count),
                                       &(glob_xmount.output.pp_lib_params)
                                      )==FALSE)
             {
               LOG_ERROR("Unable to parse output library options '%s'!\n",
                         pp_argv[i]);
               return FALSE;
             }
           } else {
             LOG_ERROR("You can only specify --outopts once!")
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify special output lib params!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--owcache")==0) {
         // Enable writable access to mounted image and overwrite existing cache
         // Next parameter must be cache file to read/write changes from/to
         if((i+1)<argc) {
           i++;
-          XMOUNT_STRSET(glob_xmount.cache.p_cache_file,pp_argv[i])
+          XMOUNT_STRSET(glob_xmount.args.p_cache_file,pp_argv[i])
           glob_xmount.output.writable=TRUE;
-          glob_xmount.cache.overwrite_cache=TRUE;
+          glob_xmount.args.overwrite_cache=TRUE;
         } else {
           LOG_ERROR("You must specify a cache file!\n")
           return FALSE;
         }
         LOG_DEBUG("Enabling virtual write support overwriting cache file %s\n",
-                  glob_xmount.cache.p_cache_file)
+                  glob_xmount.args.p_cache_file)
       } else if(strcmp(pp_argv[i],"--sizelimit")==0) {
         // Set input image size limit
         if((i+1)<argc) {
           i++;
           glob_xmount.input.image_size_limit=StrToUint64(pp_argv[i],&ret);
           if(ret==0) {
             LOG_ERROR("Unable to convert '%s' to a number!\n",pp_argv[i])
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify a size limit!\n")
           return FALSE;
         }
         LOG_DEBUG("Setting input image size limit to \"%" PRIu64 "\"\n",
                   glob_xmount.input.image_size_limit)
       } else if(strcmp(pp_argv[i],"--version")==0 ||
                 strcmp(pp_argv[i],"--info")==0)
       {
         // Print xmount info
         printf(XMOUNT_COPYRIGHT_NOTICE "\n\n",XMOUNT_VERSION);
 #ifdef __GNUC__
         printf("  compile timestamp: %s %s\n",__DATE__,__TIME__);
         printf("  gcc version: %s\n",__VERSION__);
 #endif
         printf("  loaded input libraries:\n");
         for(uint32_t ii=0;ii<glob_xmount.input.libs_count;ii++) {
           printf("    - %s supporting ",glob_xmount.input.pp_libs[ii]->p_name);
           p_buf=glob_xmount.input.pp_libs[ii]->p_supported_input_types;
           first=TRUE;
           while(*p_buf!='\0') {
             if(first) {
               printf("\"%s\"",p_buf);
               first=FALSE;
             } else printf(", \"%s\"",p_buf);
             p_buf+=(strlen(p_buf)+1);
           }
           printf("\n");
         }
         printf("  loaded morphing libraries:\n");
         for(uint32_t ii=0;ii<glob_xmount.morphing.libs_count;ii++) {
           printf("    - %s supporting ",
                  glob_xmount.morphing.pp_libs[ii]->p_name);
           p_buf=glob_xmount.morphing.pp_libs[ii]->p_supported_morphing_types;
           first=TRUE;
           while(*p_buf!='\0') {
             if(first) {
               printf("\"%s\"",p_buf);
               first=FALSE;
             } else printf(", \"%s\"",p_buf);
             p_buf+=(strlen(p_buf)+1);
           }
           printf("\n");
         }
         printf("  loaded output libraries:\n");
         for(uint32_t ii=0;ii<glob_xmount.output.libs_count;ii++) {
           printf("    - %s supporting ",
                  glob_xmount.output.pp_libs[ii]->p_name);
           p_buf=glob_xmount.output.pp_libs[ii]->p_supported_output_formats;
           first=TRUE;
           while(*p_buf!='\0') {
             if(first) {
               printf("\"%s\"",p_buf);
               first=FALSE;
             } else printf(", \"%s\"",p_buf);
             p_buf+=(strlen(p_buf)+1);
           }
           printf("\n");
         }
         printf("\n");
         exit(0);
       } else {
         LOG_ERROR("Unknown command line option \"%s\"\n",pp_argv[i]);
         return FALSE;
       }
     }
     i++;
   }
 
   // Extract mountpoint
   if(i==(argc-1)) {
     XMOUNT_STRSET(glob_xmount.p_mountpoint,pp_argv[argc-1])
     XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                    char**,
                    (glob_xmount.fuse_argc+1)*sizeof(char*));
     XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
                   glob_xmount.p_mountpoint);
     glob_xmount.fuse_argc++;
   } else {
     LOG_ERROR("No mountpoint specified!\n")
     return FALSE;
   }
 
   if(FuseMinusOControl==TRUE) {
     // We control the -o flag, set subtype, fsname and allow_other options
     glob_xmount.fuse_argc+=2;
     XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                    char**,
                    glob_xmount.fuse_argc*sizeof(char*));
     XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-2],"-o");
     XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                   "subtype=xmount");
     if(glob_xmount.input.images_count!=0) {
       // Set name of first source file as fsname
       XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                     ",fsname='");
       // If possible, use full path
       p_buf=realpath(glob_xmount.input.pp_images[0]->pp_files[0],NULL);
       if(p_buf==NULL) {
         XMOUNT_STRSET(p_buf,glob_xmount.input.pp_images[0]->pp_files[0]);
       }
       // Make sure fsname does not include some forbidden chars
       for(uint32_t i=0;i<strlen(p_buf);i++) {
         if(p_buf[i]=='\'') p_buf[i]='_';
       }
       // Set fsname
       XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                     p_buf);
       XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                     "'");
       free(p_buf);
     }
     if(FuseAllowOther==TRUE) {
       // Add "allow_other" option if allowed
       if(glob_xmount.may_set_fuse_allow_other) {
         XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                       ",allow_other");
       }
     }
   }
 
   return TRUE;
 }
 
 //! Extract output file name from input image name
 /*!
  * \param p_orig_name Name of input image (may include a path)
  * \return TRUE on success, FALSE on error
  */
 static int ExtractOutputFileNames(char *p_orig_name) {
   char *tmp;
 
   // Truncate any leading path
   tmp=strrchr(p_orig_name,'/');
   if(tmp!=NULL) p_orig_name=tmp+1;
 
   // Extract file extension
   tmp=strrchr(p_orig_name,'.');
 
   // Set leading '/'
   XMOUNT_STRSET(glob_xmount.output.p_virtual_image_path,"/");
   XMOUNT_STRSET(glob_xmount.output.p_info_path,"/");
 
   // Copy filename
   if(tmp==NULL) {
     // Input image filename has no extension
     XMOUNT_STRAPP(glob_xmount.output.p_virtual_image_path,p_orig_name);
     XMOUNT_STRAPP(glob_xmount.output.p_info_path,p_orig_name);
     XMOUNT_STRAPP(glob_xmount.output.p_info_path,".info");
   } else {
     XMOUNT_STRNAPP(glob_xmount.output.p_virtual_image_path,p_orig_name,
                    strlen(p_orig_name)-strlen(tmp));
     XMOUNT_STRNAPP(glob_xmount.output.p_info_path,p_orig_name,
                    strlen(p_orig_name)-strlen(tmp));
     XMOUNT_STRAPP(glob_xmount.output.p_info_path,".info");
   }
 
   // Add virtual file extensions
   // TODO: Get from output lib and add
   //XMOUNT_STRAPP(glob_xmount.output.p_virtual_image_path,".dd");
 
   LOG_DEBUG("Set virtual image name to \"%s\"\n",
             glob_xmount.output.p_virtual_image_path);
   LOG_DEBUG("Set virtual image info name to \"%s\"\n",
             glob_xmount.output.p_info_path);
   return TRUE;
 }
 
 //! Calculates an MD5 hash of the first HASH_AMOUNT bytes of the input image
 /*!
  * \param p_hash_low Pointer to the lower 64 bit of the hash
  * \param p_hash_high Pointer to the higher 64 bit of the hash
  * \return TRUE on success, FALSE on error
  */
 static int CalculateInputImageHash(uint64_t *p_hash_low,
                                    uint64_t *p_hash_high)
 {
   char hash[16];
   md5_state_t md5_state;
   char *p_buf;
   int ret;
   size_t read_data;
 
   XMOUNT_MALLOC(p_buf,char*,HASH_AMOUNT*sizeof(char));
   ret=ReadMorphedImageData(p_buf,0,HASH_AMOUNT,&read_data);
   if(ret!=TRUE || read_data==0) {
     LOG_ERROR("Couldn't read data from morphed image file!\n")
     free(p_buf);
     return FALSE;
   }
 
   // Calculate MD5 hash
   md5_init(&md5_state);
   md5_append(&md5_state,(const md5_byte_t*)p_buf,read_data);
   md5_finish(&md5_state,(md5_byte_t*)hash);
   // Convert MD5 hash into two 64bit integers
   *p_hash_low=*((uint64_t*)hash);
   *p_hash_high=*((uint64_t*)(hash+8));
   free(p_buf);
 
   return TRUE;
 }
 
 //! Create info file
 /*!
  * \return TRUE on success, FALSE on error
  */
 static int InitInfoFile() {
   int ret;
   char *p_buf;
 
   // Start with static input header
   XMOUNT_MALLOC(glob_xmount.output.p_info_file,
                 char*,
                 strlen(IMAGE_INFO_INPUT_HEADER)+1);
   strncpy(glob_xmount.output.p_info_file,
           IMAGE_INFO_INPUT_HEADER,
           strlen(IMAGE_INFO_INPUT_HEADER)+1);
 
   // Get and add infos from input lib(s)
   for(uint64_t i=0;i<glob_xmount.input.images_count;i++) {
     ret=glob_xmount.input.pp_images[i]->p_functions->
           GetInfofileContent(glob_xmount.input.pp_images[i]->p_handle,(const char**)&p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to get info file content for image '%s': %s!\n",
                 glob_xmount.input.pp_images[i]->pp_files[0],
                 glob_xmount.input.pp_images[i]->p_functions->
                   GetErrorMessage(ret));
       return FALSE;
     }
     // Add infos to main buffer and free p_buf
     XMOUNT_STRAPP(glob_xmount.output.p_info_file,"\n--> ");
     XMOUNT_STRAPP(glob_xmount.output.p_info_file,
                   glob_xmount.input.pp_images[i]->pp_files[0]);
     XMOUNT_STRAPP(glob_xmount.output.p_info_file," <--\n");
     if(p_buf!=NULL) {
       XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf);
       glob_xmount.input.pp_images[i]->p_functions->FreeBuffer(p_buf);
     } else {
       XMOUNT_STRAPP(glob_xmount.output.p_info_file,"None\n");
     }
   }
 
   // Add static morphing header
   XMOUNT_STRAPP(glob_xmount.output.p_info_file,IMAGE_INFO_MORPHING_HEADER);
 
   // Get and add infos from morphing lib
   ret=glob_xmount.morphing.p_functions->
         GetInfofileContent(glob_xmount.morphing.p_handle,(const char**)&p_buf);
   if(ret!=0) {
     LOG_ERROR("Unable to get info file content from morphing lib: %s!\n",
               glob_xmount.morphing.p_functions->GetErrorMessage(ret));
     return FALSE;
   }
   if(p_buf!=NULL) {
     XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf);
     glob_xmount.morphing.p_functions->FreeBuffer(p_buf);
   } else {
     XMOUNT_STRAPP(glob_xmount.output.p_info_file,"None\n");
   }
 
   return TRUE;
 }
 
 //! Load input / morphing libs
 /*!
  * \return TRUE on success, FALSE on error
  */
 static int LoadLibs() {
   DIR *p_dir=NULL;
   struct dirent *p_dirent=NULL;
   int base_library_path_len=0;
   char *p_library_path=NULL;
   void *p_libxmount=NULL;
   t_LibXmount_Input_GetApiVersion pfun_input_GetApiVersion;
   t_LibXmount_Input_GetSupportedFormats pfun_input_GetSupportedFormats;
   t_LibXmount_Input_GetFunctions pfun_input_GetFunctions;
   t_LibXmount_Morphing_GetApiVersion pfun_morphing_GetApiVersion;
   t_LibXmount_Morphing_GetSupportedTypes pfun_morphing_GetSupportedTypes;
   t_LibXmount_Morphing_GetFunctions pfun_morphing_GetFunctions;
   t_LibXmount_Output_GetApiVersion pfun_output_GetApiVersion;
   t_LibXmount_Output_GetSupportedFormats pfun_output_GetSupportedFormats;
   t_LibXmount_Output_GetFunctions pfun_output_GetFunctions;
   const char *p_supported_formats=NULL;
   const char *p_buf;
   uint32_t supported_formats_len=0;
   pts_InputLib p_input_lib=NULL;
   pts_MorphingLib p_morphing_lib=NULL;
   pts_OutputLib p_output_lib=NULL;
 
   LOG_DEBUG("Searching for xmount libraries in '%s'.\n",
             XMOUNT_LIBRARY_PATH);
 
   // Open lib dir
   p_dir=opendir(XMOUNT_LIBRARY_PATH);
   if(p_dir==NULL) {
     LOG_ERROR("Unable to access xmount library directory '%s'!\n",
               XMOUNT_LIBRARY_PATH);
     return FALSE;
   }
 
   // Construct base library path
   base_library_path_len=strlen(XMOUNT_LIBRARY_PATH);
   XMOUNT_STRSET(p_library_path,XMOUNT_LIBRARY_PATH);
   if(XMOUNT_LIBRARY_PATH[base_library_path_len]!='/') {
     base_library_path_len++;
     XMOUNT_STRAPP(p_library_path,"/");
   }
 
 #define LIBXMOUNT_LOAD(path) {                            \
   p_libxmount=dlopen(path,RTLD_NOW);                      \
   if(p_libxmount==NULL) {                                 \
     LOG_ERROR("Unable to load input library '%s': %s!\n", \
               path,                                       \
               dlerror());                                 \
     continue;                                             \
   }                                                       \
 }
 #define LIBXMOUNT_LOAD_SYMBOL(name,pfun) {                       \
   if((pfun=dlsym(p_libxmount,name))==NULL) {                     \
     LOG_ERROR("Unable to load symbol '%s' from library '%s'!\n", \
               name,                                              \
               p_library_path);                                   \
     dlclose(p_libxmount);                                        \
     p_libxmount=NULL;                                            \
     continue;                                                    \
   }                                                              \
 }
 
   // Loop over lib dir
   while((p_dirent=readdir(p_dir))!=NULL) {
     LOG_DEBUG("Trying to load '%s'\n",p_dirent->d_name);
 
     // Construct full path to found object
     p_library_path=realloc(p_library_path,
                            base_library_path_len+strlen(p_dirent->d_name)+1);
     if(p_library_path==NULL) {
       LOG_ERROR("Couldn't allocate memory!\n");
       exit(1);
     }
     strcpy(p_library_path+base_library_path_len,p_dirent->d_name);
 
     if(strncmp(p_dirent->d_name,"libxmount_input_",16)==0) {
       // Found possible input lib. Try to load it
       LIBXMOUNT_LOAD(p_library_path);
 
       // Load library symbols
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetApiVersion",
                             pfun_input_GetApiVersion);
 
       // Check library's API version
       if(pfun_input_GetApiVersion()!=LIBXMOUNT_INPUT_API_VERSION) {
         LOG_DEBUG("Failed! Wrong API version.\n");
         LOG_ERROR("Unable to load input library '%s'. Wrong API version\n",
                   p_library_path);
         dlclose(p_libxmount);
         continue;
       }
 
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetSupportedFormats",
                             pfun_input_GetSupportedFormats);
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetFunctions",
                             pfun_input_GetFunctions);
 
       // Construct new entry for our library list
       XMOUNT_MALLOC(p_input_lib,pts_InputLib,sizeof(ts_InputLib));
       // Initialize lib_functions structure to NULL
       memset(&(p_input_lib->lib_functions),
              0,
              sizeof(ts_LibXmountInputFunctions));
 
       // Set name and handle
       XMOUNT_STRSET(p_input_lib->p_name,p_dirent->d_name);
       p_input_lib->p_lib=p_libxmount;
 
       // Get and set supported formats
       p_supported_formats=pfun_input_GetSupportedFormats();
       supported_formats_len=0;
       p_buf=p_supported_formats;
       while(*p_buf!='\0') {
         supported_formats_len+=(strlen(p_buf)+1);
         p_buf+=(strlen(p_buf)+1);
       }
       supported_formats_len++;
       XMOUNT_MALLOC(p_input_lib->p_supported_input_types,
                     char*,
                     supported_formats_len);
       memcpy(p_input_lib->p_supported_input_types,
              p_supported_formats,
              supported_formats_len);
 
       // Get, set and check lib_functions
       pfun_input_GetFunctions(&(p_input_lib->lib_functions));
       if(p_input_lib->lib_functions.CreateHandle==NULL ||
          p_input_lib->lib_functions.DestroyHandle==NULL ||
          p_input_lib->lib_functions.Open==NULL ||
          p_input_lib->lib_functions.Close==NULL ||
          p_input_lib->lib_functions.Size==NULL ||
          p_input_lib->lib_functions.Read==NULL ||
          p_input_lib->lib_functions.OptionsHelp==NULL ||
          p_input_lib->lib_functions.OptionsParse==NULL ||
          p_input_lib->lib_functions.GetInfofileContent==NULL ||
          p_input_lib->lib_functions.GetErrorMessage==NULL ||
          p_input_lib->lib_functions.FreeBuffer==NULL)
       {
         LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
                   p_dirent->d_name);
         free(p_input_lib->p_supported_input_types);
         free(p_input_lib->p_name);
         free(p_input_lib);
         dlclose(p_libxmount);
         continue;
       }
 
       // Add entry to the input library list
       XMOUNT_REALLOC(glob_xmount.input.pp_libs,
                      pts_InputLib*,
                      sizeof(pts_InputLib)*(glob_xmount.input.libs_count+1));
       glob_xmount.input.pp_libs[glob_xmount.input.libs_count++]=p_input_lib;
 
       LOG_DEBUG("Input library '%s' loaded successfully\n",p_dirent->d_name);
     } if(strncmp(p_dirent->d_name,"libxmount_morphing_",19)==0) {
       // Found possible morphing lib. Try to load it
       LIBXMOUNT_LOAD(p_library_path);
 
       // Load library symbols
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetApiVersion",
                             pfun_morphing_GetApiVersion);
 
       // Check library's API version
       if(pfun_morphing_GetApiVersion()!=LIBXMOUNT_MORPHING_API_VERSION) {
         LOG_DEBUG("Failed! Wrong API version.\n");
         LOG_ERROR("Unable to load morphing library '%s'. Wrong API version\n",
                   p_library_path);
         dlclose(p_libxmount);
         continue;
       }
 
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetSupportedTypes",
                             pfun_morphing_GetSupportedTypes);
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetFunctions",
                             pfun_morphing_GetFunctions);
 
       // Construct new entry for our library list
       XMOUNT_MALLOC(p_morphing_lib,pts_MorphingLib,sizeof(ts_MorphingLib));
       // Initialize lib_functions structure to NULL
       memset(&(p_morphing_lib->lib_functions),
              0,
              sizeof(ts_LibXmountMorphingFunctions));
 
       // Set name and handle
       XMOUNT_STRSET(p_morphing_lib->p_name,p_dirent->d_name);
       p_morphing_lib->p_lib=p_libxmount;
 
       // Get and set supported types
       p_supported_formats=pfun_morphing_GetSupportedTypes();
       supported_formats_len=0;
       p_buf=p_supported_formats;
       while(*p_buf!='\0') {
         supported_formats_len+=(strlen(p_buf)+1);
         p_buf+=(strlen(p_buf)+1);
       }
       supported_formats_len++;
       XMOUNT_MALLOC(p_morphing_lib->p_supported_morphing_types,
                     char*,
                     supported_formats_len);
       memcpy(p_morphing_lib->p_supported_morphing_types,
              p_supported_formats,
              supported_formats_len);
 
       // Get, set and check lib_functions
       pfun_morphing_GetFunctions(&(p_morphing_lib->lib_functions));
       if(p_morphing_lib->lib_functions.CreateHandle==NULL ||
          p_morphing_lib->lib_functions.DestroyHandle==NULL ||
          p_morphing_lib->lib_functions.Morph==NULL ||
          p_morphing_lib->lib_functions.Size==NULL ||
          p_morphing_lib->lib_functions.Read==NULL ||
          p_morphing_lib->lib_functions.OptionsHelp==NULL ||
          p_morphing_lib->lib_functions.OptionsParse==NULL ||
          p_morphing_lib->lib_functions.GetInfofileContent==NULL ||
          p_morphing_lib->lib_functions.GetErrorMessage==NULL ||
          p_morphing_lib->lib_functions.FreeBuffer==NULL)
       {
         LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
                   p_dirent->d_name);
         free(p_morphing_lib->p_supported_morphing_types);
         free(p_morphing_lib->p_name);
         free(p_morphing_lib);
         dlclose(p_libxmount);
         continue;
       }
 
       // Add entry to the input library list
       XMOUNT_REALLOC(glob_xmount.morphing.pp_libs,
                      pts_MorphingLib*,
                      sizeof(pts_MorphingLib)*
                        (glob_xmount.morphing.libs_count+1));
       glob_xmount.morphing.pp_libs[glob_xmount.morphing.libs_count++]=
         p_morphing_lib;
 
       LOG_DEBUG("Morphing library '%s' loaded successfully\n",p_dirent->d_name);
     } if(strncmp(p_dirent->d_name,"libxmount_output_",17)==0) {
       // Found possible output lib. Try to load it
       LIBXMOUNT_LOAD(p_library_path);
 
       // Load library symbols
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetApiVersion",
                             pfun_output_GetApiVersion);
 
       // Check library's API version
       if(pfun_output_GetApiVersion()!=LIBXMOUNT_OUTPUT_API_VERSION) {
         LOG_DEBUG("Failed! Wrong API version.\n");
         LOG_ERROR("Unable to load output library '%s'. Wrong API version\n",
                   p_library_path);
         dlclose(p_libxmount);
         continue;
       }
 
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetSupportedFormats",
                             pfun_output_GetSupportedFormats);
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetFunctions",
                             pfun_output_GetFunctions);
 
       // Construct new entry for our library list
       XMOUNT_MALLOC(p_output_lib,pts_OutputLib,sizeof(ts_OutputLib));
       // Initialize lib_functions structure to NULL
       memset(&(p_output_lib->lib_functions),
              0,
              sizeof(ts_LibXmountOutput_Functions));
 
       // Set name and handle
       XMOUNT_STRSET(p_output_lib->p_name,p_dirent->d_name);
       p_output_lib->p_lib=p_libxmount;
 
       // Get and set supported types
       p_supported_formats=pfun_output_GetSupportedFormats();
       supported_formats_len=0;
       p_buf=p_supported_formats;
       while(*p_buf!='\0') {
         supported_formats_len+=(strlen(p_buf)+1);
         p_buf+=(strlen(p_buf)+1);
       }
       supported_formats_len++;
       XMOUNT_MALLOC(p_output_lib->p_supported_output_formats,
                     char*,
                     supported_formats_len);
       memcpy(p_output_lib->p_supported_output_formats,
              p_supported_formats,
              supported_formats_len);
 
       // Get, set and check lib_functions
       pfun_output_GetFunctions(&(p_output_lib->lib_functions));
       if(p_output_lib->lib_functions.CreateHandle==NULL ||
          p_output_lib->lib_functions.DestroyHandle==NULL ||
          p_output_lib->lib_functions.Transform==NULL ||
          p_output_lib->lib_functions.Size==NULL ||
          p_output_lib->lib_functions.Read==NULL ||
          p_output_lib->lib_functions.Write==NULL ||
          p_output_lib->lib_functions.OptionsHelp==NULL ||
          p_output_lib->lib_functions.OptionsParse==NULL ||
          p_output_lib->lib_functions.GetInfofileContent==NULL ||
          p_output_lib->lib_functions.GetErrorMessage==NULL ||
          p_output_lib->lib_functions.FreeBuffer==NULL)
       {
         LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
                   p_dirent->d_name);
         free(p_output_lib->p_supported_output_formats);
         free(p_output_lib->p_name);
         free(p_output_lib);
         dlclose(p_libxmount);
         continue;
       }
 
       // Add entry to the input library list
       XMOUNT_REALLOC(glob_xmount.output.pp_libs,
                      pts_OutputLib*,
                      sizeof(pts_OutputLib)*
                        (glob_xmount.output.libs_count+1));
       glob_xmount.output.pp_libs[glob_xmount.output.libs_count++]=
         p_output_lib;
 
       LOG_DEBUG("Output library '%s' loaded successfully\n",p_dirent->d_name);
     } else {
       LOG_DEBUG("Ignoring '%s'.\n",p_dirent->d_name);
       continue;
     }
   }
 
 #undef LIBXMOUNT_LOAD_SYMBOL
 #undef LIBXMOUNT_LOAD
 
   LOG_DEBUG("A total of %u input libs, %u morphing libs and %u output libs "
               "were loaded.\n",
             glob_xmount.input.libs_count,
             glob_xmount.morphing.libs_count,
             glob_xmount.output.libs_count);
 
   free(p_library_path);
   closedir(p_dir);
   return ((glob_xmount.input.libs_count>0 &&
            glob_xmount.morphing.libs_count>0 &&
            glob_xmount.output.libs_count>0) ? TRUE : FALSE);
 }
 
 //! Search an appropriate input lib for specified input type
 /*!
  * \param p_input_image Input image to search input lib for
  * \return TRUE on success, FALSE on error
  */
 static int FindInputLib(pts_InputImage p_input_image) {
   char *p_buf;
 
   LOG_DEBUG("Trying to find suitable library for input type '%s'.\n",
             p_input_image->p_type);
 
   // Loop over all loaded libs
   for(uint32_t i=0;i<glob_xmount.input.libs_count;i++) {
     LOG_DEBUG("Checking input library %s\n",
               glob_xmount.input.pp_libs[i]->p_name);
     p_buf=glob_xmount.input.pp_libs[i]->p_supported_input_types;
     while(*p_buf!='\0') {
       if(strcmp(p_buf,p_input_image->p_type)==0) {
         // Library supports input type, set lib functions
         LOG_DEBUG("Input library '%s' pretends to handle that input type.\n",
                   glob_xmount.input.pp_libs[i]->p_name);
         p_input_image->p_functions=
           &(glob_xmount.input.pp_libs[i]->lib_functions);
         return TRUE;
       }
       p_buf+=(strlen(p_buf)+1);
     }
   }
 
   LOG_DEBUG("Couldn't find any suitable library.\n");
 
   // No library supporting input type found
   return FALSE;
 }
 
 //! Search an appropriate morphing lib for the specified morph type
 /*!
  * \return TRUE on success, FALSE on error
  */
 static int FindMorphingLib() {
   char *p_buf;
 
   LOG_DEBUG("Trying to find suitable library for morph type '%s'.\n",
             glob_xmount.morphing.p_morph_type);
 
   // Loop over all loaded libs
   for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
     LOG_DEBUG("Checking morphing library %s\n",
               glob_xmount.morphing.pp_libs[i]->p_name);
     p_buf=glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types;
     while(*p_buf!='\0') {
       if(strcmp(p_buf,glob_xmount.morphing.p_morph_type)==0) {
         // Library supports morph type, set lib functions
         LOG_DEBUG("Morphing library '%s' pretends to handle that morph type.\n",
                   glob_xmount.morphing.pp_libs[i]->p_name);
         glob_xmount.morphing.p_functions=
           &(glob_xmount.morphing.pp_libs[i]->lib_functions);
         return TRUE;
       }
       p_buf+=(strlen(p_buf)+1);
     }
   }
 
   LOG_DEBUG("Couldn't find any suitable library.\n");
 
   // No library supporting morph type found
   return FALSE;
 }
 
 //! Search an appropriate output lib for the specified output format
 /*!
  * \return TRUE on success, FALSE on error
  */
 static int FindOutputLib() {
   char *p_buf;
 
   LOG_DEBUG("Trying to find suitable library for output format '%s'.\n",
             glob_xmount.output.p_output_format);
 
   // Loop over all loaded output libs
   for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
     LOG_DEBUG("Checking output library %s\n",
               glob_xmount.output.pp_libs[i]->p_name);
     p_buf=glob_xmount.output.pp_libs[i]->p_supported_output_formats;
     while(*p_buf!='\0') {
       if(strcmp(p_buf,glob_xmount.output.p_output_format)==0) {
         // Library supports output type, set lib functions
         LOG_DEBUG("Output library '%s' pretends to handle that output format.\n",
                   glob_xmount.output.pp_libs[i]->p_name);
         glob_xmount.output.p_functions=
           &(glob_xmount.output.pp_libs[i]->lib_functions);
         return TRUE;
       }
       p_buf+=(strlen(p_buf)+1);
     }
   }
 
   LOG_DEBUG("Couldn't find any suitable library.\n");
 
   // No library supporting output format found
   return FALSE;
 }
 
 static void InitResources() {
+  // Args
+  glob_xmount.args.overwrite_cache=FALSE;
+  glob_xmount.args.p_cache_file=NULL;
+
   // Input
   glob_xmount.input.libs_count=0;
   glob_xmount.input.pp_libs=NULL;
   glob_xmount.input.lib_params_count=0;
   glob_xmount.input.pp_lib_params=NULL;
   glob_xmount.input.images_count=0;
   glob_xmount.input.pp_images=NULL;
   glob_xmount.input.image_offset=0;
   glob_xmount.input.image_size_limit=0;
   glob_xmount.input.image_hash_lo=0;
   glob_xmount.input.image_hash_hi=0;
 
   // Morphing
   glob_xmount.morphing.libs_count=0;
   glob_xmount.morphing.pp_libs=NULL;
   glob_xmount.morphing.p_morph_type=NULL;
   glob_xmount.morphing.lib_params_count=0;
   glob_xmount.morphing.pp_lib_params=NULL;
   glob_xmount.morphing.p_handle=NULL;
   glob_xmount.morphing.p_functions=NULL;
   glob_xmount.morphing.input_image_functions.ImageCount=
     &LibXmount_Morphing_ImageCount;
   glob_xmount.morphing.input_image_functions.Size=&LibXmount_Morphing_Size;
   glob_xmount.morphing.input_image_functions.Read=&LibXmount_Morphing_Read;
 
   // Cache
-  glob_xmount.cache.overwrite_cache=FALSE;
-  glob_xmount.cache.p_cache_file=NULL;
-  glob_xmount.cache.h_cache_file=NULL;
-  glob_xmount.cache.h_block_cache=NULL;
-  glob_xmount.cache.h_block_cache_index=NULL;
-  glob_xmount.cache.p_block_cache_index=NULL;
-  glob_xmount.cache.block_cache_index_len=0;
+  glob_xmount.h_cache=NULL;
 
   // Output
   glob_xmount.output.libs_count=0;
   glob_xmount.output.pp_libs=NULL;
   glob_xmount.output.p_output_format=NULL;
   glob_xmount.output.lib_params_count=0;
   glob_xmount.output.pp_lib_params=NULL;
   glob_xmount.output.p_handle=NULL;
   glob_xmount.output.p_functions=NULL;
   glob_xmount.output.input_functions.Size=&LibXmount_Output_Size;
   glob_xmount.output.input_functions.Read=&LibXmount_Output_Read;
   glob_xmount.output.input_functions.Write=&LibXmount_Output_Write;
   glob_xmount.output.image_size=0;
   glob_xmount.output.writable=FALSE;
   glob_xmount.output.p_virtual_image_path=NULL;
   glob_xmount.output.p_info_path=NULL;
   glob_xmount.output.p_info_file=NULL;
 
   // Misc data
   glob_xmount.debug=FALSE;
   glob_xmount.may_set_fuse_allow_other=FALSE;
   glob_xmount.fuse_argc=0;
   glob_xmount.pp_fuse_argv=NULL;
   glob_xmount.p_mountpoint=NULL;
 }
 
 /*
  * FreeResources
  */
 static void FreeResources() {
   int ret;
-  teGidaFsError gidafs_ret=eGidaFsError_None;
+  te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
 
   LOG_DEBUG("Freeing all resources\n");
 
   // Misc
   if(glob_xmount.pp_fuse_argv!=NULL) {
     for(int i=0;i<glob_xmount.fuse_argc;i++) free(glob_xmount.pp_fuse_argv[i]);
     free(glob_xmount.pp_fuse_argv);
   }
   if(glob_xmount.p_mountpoint!=NULL) free(glob_xmount.p_mountpoint);
 
   // Output
   if(glob_xmount.output.p_functions!=NULL) {
     if(glob_xmount.output.p_handle!=NULL) {
       // Destroy output handle
       ret=glob_xmount.output.p_functions->
             DestroyHandle(&(glob_xmount.output.p_handle));
       if(ret!=0) {
         LOG_ERROR("Unable to destroy output handle: %s!\n",
                   glob_xmount.output.p_functions->GetErrorMessage(ret));
       }
     }
   }
   if(glob_xmount.output.pp_lib_params!=NULL) {
     for(uint32_t i=0;i<glob_xmount.output.lib_params_count;i++)
       free(glob_xmount.output.pp_lib_params[i]);
     free(glob_xmount.output.pp_lib_params);
   }
   if(glob_xmount.output.p_output_format!=NULL)
     free(glob_xmount.output.p_output_format);
   if(glob_xmount.output.pp_libs!=NULL) {
     // Unload output libs
     for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
       if(glob_xmount.output.pp_libs[i]==NULL) continue;
       if(glob_xmount.output.pp_libs[i]->p_supported_output_formats!=NULL)
         free(glob_xmount.output.pp_libs[i]->p_supported_output_formats);
       if(glob_xmount.output.pp_libs[i]->p_lib!=NULL)
         dlclose(glob_xmount.output.pp_libs[i]->p_lib);
       if(glob_xmount.output.pp_libs[i]->p_name!=NULL)
         free(glob_xmount.output.pp_libs[i]->p_name);
       free(glob_xmount.output.pp_libs[i]);
     }
     free(glob_xmount.output.pp_libs);
   }
   if(glob_xmount.output.p_info_path!=NULL)
     free(glob_xmount.output.p_info_path);
   if(glob_xmount.output.p_info_file!=NULL)
     free(glob_xmount.output.p_info_file);
   if(glob_xmount.output.p_virtual_image_path!=NULL)
     free(glob_xmount.output.p_virtual_image_path);
 
   // Cache
-  if(glob_xmount.cache.h_cache_file!=NULL) {
-    if(glob_xmount.cache.p_block_cache_index!=NULL)
-      free(glob_xmount.cache.p_block_cache_index);
-    if(glob_xmount.cache.h_block_cache_index!=NULL) {
-      gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file,
-                                     &(glob_xmount.cache.h_block_cache_index));
-      if(gidafs_ret!=eGidaFsError_None) {
-        LOG_ERROR("Unable to close block cache index file: Error code %u: "
-                    "Ignoring!\n",
-                  gidafs_ret)
-      }
-    }
-    if(glob_xmount.cache.h_block_cache!=NULL) {
-      gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file,
-                                     &(glob_xmount.cache.h_block_cache));
-      if(gidafs_ret!=eGidaFsError_None) {
-        LOG_ERROR("Unable to close block cache file: Error code %u: "
-                    "Ignoring!\n",
-                  gidafs_ret)
-      }
-    }
-    gidafs_ret=GidaFsLib_CloseFs(&(glob_xmount.cache.h_cache_file));
-    if(gidafs_ret!=eGidaFsError_None) {
+  if(glob_xmount.h_cache!=NULL) {
+    cache_ret=XmountCache_Close(&(glob_xmount.h_cache));
+    if(cache_ret!=e_XmountCache_Error_None) {
       LOG_ERROR("Unable to close cache file: Error code %u: Ignoring!\n",
-                gidafs_ret)
+                cache_ret);
     }
   }
-  if(glob_xmount.cache.p_cache_file!=NULL) free(glob_xmount.cache.p_cache_file);
 
   // Morphing
   if(glob_xmount.morphing.p_functions!=NULL) {
     if(glob_xmount.morphing.p_handle!=NULL) {
       // Destroy morphing handle
       ret=glob_xmount.morphing.p_functions->
             DestroyHandle(&(glob_xmount.morphing.p_handle));
       if(ret!=0) {
         LOG_ERROR("Unable to destroy morphing handle: %s!\n",
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret));
       }
     }
   }
   if(glob_xmount.morphing.pp_lib_params!=NULL) {
     for(uint32_t i=0;i<glob_xmount.morphing.lib_params_count;i++)
       free(glob_xmount.morphing.pp_lib_params[i]);
     free(glob_xmount.morphing.pp_lib_params);
   }
   if(glob_xmount.morphing.p_morph_type!=NULL)
     free(glob_xmount.morphing.p_morph_type);
   if(glob_xmount.morphing.pp_libs!=NULL) {
     // Unload morphing libs
     for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
       if(glob_xmount.morphing.pp_libs[i]==NULL) continue;
       if(glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types!=NULL)
         free(glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types);
       if(glob_xmount.morphing.pp_libs[i]->p_lib!=NULL)
         dlclose(glob_xmount.morphing.pp_libs[i]->p_lib);
       if(glob_xmount.morphing.pp_libs[i]->p_name!=NULL)
         free(glob_xmount.morphing.pp_libs[i]->p_name);
       free(glob_xmount.morphing.pp_libs[i]);
     }
     free(glob_xmount.morphing.pp_libs);
   }
 
   // Input
   if(glob_xmount.input.pp_images!=NULL) {
     // Close all input images
     for(uint64_t i=0;i<glob_xmount.input.images_count;i++) {
       if(glob_xmount.input.pp_images[i]==NULL) continue;
       if(glob_xmount.input.pp_images[i]->p_functions!=NULL) {
         if(glob_xmount.input.pp_images[i]->p_handle!=NULL) {
           ret=glob_xmount.input.pp_images[i]->p_functions->
                 Close(glob_xmount.input.pp_images[i]->p_handle);
           if(ret!=0) {
             LOG_ERROR("Unable to close input image: %s\n",
                       glob_xmount.input.pp_images[i]->p_functions->
                         GetErrorMessage(ret));
           }
           ret=glob_xmount.input.pp_images[i]->p_functions->
                 DestroyHandle(&(glob_xmount.input.pp_images[i]->p_handle));
           if(ret!=0) {
             LOG_ERROR("Unable to destroy input image handle: %s\n",
                       glob_xmount.input.pp_images[i]->p_functions->
                         GetErrorMessage(ret));
           }
         }
       }
       if(glob_xmount.input.pp_images[i]->pp_files!=NULL) {
         for(uint64_t ii=0;ii<glob_xmount.input.pp_images[i]->files_count;ii++) {
           if(glob_xmount.input.pp_images[i]->pp_files[ii]!=NULL)
             free(glob_xmount.input.pp_images[i]->pp_files[ii]);
         }
         free(glob_xmount.input.pp_images[i]->pp_files);
       }
       if(glob_xmount.input.pp_images[i]->p_type!=NULL)
         free(glob_xmount.input.pp_images[i]->p_type);
       free(glob_xmount.input.pp_images[i]);
     }
     free(glob_xmount.input.pp_images);
   }
   if(glob_xmount.input.pp_lib_params!=NULL) {
     for(uint32_t i=0;i<glob_xmount.input.lib_params_count;i++)
       free(glob_xmount.input.pp_lib_params[i]);
     free(glob_xmount.input.pp_lib_params);
   }
   if(glob_xmount.input.pp_libs!=NULL) {
     // Unload all input libs
     for(uint32_t i=0;i<glob_xmount.input.libs_count;i++) {
       if(glob_xmount.input.pp_libs[i]->p_supported_input_types!=NULL)
         free(glob_xmount.input.pp_libs[i]->p_supported_input_types);
       if(glob_xmount.input.pp_libs[i]->p_lib!=NULL)
         dlclose(glob_xmount.input.pp_libs[i]->p_lib);
       if(glob_xmount.input.pp_libs[i]->p_name!=NULL)
         free(glob_xmount.input.pp_libs[i]->p_name);
       free(glob_xmount.input.pp_libs[i]);
     }
     free(glob_xmount.input.pp_libs);
   }
 
+  // Args
+  if(glob_xmount.args.p_cache_file!=NULL) {
+    XMOUNT_FREE(glob_xmount.args.p_cache_file);
+  }
+
   // Before we return, initialize everything in case ReleaseResources would be
   // called again.
   InitResources();
 }
 
 //! Function to split given library options
 static int SplitLibraryParameters(char *p_params,
                                   uint32_t *p_ret_opts_count,
                                   pts_LibXmountOptions **ppp_ret_opt)
 {
   pts_LibXmountOptions p_opts=NULL;
   pts_LibXmountOptions *pp_opts=NULL;
   uint32_t params_len;
   uint32_t opts_count=0;
   uint32_t sep_pos=0;
   char *p_buf=p_params;
 
   if(p_params==NULL) return FALSE;
 
   // Get params length
   params_len=strlen(p_params);
 
   // Return if no params specified
   if(params_len==0) {
     *ppp_ret_opt=NULL;
     p_ret_opts_count=0;
     return TRUE;
   }
 
   // Split params
   while(*p_buf!='\0') {
     XMOUNT_MALLOC(p_opts,pts_LibXmountOptions,sizeof(ts_LibXmountOptions));
     p_opts->valid=0;
 
 #define FREE_PP_OPTS() {                                 \
   if(pp_opts!=NULL) {                                    \
     for(uint32_t i=0;i<opts_count;i++) free(pp_opts[i]); \
     free(pp_opts);                                       \
   }                                                      \
 }
 
     // Search next assignment operator
     sep_pos=0;
     while(p_buf[sep_pos]!='\0' &&  p_buf[sep_pos]!='=') sep_pos++;
     if(sep_pos==0 || p_buf[sep_pos]=='\0') {
       LOG_ERROR("Library parameter '%s' is missing an assignment operator!\n",
                 p_buf);
       free(p_opts);
       FREE_PP_OPTS();
       return FALSE;
     }
 
     // Save option key
     XMOUNT_STRNSET(p_opts->p_key,p_buf,sep_pos);
     p_buf+=(sep_pos+1);
 
     // Search next separator
     sep_pos=0;
     while(p_buf[sep_pos]!='\0' &&  p_buf[sep_pos]!=',') sep_pos++;
     if(sep_pos==0) {
       LOG_ERROR("Library parameter '%s' is not of format key=value!\n",
                 p_opts->p_key);
       free(p_opts->p_key);
       free(p_opts);
       FREE_PP_OPTS();
       return FALSE;
     }
 
     // Save option value
     XMOUNT_STRNSET(p_opts->p_value,p_buf,sep_pos);
     p_buf+=sep_pos;
 
     LOG_DEBUG("Extracted library option: '%s' = '%s'\n",
               p_opts->p_key,
               p_opts->p_value);
 
 #undef FREE_PP_OPTS
 
     // Add current option to return array
     XMOUNT_REALLOC(pp_opts,
                    pts_LibXmountOptions*,
                    sizeof(pts_LibXmountOptions)*(opts_count+1));
     pp_opts[opts_count++]=p_opts;
 
     // If we're not at the end of p_params, skip over separator for next run
     if(*p_buf!='\0') p_buf++;
   }
 
   LOG_DEBUG("Extracted a total of %" PRIu32 " library options\n",opts_count);
 
   *p_ret_opts_count=opts_count;
   *ppp_ret_opt=pp_opts;
   return TRUE;
 }
 
 /*******************************************************************************
  * LibXmount_Morphing function implementation
  ******************************************************************************/
 //! Function to get the amount of input images
 /*!
  * \param p_count Count of input images
  * \return 0 on success
  */
 static int LibXmount_Morphing_ImageCount(uint64_t *p_count) {
   *p_count=glob_xmount.input.images_count;
   return 0;
 }
 
 //! Function to get the size of the morphed data
 /*!
  * \param image Image number
  * \param p_size Pointer to store input image's size to
  * \return 0 on success
  */
 static int LibXmount_Morphing_Size(uint64_t image, uint64_t *p_size) {
   if(image>=glob_xmount.input.images_count) return -1;
   *p_size=glob_xmount.input.pp_images[image]->size;
   return 0;
 }
 
 //! Function to read data from input image
 /*!
  * \param image Image number
  * \param p_buf Buffer to store read data to
  * \param offset Position at which to start reading
  * \param count Amount of bytes to read
  * \param p_read Number of read bytes on success
  * \return 0 on success or negated error code on error
  */
 static int LibXmount_Morphing_Read(uint64_t image,
                                    char *p_buf,
                                    off_t offset,
                                    size_t count,
                                    size_t *p_read)
 {
   if(image>=glob_xmount.input.images_count) return -EIO;
   return ReadInputImageData(glob_xmount.input.pp_images[image],
                             p_buf,
                             offset,
                             count,
                             p_read);
 }
 
 /*******************************************************************************
  * LibXmount_Output function implementation
  ******************************************************************************/
 //! Function to get the size of the morphed image
 /*!
  * \param p_size Pointer to store morphed image's size to
  * \return 0 on success
  */
 static int LibXmount_Output_Size(uint64_t *p_size) {
   int ret=0;
 
   ret=GetMorphedImageSize(p_size);
 
   return ret==TRUE ? 0 : ret;
 }
 
 //! Function to read data from the morphed image
 /*!
  * \param p_buf Buffer to store read data to
  * \param offset Position at which to start reading
  * \param count Amount of bytes to read
  * \param p_read Number of read bytes on success
  * \return 0 on success or negated error code on error
  */
 static int LibXmount_Output_Read(char *p_buf,
                                  off_t offset,
                                  size_t count,
                                  size_t *p_read)
 {
   return ReadMorphedImageData(p_buf,offset,count,p_read);
 }
 
 //! Function to write data to the morphed image
 /*!
  * \param p_buf Buffer with data to write
  * \param offset Position at which to start writing
  * \param count Amount of bytes to write
  * \param p_written Number of written bytes on success
  * \return 0 on success or negated error code on error
  */
 static int LibXmount_Output_Write(char *p_buf,
                                   off_t offset,
                                   size_t count,
                                   size_t *p_written)
 {
   return WriteMorphedImageData(p_buf,offset,count,p_written);
 }
 
 /*******************************************************************************
  * Main
  ******************************************************************************/
 int main(int argc, char *argv[]) {
   struct stat file_stat;
   int ret;
   int fuse_ret;
   char *p_err_msg;
+  te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
 
   // Set implemented FUSE functions
   struct fuse_operations xmount_operations = {
     //.access=FuseAccess,
     .getattr=Xmount_FuseGetAttr,
     .mkdir=Xmount_FuseMkDir,
     .mknod=Xmount_FuseMkNod,
     .open=Xmount_FuseOpen,
     .readdir=Xmount_FuseReadDir,
     .read=Xmount_FuseRead,
     .rename=Xmount_FuseRename,
     .rmdir=Xmount_FuseRmDir,
     //.statfs=FuseStatFs,
     .unlink=Xmount_FuseUnlink,
     .write=Xmount_FuseWrite
   };
 
   // Disable std output / input buffering
   setbuf(stdout,NULL);
   setbuf(stderr,NULL);
 
   // Init glob_xmount
   InitResources();
 
-  // Load input and morphing libs
+  // Load input, morphing and output libs
   if(!LoadLibs()) {
     LOG_ERROR("Unable to load any libraries!\n")
     return 1;
   }
 
   // Check FUSE settings
   CheckFuseSettings();
 
   // Parse command line options
   if(ParseCmdLine(argc,argv)!=TRUE) {
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
 
   // Check command line options
   if(glob_xmount.input.images_count==0) {
     LOG_ERROR("No --in command line option specified!\n")
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
   if(glob_xmount.fuse_argc<2) {
     LOG_ERROR("Couldn't parse command line options!\n")
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
   if(glob_xmount.morphing.p_morph_type==NULL) {
     XMOUNT_STRSET(glob_xmount.morphing.p_morph_type,"combine");
   }
+  // TODO: Add default output image format here
 
   // Check if mountpoint is a valid dir
   if(stat(glob_xmount.p_mountpoint,&file_stat)!=0) {
     LOG_ERROR("Unable to stat mount point '%s'!\n",glob_xmount.p_mountpoint);
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
   if(!S_ISDIR(file_stat.st_mode)) {
     LOG_ERROR("Mount point '%s' is not a directory!\n",
               glob_xmount.p_mountpoint);
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
 
   if(glob_xmount.debug==TRUE) {
     LOG_DEBUG("Options passed to FUSE: ")
     for(int i=0;i<glob_xmount.fuse_argc;i++) {
       printf("%s ",glob_xmount.pp_fuse_argv[i]);
     }
     printf("\n");
   }
 
   // Init mutexes
   pthread_mutex_init(&(glob_xmount.mutex_image_rw),NULL);
   pthread_mutex_init(&(glob_xmount.mutex_info_read),NULL);
 
   // Load input images
   for(uint64_t i=0;i<glob_xmount.input.images_count;i++) {
     if(glob_xmount.debug==TRUE) {
       if(glob_xmount.input.pp_images[i]->files_count==1) {
         LOG_DEBUG("Loading image file \"%s\"...\n",
                   glob_xmount.input.pp_images[i]->pp_files[0])
       } else {
         LOG_DEBUG("Loading image files \"%s .. %s\"...\n",
                   glob_xmount.input.pp_images[i]->pp_files[0],
                   glob_xmount.input.pp_images[i]->
                     pp_files[glob_xmount.input.pp_images[i]->files_count-1])
       }
     }
 
     // Find input lib
     if(!FindInputLib(glob_xmount.input.pp_images[i])) {
       LOG_ERROR("Unknown input image type '%s' for input image '%s'!\n",
                 glob_xmount.input.pp_images[i]->p_type,
                 glob_xmount.input.pp_images[i]->pp_files[0])
       PrintUsage(argv[0]);
       FreeResources();
       return 1;
     }
 
     // Init input image handle
     ret=glob_xmount.input.pp_images[i]->p_functions->
           CreateHandle(&(glob_xmount.input.pp_images[i]->p_handle),
                        glob_xmount.input.pp_images[i]->p_type,
                        glob_xmount.debug);
     if(ret!=0) {
       LOG_ERROR("Unable to init input handle for input image '%s': %s!\n",
                 glob_xmount.input.pp_images[i]->pp_files[0],
                 glob_xmount.input.pp_images[i]->p_functions->
                   GetErrorMessage(ret));
       FreeResources();
       return 1;
     }
 
     // Parse input lib specific options
     if(glob_xmount.input.pp_lib_params!=NULL) {
       ret=glob_xmount.input.pp_images[i]->p_functions->
             OptionsParse(glob_xmount.input.pp_images[i]->p_handle,
                          glob_xmount.input.lib_params_count,
                          glob_xmount.input.pp_lib_params,
                          (const char**)&p_err_msg);
       if(ret!=0) {
         if(p_err_msg!=NULL) {
           LOG_ERROR("Unable to parse input library specific options for image "
                       "'%s': %s: %s!\n",
                     glob_xmount.input.pp_images[i]->pp_files[0],
                     glob_xmount.input.pp_images[i]->p_functions->
                       GetErrorMessage(ret),
                     p_err_msg);
           glob_xmount.input.pp_images[i]->p_functions->FreeBuffer(p_err_msg);
           FreeResources();
           return 1;
         } else {
           LOG_ERROR("Unable to parse input library specific options for image "
                       "'%s': %s!\n",
                     glob_xmount.input.pp_images[i]->pp_files[0],
                     glob_xmount.input.pp_images[i]->p_functions->
                       GetErrorMessage(ret));
           FreeResources();
           return 1;
         }
       }
     }
 
     // Open input image
     ret=
       glob_xmount.input.pp_images[i]->
         p_functions->
           Open(glob_xmount.input.pp_images[i]->p_handle,
                (const char**)(glob_xmount.input.pp_images[i]->pp_files),
                glob_xmount.input.pp_images[i]->files_count);
     if(ret!=0) {
       LOG_ERROR("Unable to open input image file '%s': %s!\n",
                 glob_xmount.input.pp_images[i]->pp_files[0],
                 glob_xmount.input.pp_images[i]->p_functions->
                   GetErrorMessage(ret));
       FreeResources();
       return 1;
     }
 
     // Determine input image size
     ret=glob_xmount.input.pp_images[i]->
       p_functions->
         Size(glob_xmount.input.pp_images[i]->p_handle,
              &(glob_xmount.input.pp_images[i]->size));
     if(ret!=0) {
       LOG_ERROR("Unable to determine size of input image '%s': %s!\n",
                 glob_xmount.input.pp_images[i]->pp_files[0],
                 glob_xmount.input.pp_images[i]->
                   p_functions->GetErrorMessage(ret));
       FreeResources();
       return 1;
     }
 
     // If an offset was specified, check it against offset and change size
     if(glob_xmount.input.image_offset!=0) {
       if(glob_xmount.input.image_offset>glob_xmount.input.pp_images[i]->size) {
         LOG_ERROR("The specified offset is larger than the size of the input "
                     "image '%s'! (%" PRIu64 " > %" PRIu64 ")\n",
                   glob_xmount.input.pp_images[i]->pp_files[0],
                   glob_xmount.input.image_offset,
                   glob_xmount.input.pp_images[i]->size);
         FreeResources();
         return 1;
       }
       glob_xmount.input.pp_images[i]->size-=glob_xmount.input.image_offset;
     }
 
     // If a size limit was specified, check it and change size
     if(glob_xmount.input.image_size_limit!=0) {
       if(glob_xmount.input.pp_images[i]->size<
            glob_xmount.input.image_size_limit)
       {
         LOG_ERROR("The specified size limit is larger than the size of the "
                     "input image '%s'! (%" PRIu64 " > %" PRIu64 ")\n",
                   glob_xmount.input.pp_images[i]->pp_files[0],
                   glob_xmount.input.image_size_limit,
                   glob_xmount.input.pp_images[i]->size);
         FreeResources();
         return 1;
       }
       glob_xmount.input.pp_images[i]->size=glob_xmount.input.image_size_limit;
     }
 
     LOG_DEBUG("Input image loaded successfully\n")
   }
 
   // Find morphing lib
   if(FindMorphingLib()!=TRUE) {
     LOG_ERROR("Unable to find a library supporting the morphing type '%s'!\n",
               glob_xmount.morphing.p_morph_type);
     FreeResources();
     return 1;
   }
 
   // Init morphing
   ret=glob_xmount.morphing.p_functions->
         CreateHandle(&glob_xmount.morphing.p_handle,
                      glob_xmount.morphing.p_morph_type,
                      glob_xmount.debug);
   if(ret!=0) {
     LOG_ERROR("Unable to create morphing handle: %s!\n",
               glob_xmount.morphing.p_functions->GetErrorMessage(ret));
     FreeResources();
     return 1;
   }
 
   // Parse morphing lib specific options
   if(glob_xmount.morphing.pp_lib_params!=NULL) {
     p_err_msg=NULL;
     ret=glob_xmount.morphing.p_functions->
           OptionsParse(glob_xmount.morphing.p_handle,
                        glob_xmount.morphing.lib_params_count,
                        glob_xmount.morphing.pp_lib_params,
                        (const char**)&p_err_msg);
     if(ret!=0) {
       if(p_err_msg!=NULL) {
         LOG_ERROR("Unable to parse morphing library specific options: %s: %s!\n",
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret),
                   p_err_msg);
         glob_xmount.morphing.p_functions->FreeBuffer(p_err_msg);
         FreeResources();
         return 1;
       } else {
         LOG_ERROR("Unable to parse morphing library specific options: %s!\n",
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret));
         FreeResources();
         return 1;
       }
     }
   }
 
   // Morph image
   ret=glob_xmount.morphing.p_functions->
         Morph(glob_xmount.morphing.p_handle,
               &(glob_xmount.morphing.input_image_functions));
   if(ret!=0) {
     LOG_ERROR("Unable to start morphing: %s!\n",
               glob_xmount.morphing.p_functions->GetErrorMessage(ret));
     FreeResources();
     return 1;
   }
 
   // Init random generator
   srand(time(NULL));
 
   // Calculate partial MD5 hash of input image file
   if(CalculateInputImageHash(&(glob_xmount.input.image_hash_lo),
                              &(glob_xmount.input.image_hash_hi))==FALSE)
   {
     LOG_ERROR("Couldn't calculate partial hash of morphed image!\n")
     return 1;
   }
 
   if(glob_xmount.debug==TRUE) {
     LOG_DEBUG("Partial MD5 hash of morphed image: ")
     for(int i=0;i<8;i++)
       printf("%02hhx",*(((char*)(&(glob_xmount.input.image_hash_lo)))+i));
     for(int i=0;i<8;i++)
       printf("%02hhx",*(((char*)(&(glob_xmount.input.image_hash_hi)))+i));
     printf("\n");
   }
 
   if(!ExtractOutputFileNames(glob_xmount.input.pp_images[0]->pp_files[0])) {
     LOG_ERROR("Couldn't extract virtual file names!\n");
     FreeResources();
     return 1;
   }
   LOG_DEBUG("Virtual file names extracted successfully\n")
 
   // Find output lib
   if(FindOutputLib()!=TRUE) {
     LOG_ERROR("Unable to find a library supporting the output format '%s'!\n",
               glob_xmount.output.p_output_format);
     FreeResources();
     return 1;
   }
 
   // Init output
   ret=glob_xmount.output.p_functions->
         CreateHandle(&glob_xmount.output.p_handle,
                      glob_xmount.output.p_output_format,
                      glob_xmount.debug);
   if(ret!=0) {
     LOG_ERROR("Unable to create output handle: %s!\n",
               glob_xmount.output.p_functions->GetErrorMessage(ret));
     FreeResources();
     return 1;
   }
 
   // Parse output lib specific options
   if(glob_xmount.output.pp_lib_params!=NULL) {
     p_err_msg=NULL;
     ret=glob_xmount.output.p_functions->
           OptionsParse(glob_xmount.output.p_handle,
                        glob_xmount.output.lib_params_count,
                        glob_xmount.output.pp_lib_params,
                        (const char**)&p_err_msg);
     if(ret!=0) {
       if(p_err_msg!=NULL) {
         LOG_ERROR("Unable to parse output library specific options: %s: %s!\n",
                   glob_xmount.output.p_functions->GetErrorMessage(ret),
                   p_err_msg);
         glob_xmount.output.p_functions->FreeBuffer(p_err_msg);
         FreeResources();
         return 1;
       } else {
         LOG_ERROR("Unable to parse output library specific options: %s!\n",
                   glob_xmount.output.p_functions->GetErrorMessage(ret));
         FreeResources();
         return 1;
       }
     }
   }
 
   // Morph image
   ret=glob_xmount.morphing.p_functions->
         Morph(glob_xmount.morphing.p_handle,
               &(glob_xmount.morphing.input_image_functions));
   if(ret!=0) {
     LOG_ERROR("Unable to start morphing: %s!\n",
               glob_xmount.morphing.p_functions->GetErrorMessage(ret));
     FreeResources();
     return 1;
   }
 
   // Gather infos for info file
   if(!InitInfoFile()) {
     LOG_ERROR("Couldn't gather infos for virtual image info file!\n")
     FreeResources();
     return 1;
   }
   LOG_DEBUG("Virtual image info file build successfully\n")
 
   if(glob_xmount.output.writable) {
     // Init cache file and cache file block index
+    // TODO: Add cache file creration / opening
+/*
+    if(glob_xmount.args.overwrite_cache==TRUE) {
+      cache_ret=XmountCache_Create(&(glob_xmount.h_cache),
+                                   glob_xmount.args.p_cache_file,
+
+
+    } else {
+      cache_ret=XmountCache_Open
+    }
+
+
+    te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
     if(!InitCacheFile()) {
       LOG_ERROR("Couldn't initialize cache file!\n")
       FreeResources();
       return 1;
     }
+*/
     LOG_DEBUG("Cache file initialized successfully\n")
   }
 
   // Call fuse_main to do the fuse magic
   fuse_ret=fuse_main(glob_xmount.fuse_argc,
                      glob_xmount.pp_fuse_argv,
                      &xmount_operations,
                      NULL);
 
   // Destroy mutexes
   pthread_mutex_destroy(&(glob_xmount.mutex_image_rw));
   pthread_mutex_destroy(&(glob_xmount.mutex_info_read));
 
   // Free allocated memory
   FreeResources();
   return fuse_ret;
 }
diff --git a/src/xmount.h b/src/xmount.h
index 58bfb58..36340ec 100755
--- a/src/xmount.h
+++ b/src/xmount.h
@@ -1,83 +1,93 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * xmount is a small tool to "fuse mount" various image formats and enable      *
 * virtual write access.                                                        *
 *                                                                              *
 * 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 3 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, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #ifndef XMOUNT_H
 #define XMOUNT_H
 
 #include "xmount_input.h"
 #include "xmount_morphing.h"
 #include "xmount_cache.h"
 #include "xmount_output.h"
 
 #undef FALSE
 #undef TRUE
 #define FALSE 0
 #define TRUE 1
 
 /*
  * Constants
  */
 #define IMAGE_INFO_INPUT_HEADER \
   "------> The following values are supplied by the used input library(ies) " \
     "<------\n"
 #define IMAGE_INFO_MORPHING_HEADER \
   "\n------> The following values are supplied by the used morphing library " \
     "<------\n\n"
 
 /*******************************************************************************
  * Xmount specific structures
  ******************************************************************************/
+//! Structure containing xmount arguments
+typedef struct s_XmountArgs {
+  //! Cache file
+  char *p_cache_file;
+  //! If set to 1, overwrite any existing cache file
+  uint8_t overwrite_cache;
+} ts_XmountArgs;
+
 //! Structure containing global xmount runtime infos
 typedef struct s_XmountData {
+  //! Parsed xmount arguments
+  ts_XmountArgs args;
   //! Input image related data
   ts_InputData input;
   //! Morphing related data
   ts_MorphingData morphing;
-  //! Cache file related data
-  ts_CacheData cache;
+  //! Cache file handle
+  pts_XmountCacheHandle h_cache;
   //! Output image related data
   ts_OutputData output;
   //! Enable debug output
   uint8_t debug;
   //! Set if we are allowed to set fuse's allow_other option
   uint8_t may_set_fuse_allow_other;
   //! Argv for FUSE
   int fuse_argc;
   //! Argv for FUSE
   char **pp_fuse_argv;
   //! Mount point
   char *p_mountpoint;
   //! Mutex to control concurrent read & write access on output image
   pthread_mutex_t mutex_image_rw;
   //! Mutex to control concurrent read access on info file
   pthread_mutex_t mutex_info_read;
 } ts_XmountData;
 
 /*******************************************************************************
  * Global vars
  ******************************************************************************/
 //! Struct that contains various runtime configuration options
 ts_XmountData glob_xmount;
 
 /*******************************************************************************
  * Xmount functions
  ******************************************************************************/
 
 #endif // XMOUNT_H
diff --git a/src/xmount_cache.c b/src/xmount_cache.c
index 576b3ef..9538c28 100644
--- a/src/xmount_cache.c
+++ b/src/xmount_cache.c
@@ -1,957 +1,798 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * 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 3 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, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "xmount_cache.h"
 #include "xmount.h"
 #include "macros.h"
 
 /*******************************************************************************
  * Private definitions / macros
  ******************************************************************************/
 #define LOG_WARNING(...) {            \
   LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
 }
 #define LOG_ERROR(...) {            \
   LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
 }
 #define LOG_DEBUG(...) {                              \
   LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
 }
 
 #ifndef __LP64__
   //! Value used to indicate an uncached block entry
   #define XMOUNT_CACHE_INVALID_INDEX 0xFFFFFFFFFFFFFFFFLL
 #else
   #define XMOUNT_CACHE_INVALID_INDEX 0xFFFFFFFFFFFFFFFF
 #endif
 
 //! Structures and vars needed for write access
 #define XMOUNT_CACHE_FOLDER "/.xmount"
 #define XMOUNT_CACHE_BLOCK_FILE XMOUNT_CACHE_FOLDER "/blocks.data"
 #define XMOUNT_CACHE_BLOCK_INDEX_FILE XMOUNT_CACHE_FOLDER "/blocks.index"
 
 /*******************************************************************************
  * Private types / structures / enums
  ******************************************************************************/
 typedef struct s_XmountCacheHandle {
   //! Cache file to save changes to
   char *p_cache_file;
   //! Handle to cache file
   hGidaFs h_cache_file;
   //! Handle to block cache
   hGidaFsFile h_block_cache;
   //! Handle to block cache index
   hGidaFsFile h_block_cache_index;
   //! In-memory copy of cache index
   uint64_t *p_block_cache_index;
   //! Length (in elements) of in-memory block cache index
   uint64_t block_cache_index_len;
   // TODO: Move to s_XmountData
   //! Overwrite existing cache
   uint8_t overwrite_cache;
 } ts_XmountCacheHandle, *pts_XmountCacheHandle;
 
 /*******************************************************************************
  * Private functions declarations
  ******************************************************************************/
 /*!
  * \brief Create a new xmount cache handle
  *
  * \param pp_h Pointer to an xmount cache handle
  * \param p_file Cache file path / name
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_CreateHandle(pts_XmountCacheHandle *pp_h,
                                               const char *p_file);
 
 /*!
  * \brief Destroy an xmount cache handle
  *
  * \param pp_h Pointer to an xmount cache handle
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_DestroyHandle(pts_XmountCacheHandle *pp_h);
 
 /*!
  * \brief Check if a file exists
  *
  * Checks if the given file p_file exists.
  *
  * \param p_file File to check for
  * \return e_XmountCache_Error_None if file exists
  */
 te_XmountCache_Error XmountCache_FileExists(const char *p_file);
 
+/*!
+ * \brief Updates a block cache entry
+ *
+ * Updates the given block cache index entry on disk. If the special value
+ * XMOUNT_CACHE_INVALID_INDEX is given as entry value, the whole block cache
+ * index is updated.
+ *
+ * \param p_h Cache handle
+ * \param entry Block cache entry number to update
+ * \return e_XmountCache_Error_None on success
+ */
+te_XmountCache_Error XmountCache_UpdateIndex(pts_XmountCacheHandle p_h,
+                                             uint64_t entry);
+
 /*******************************************************************************
  * Public functions implementations
  ******************************************************************************/
 /*
  * XmountCache_Create
  */
 te_XmountCache_Error XmountCache_Create(pts_XmountCacheHandle *pp_h,
                                         const char *p_file,
                                         uint64_t image_size,
                                         uint8_t overwrite)
 {
   pts_XmountCacheHandle p_h=NULL;
   teGidaFsError gidafs_ret=eGidaFsError_None;
   te_XmountCache_Error ret=e_XmountCache_Error_None;
 
-  // Check params
+  // Params check
   if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
   if(p_file==NULL) return e_XmountCache_Error_InvalidString;
   if(strlen(p_file)==0) return e_XmountCache_Error_InvalidFile;
 
   // Make sure file does not exist when overwrite was not specified
   if(overwrite==0 && XmountCache_FileExists(p_file)==e_XmountCache_Error_None) {
     // Given file exists and overwrite was not specified. This is fatal!
     return e_XmountCache_Error_ExistingFile;
   }
 
   // Create new handle
   ret=XmountCache_CreateHandle(&p_h,p_file);
   if(ret!=e_XmountCache_Error_None) return ret;
 
 #define XMOUNTCACHE_CREATE__DESTROY_HANDLE do {                             \
   ret=XmountCache_DestroyHandle(&p_h);                                      \
   if(ret!=e_XmountCache_Error_None) {                                       \
     LOG_ERROR("Unable to destroy cache handle: Error code %u: Ignoring!\n", \
               ret);                                                         \
   }                                                                         \
   *pp_h=NULL;                                                               \
 } while(0)
 
   // Create new cache file
   gidafs_ret=GidaFsLib_NewFs(&(p_h->h_cache_file),
                              p_h->p_cache_file,
                              0);
   if(gidafs_ret!=eGidaFsError_None) {
     LOG_ERROR("Unable to create new xmount cache file '%s': Error code %u!\n",
               p_h->p_cache_file,
               gidafs_ret);
     XMOUNTCACHE_CREATE__DESTROY_HANDLE;
     return FALSE;
   }
 
 #define XMOUNTCACHE_CREATE__CLOSE_CACHE do {             \
   gidafs_ret=GidaFsLib_CloseFs(&(p_h->h_cache_file));    \
   if(gidafs_ret!=eGidaFsError_None) {                    \
     LOG_ERROR("Unable to close xmount cache file '%s': " \
                 "Error code %u: Ignoring!\n",            \
               p_h->p_cache_file,                         \
               gidafs_ret);                               \
   }                                                      \
 } while(0)
 
   // TODO: Check if cache file uses same block size as we do
 
   // Create needed xmount subdirectory
   gidafs_ret=GidaFsLib_CreateDir(p_h->h_cache_file,
                                  XMOUNT_CACHE_FOLDER,
                                  eGidaFsNodeFlag_RWXu);
   if(gidafs_ret!=eGidaFsError_None) {
     LOG_ERROR("Unable to create cache file directory '%s': Error code %u!\n",
               XMOUNT_CACHE_FOLDER,
               gidafs_ret);
     XMOUNTCACHE_CREATE__CLOSE_CACHE;
     XMOUNTCACHE_CREATE__DESTROY_HANDLE;
     return e_XmountCache_Error_FailedCacheInit;
   }
 
   // Create block cache file
   gidafs_ret=GidaFsLib_OpenFile(p_h->h_cache_file,
                                 XMOUNT_CACHE_BLOCK_FILE,
                                 &(p_h->h_block_cache),
                                 eGidaFsOpenFileFlag_ReadWrite |
                                   eGidaFsOpenFileFlag_CreateAlways,
                                 eGidaFsNodeFlag_Rall | eGidaFsNodeFlag_Wusr);
   if(gidafs_ret!=eGidaFsError_None) {
     LOG_ERROR("Unable to create block cache file '%s': Error code %u!\n",
               XMOUNT_CACHE_BLOCK_FILE,
               gidafs_ret);
     XMOUNTCACHE_CREATE__CLOSE_CACHE;
     XMOUNTCACHE_CREATE__DESTROY_HANDLE;
+    // TODO: Own error code needed here
     return e_XmountCache_Error_FailedCacheInit;
   }
 
 #define XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE do {                \
   gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file,               \
                                  &(p_h->h_block_cache));          \
   if(gidafs_ret!=eGidaFsError_None) {                             \
     LOG_ERROR("Unable to close block cache file: Error code %u: " \
                 "Ignoring!\n",                                    \
               gidafs_ret);                                        \
   }                                                               \
 } while(0)
 
   // Create block cache index file
   gidafs_ret=GidaFsLib_OpenFile(p_h->h_cache_file,
                                 XMOUNT_CACHE_BLOCK_INDEX_FILE,
                                 &(p_h->h_block_cache_index),
                                 eGidaFsOpenFileFlag_ReadWrite |
                                   eGidaFsOpenFileFlag_CreateAlways,
                                 eGidaFsNodeFlag_Rall | eGidaFsNodeFlag_Wusr);
   if(gidafs_ret!=eGidaFsError_None) {
     LOG_ERROR("Unable to create block cache index file '%s': Error code %u!\n",
               XMOUNT_CACHE_BLOCK_FILE,
               gidafs_ret);
     XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE;
     XMOUNTCACHE_CREATE__CLOSE_CACHE;
     XMOUNTCACHE_CREATE__DESTROY_HANDLE;
+    // TODO: Own error code needed here
     return e_XmountCache_Error_FailedCacheInit;
   }
 
 #define XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE_INDEX do {                \
   gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file,                     \
                                  &(p_h->h_block_cache_index));          \
   if(gidafs_ret!=eGidaFsError_None) {                                   \
     LOG_ERROR("Unable to close block cache index file: Error code %u: " \
                 "Ignoring!\n",                                          \
               gidafs_ret);                                              \
   }                                                                     \
 } while(0)
 
   // Calculate how many cache blocks are needed and how big the cache block
   // index must be
   p_h->block_cache_index_len=image_size/XMOUNT_CACHE_BLOCK_SIZE;
   if((image_size%XMOUNT_CACHE_BLOCK_SIZE)!=0) p_h->block_cache_index_len++;
 
   LOG_DEBUG("Cache blocks: %" PRIu64 " entries using %" PRIu64 " bytes\n",
             p_h->block_cache_index_len,
             p_h->block_cache_index_len*sizeof(uint8_t));
 
   // Prepare in-memory buffer for block cache index
   p_h->p_block_cache_index=
     (uint64_t*)calloc(1,p_h->block_cache_index_len*sizeof(uint64_t));
   if(p_h->p_block_cache_index==NULL) {
     XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE_INDEX;
     XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE;
     XMOUNTCACHE_CREATE__CLOSE_CACHE;
     XMOUNTCACHE_CREATE__DESTROY_HANDLE;
     return e_XmountCache_Error_Alloc;
   }
 
   // Generate initial block cache index
   for(uint64_t i=0;i<p_h->block_cache_index_len;i++) {
     p_h->p_block_cache_index[i]=XMOUNT_CACHE_INVALID_INDEX;
   }
 
   // Write initial block cache index to cache file
-  if(UpdateBlockCacheIndex(XMOUNT_BLOCK_CACHE_INVALID_INDEX,0)!=TRUE) {
-    LOG_ERROR("Unable to generate initial block cache index file '%s': "
+  ret=XmountCache_UpdateIndex(p_h,XMOUNT_CACHE_INVALID_INDEX);
+  if(ret!=e_XmountCache_Error_None) {
+    LOG_ERROR("Unable to update initial block cache index file: "
                 "Error code %u!\n",
               XMOUNT_CACHE_BLOCK_FILE,
-              gidafs_ret);
+              ret);
     XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE_INDEX;
     XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE;
     XMOUNTCACHE_CREATE__CLOSE_CACHE;
     XMOUNTCACHE_CREATE__DESTROY_HANDLE;
-    return e_XmountCache_Error_FailedCacheInit;
+    return ret;
   }
 
 #undef XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE_INDEX
 #undef XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE
 #undef XMOUNTCACHE_CREATE__CLOSE_CACHE
 #undef XMOUNTCACHE_CREATE__DESTROY_HANDLE
 
   *pp_h=p_h;
   return e_XmountCache_Error_None;
 }
 
 /*
  * XmountCache_Open
  */
 te_XmountCache_Error XmountCache_Open(pts_XmountCacheHandle *pp_h,
                                       const char *p_file,
                                       uint64_t image_size)
 {
+  uint64_t blockindex_size=0;
+  uint64_t read=0;
   pts_XmountCacheHandle p_h=NULL;
   teGidaFsError gidafs_ret=eGidaFsError_None;
   te_XmountCache_Error ret=e_XmountCache_Error_None;
 
-  // Check params
+  // Params check
   if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
   if(p_file==NULL) return e_XmountCache_Error_InvalidString;
   if(strlen(p_file)==0) return e_XmountCache_Error_InvalidFile;
 
   // Make sure file exists
   if(XmountCache_FileExists(p_file)!=e_XmountCache_Error_None) {
     // Given file does not exist. This is fatal!
     return e_XmountCache_Error_InexistingFile;
   }
 
   // Create new handle
   ret=XmountCache_CreateHandle(&p_h,p_file);
   if(ret!=e_XmountCache_Error_None) return ret;
 
 #define XMOUNTCACHE_OPEN__DESTROY_HANDLE do {                               \
   ret=XmountCache_DestroyHandle(&p_h);                                      \
   if(ret!=e_XmountCache_Error_None) {                                       \
     LOG_ERROR("Unable to destroy cache handle: Error code %u: Ignoring!\n", \
               ret);                                                         \
   }                                                                         \
   *pp_h=NULL;                                                               \
 } while(0)
 
   // Open cache file
   gidafs_ret=GidaFsLib_OpenFs(&(p_h->h_cache_file),p_h->p_cache_file);
   if(gidafs_ret!=eGidaFsError_None) {
     // TODO: Check for old cache file type and inform user it isn't supported
     // anymore!
     LOG_ERROR("Couldn't open xmount cache file '%s': Error code %u!\n",
               p_h->p_cache_file,
               gidafs_ret)
     return e_XmountCache_Error_FailedOpeningCache;
   }
 
 #define XMOUNTCACHE_OPEN__CLOSE_CACHE do {               \
   gidafs_ret=GidaFsLib_CloseFs(&(p_h->h_cache_file));    \
   if(gidafs_ret!=eGidaFsError_None) {                    \
     LOG_ERROR("Unable to close xmount cache file '%s': " \
                 "Error code %u: Ignoring!\n",            \
               p_h->p_cache_file,                         \
               gidafs_ret);                               \
   }                                                      \
 } while(0)
 
+  // Open block cache file
+  gidafs_ret=GidaFsLib_OpenFile(p_h->h_cache_file,
+                                XMOUNT_CACHE_BLOCK_FILE,
+                                &(p_h->h_block_cache),
+                                eGidaFsOpenFileFlag_ReadWrite,
+                                0);
+  if(gidafs_ret!=eGidaFsError_None) {
+    LOG_ERROR("Unable to open block cache file '%s': Error code %u!\n",
+              XMOUNT_CACHE_BLOCK_FILE,
+              gidafs_ret);
+    XMOUNTCACHE_OPEN__CLOSE_CACHE;
+    XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+    // TODO: Own error code needed here
+    return e_XmountCache_Error_FailedOpeningCache;
+  }
+
 #define XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE do {                  \
   gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file,               \
                                  &(p_h->h_block_cache));          \
   if(gidafs_ret!=eGidaFsError_None) {                             \
     LOG_ERROR("Unable to close block cache file: Error code %u: " \
                 "Ignoring!\n",                                    \
               gidafs_ret);                                        \
   }                                                               \
 } while(0)
 
+  // Open block cache index file
+  gidafs_ret=GidaFsLib_OpenFile(p_h->h_cache_file,
+                                XMOUNT_CACHE_BLOCK_INDEX_FILE,
+                                &(p_h->h_block_cache_index),
+                                eGidaFsOpenFileFlag_ReadWrite,
+                                0);
+  if(gidafs_ret!=eGidaFsError_None) {
+    LOG_ERROR("Unable to open block cache index file '%s': Error code %u!\n",
+              XMOUNT_CACHE_BLOCK_FILE,
+              gidafs_ret);
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+    XMOUNTCACHE_OPEN__CLOSE_CACHE;
+    XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+    // TODO: Own error code needed here
+    return e_XmountCache_Error_FailedOpeningCache;
+  }
+
 #define XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX do {                  \
   gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file,                     \
                                  &(p_h->h_block_cache_index));          \
   if(gidafs_ret!=eGidaFsError_None) {                                   \
     LOG_ERROR("Unable to close block cache index file: Error code %u: " \
                 "Ignoring!\n",                                          \
               gidafs_ret);                                              \
   }                                                                     \
 } while(0)
 
+  // Calculate how many cache blocks are needed and how big the cache block
+  // index must be
+  p_h->block_cache_index_len=image_size/XMOUNT_CACHE_BLOCK_SIZE;
+  if((image_size%XMOUNT_CACHE_BLOCK_SIZE)!=0) p_h->block_cache_index_len++;
 
+  LOG_DEBUG("Cache blocks: %" PRIu64 " entries using %" PRIu64 " bytes\n",
+            p_h->block_cache_index_len,
+            p_h->block_cache_index_len*sizeof(uint8_t));
 
-
-
-
-
-
-
-/*
-
-
-#define INITCACHEFILE__CLOSE_CACHE do {                                 \
-  gidafs_ret=GidaFsLib_CloseFs(&(glob_xmount.cache.h_cache_file));      \
-  if(gidafs_ret!=eGidaFsError_None) {                                   \
-    LOG_ERROR("Unable to close cache file: Error code %u: Ignoring!\n", \
-              gidafs_ret)                                               \
-  }                                                                     \
-} while(0)
-
-#define INITCACHEFILE__CLOSE_BLOCK_CACHE do {                                 \
-  gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file,              \
-                                 &(glob_xmount.cache.h_block_cache));         \
-  if(gidafs_ret!=eGidaFsError_None) {                                         \
-    LOG_ERROR("Unable to close block cache file: Error code %u: Ignoring!\n", \
-              gidafs_ret)                                                     \
-  }                                                                           \
-} while(0)
-
-#define INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX do {                         \
-  gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file,            \
-                                 &(glob_xmount.cache.h_block_cache_index)); \
-  if(gidafs_ret!=eGidaFsError_None) {                                       \
-    LOG_ERROR("Unable to close block cache index file: Error code %u: "     \
-                "Ignoring!\n",                                              \
-              gidafs_ret)                                                   \
-  }                                                                         \
-} while(0)
-
-  // TODO: Check if cache file uses same block size as we do
-
-  if(is_new_cache_file==1) {
-    // New cache file, create needed xmount subdirectory
-    gidafs_ret=GidaFsLib_CreateDir(glob_xmount.cache.h_cache_file,
-                                   XMOUNT_CACHE_FOLDER,
-                                   eGidaFsNodeFlag_RWXu);
-    if(gidafs_ret!=eGidaFsError_None) {
-      LOG_ERROR("Unable to create cache file directory '%s': Error code %u!\n",
-                XMOUNT_CACHE_FOLDER,
-                gidafs_ret)
-      INITCACHEFILE__CLOSE_CACHE;
-      return FALSE;
-    }
-  }
-
-  // Open / Create block cache file
-  gidafs_ret=GidaFsLib_OpenFile(glob_xmount.cache.h_cache_file,
-                                XMOUNT_CACHE_BLOCK_FILE,
-                                &(glob_xmount.cache.h_block_cache),
-                                eGidaFsOpenFileFlag_ReadWrite |
-                                  (is_new_cache_file==1 ?
-                                    eGidaFsOpenFileFlag_CreateAlways : 0),
-                                eGidaFsNodeFlag_Rall |
-                                  eGidaFsNodeFlag_Wusr);
-  if(gidafs_ret!=eGidaFsError_None) {
-    LOG_ERROR("Unable to open / create block cache file '%s': Error code %u!\n",
-              XMOUNT_CACHE_BLOCK_FILE,
-              gidafs_ret)
-    INITCACHEFILE__CLOSE_CACHE;
-    return FALSE;
-  }
-
-  // Open / Create block cache index file
-  gidafs_ret=GidaFsLib_OpenFile(glob_xmount.cache.h_cache_file,
-                                XMOUNT_CACHE_BLOCK_INDEX_FILE,
-                                &(glob_xmount.cache.h_block_cache_index),
-                                eGidaFsOpenFileFlag_ReadWrite |
-                                  (is_new_cache_file==1 ?
-                                    eGidaFsOpenFileFlag_CreateAlways : 0),
-                                eGidaFsNodeFlag_Rall |
-                                  eGidaFsNodeFlag_Wusr);
+  // Make sure block cache index has correct size
+  gidafs_ret=GidaFsLib_GetFileSize(p_h->h_cache_file,
+                                   p_h->h_block_cache_index,
+                                   &blockindex_size);
   if(gidafs_ret!=eGidaFsError_None) {
-    LOG_ERROR("Unable to open / create block cache index file '%s': "
-                "Error code %u!\n",
-              XMOUNT_CACHE_BLOCK_FILE,
+    LOG_ERROR("Unable to get block cache index file size: Error code %u!\n",
               gidafs_ret)
-    INITCACHEFILE__CLOSE_BLOCK_CACHE;
-    INITCACHEFILE__CLOSE_CACHE;
-    return FALSE;
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX;
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+    XMOUNTCACHE_OPEN__CLOSE_CACHE;
+    XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+    return e_XmountCache_Error_FailedGettingIndexSize;
   }
-
-  // Calculate how many cache blocks are needed and how big the cache block
-  // index must be
-  glob_xmount.cache.block_cache_index_len=image_size/CACHE_BLOCK_SIZE;
-  if((image_size%CACHE_BLOCK_SIZE)!=0) {
-    glob_xmount.cache.block_cache_index_len++;
+  if(blockindex_size%sizeof(uint64_t)!=0 ||
+     (blockindex_size/sizeof(uint64_t))!=p_h->block_cache_index_len)
+  {
+    // TODO: Be more helpfull in error message
+    LOG_ERROR("Block cache index size is incorrect for given input image!\n")
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX;
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+    XMOUNTCACHE_OPEN__CLOSE_CACHE;
+    XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+    return e_XmountCache_Error_InvalidIndexSize;
   }
 
-  LOG_DEBUG("Cache blocks: %u (0x%04X) entries using %zd (0x%08zX) bytes\n",
-            glob_xmount.cache.block_cache_index_len,
-            glob_xmount.cache.block_cache_index_len,
-            glob_xmount.cache.block_cache_index_len*
-              sizeof(t_CacheFileBlockIndex),
-            glob_xmount.cache.block_cache_index_len*
-              sizeof(t_CacheFileBlockIndex))
-
   // Prepare in-memory buffer for block cache index
-  XMOUNT_MALLOC(glob_xmount.cache.p_block_cache_index,
-                t_CacheFileBlockIndex*,
-                glob_xmount.cache.block_cache_index_len*
-                  sizeof(t_CacheFileBlockIndex))
-
-  if(is_new_cache_file==1) {
-    // Generate initial block cache index
-    for(uint64_t i=0;i<glob_xmount.cache.block_cache_index_len;i++) {
-      glob_xmount.cache.p_block_cache_index[i]=CACHE_BLOCK_FREE;
-    }
-    // Write initial block cache index to cache file
-    if(UpdateBlockCacheIndex(XMOUNT_BLOCK_CACHE_INVALID_INDEX,0)!=TRUE) {
-      LOG_ERROR("Unable to generate initial block cache index file '%s': "
-                  "Error code %u!\n",
-                XMOUNT_CACHE_BLOCK_FILE,
-                gidafs_ret)
-      INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
-      INITCACHEFILE__CLOSE_BLOCK_CACHE;
-      INITCACHEFILE__CLOSE_CACHE;
-      XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
-      return FALSE;
-    }
-  } else {
-    // Existing cache file, make sure block cache index has correct size
-    gidafs_ret=GidaFsLib_GetFileSize(glob_xmount.cache.h_cache_file,
-                                     glob_xmount.cache.h_block_cache_index,
-                                     &blockindex_size);
-    if(gidafs_ret!=eGidaFsError_None) {
-      LOG_ERROR("Unable to get block cache index file size: Error code %u!\n",
-                gidafs_ret)
-      INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
-      INITCACHEFILE__CLOSE_BLOCK_CACHE;
-      INITCACHEFILE__CLOSE_CACHE;
-      XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
-      return FALSE;
-    }
-    if(blockindex_size%sizeof(t_CacheFileBlockIndex)!=0 ||
-       (blockindex_size/sizeof(t_CacheFileBlockIndex))!=
-         glob_xmount.cache.block_cache_index_len)
-    {
-      // TODO: Be more helpfull in error message
-      LOG_ERROR("Block cache index size is incorrect for given input image!\n")
-      INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
-      INITCACHEFILE__CLOSE_BLOCK_CACHE;
-      INITCACHEFILE__CLOSE_CACHE;
-      XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
-      return FALSE;
-    }
-    // Read block cache index into memory
-    gidafs_ret=GidaFsLib_ReadFile(glob_xmount.cache.h_cache_file,
-                                  glob_xmount.cache.h_block_cache_index,
-                                  0,
-                                  blockindex_size,
-                                  glob_xmount.cache.p_block_cache_index,
-                                  &read);
-    if(gidafs_ret!=eGidaFsError_None || read!=blockindex_size) {
-      LOG_ERROR("Unable to read block cache index: Error code %u!\n",
-                gidafs_ret);
-      INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
-      INITCACHEFILE__CLOSE_BLOCK_CACHE;
-      INITCACHEFILE__CLOSE_CACHE;
-      XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
-      return FALSE;
-    }
+  p_h->p_block_cache_index=
+    (uint64_t*)calloc(1,p_h->block_cache_index_len*sizeof(uint64_t));
+  if(p_h->p_block_cache_index==NULL) {
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX;
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+    XMOUNTCACHE_OPEN__CLOSE_CACHE;
+    XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+    return e_XmountCache_Error_Alloc;
   }
 
-#undef INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX
-#undef INITCACHEFILE__CLOSE_BLOCK_CACHE
-#undef INITCACHEFILE__CLOSE_CACHE
-*/
+  // Read block cache index into memory
+  gidafs_ret=GidaFsLib_ReadFile(p_h->h_cache_file,
+                                p_h->h_block_cache_index,
+                                0,
+                                blockindex_size,
+                                p_h->p_block_cache_index,
+                                &read);
+  if(gidafs_ret!=eGidaFsError_None || read!=blockindex_size) {
+    LOG_ERROR("Unable to read block cache index: Error code %u!\n",
+              gidafs_ret);
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX;
+    XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+    XMOUNTCACHE_OPEN__CLOSE_CACHE;
+    XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+    return e_XmountCache_Error_FailedReadingIndex;
+  }
 
 #undef XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX
 #undef XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE
 #undef XMOUNTCACHE_OPEN__CLOSE_CACHE
 #undef XMOUNTCACHE_OPEN__DESTROY_HANDLE
 
   *pp_h=p_h;
   return e_XmountCache_Error_None;
 }
 
 /*
  * XmountCache_Close
  */
 te_XmountCache_Error XmountCache_Close(pts_XmountCacheHandle *pp_h) {
   pts_XmountCacheHandle p_h=NULL;
+  teGidaFsError gidafs_ret=eGidaFsError_None;
+  te_XmountCache_Error final_ret=e_XmountCache_Error_None;
   te_XmountCache_Error ret=e_XmountCache_Error_None;
 
+  // Params check
+  if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
+  if(*pp_h==NULL) return e_XmountCache_Error_InvalidHandle;
+  p_h=*pp_h;
+
+  // Close block cache index
+  gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file,&(p_h->h_block_cache_index));
+  if(gidafs_ret!=eGidaFsError_None) {
+    LOG_ERROR("Unable to close block cache index file: Error code %u: "
+                "Ignoring!\n",
+              gidafs_ret);
+    if(final_ret==e_XmountCache_Error_None) {
+      final_ret=e_XmountCache_Error_FailedClosingIndex;
+    }
+  }
+
+  // Close block cache
+  gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file,&(p_h->h_block_cache));
+  if(gidafs_ret!=eGidaFsError_None) {
+    LOG_ERROR("Unable to close block cache file: Error code %u: "
+                "Ignoring!\n",
+              gidafs_ret);
+    if(final_ret==e_XmountCache_Error_None) {
+      final_ret=e_XmountCache_Error_FailedClosingBlockCache;
+    }
+  }
+
+  // Close cache file
+  gidafs_ret=GidaFsLib_CloseFs(&(p_h->h_cache_file));
+  if(gidafs_ret!=eGidaFsError_None) {
+    LOG_ERROR("Unable to close xmount cache file '%s': Error code %u: "
+                "Ignoring!\n",
+              p_h->p_cache_file,
+              gidafs_ret);
+    if(final_ret==e_XmountCache_Error_None) {
+      final_ret=e_XmountCache_Error_FailedClosingCache;
+    }
+  }
 
+  // Destroy handle
+  ret=XmountCache_DestroyHandle(&p_h);
+  if(ret!=e_XmountCache_Error_None) {
+    LOG_ERROR("Unable to destroy cache handle: Error code %u: Ignoring!\n",
+              ret);
+    if(final_ret==e_XmountCache_Error_None) {
+      final_ret=ret;
+    }
+  }
 
   *pp_h=NULL;
-  return e_XmountCache_Error_None;
+  return final_ret;
 }
 
 /*
  * XmountCache_BlockCacheRead
  */
 te_XmountCache_Error XmountCache_BlockCacheRead(pts_XmountCacheHandle p_h,
                                                 char *p_buf,
                                                 uint64_t block,
                                                 uint64_t block_offset,
                                                 uint64_t count)
 {
-  te_XmountCache_Error ret=e_XmountCache_Error_None;
+  uint64_t read=0;
+  teGidaFsError gidafs_ret=eGidaFsError_None;
+
+  // Params check
+  if(p_h==NULL) return e_XmountCache_Error_InvalidHandle;
+  if(p_buf==NULL) return e_XmountCache_Error_InvalidBuffer;
+  if(block>=p_h->block_cache_index_len) return e_XmountCache_Error_InvalidIndex;
+  if(block_offset>XMOUNT_CACHE_BLOCK_SIZE ||
+     block_offset+count>XMOUNT_CACHE_BLOCK_SIZE)
+  {
+    return e_XmountCache_Error_ReadBeyondBlockBounds;
+  }
+  if(p_h->p_block_cache_index[block]==XMOUNT_CACHE_INVALID_INDEX) {
+    return e_XmountCache_Error_UncachedBlock;
+  }
+
+  // Read requested data from block cache file
+  gidafs_ret=GidaFsLib_ReadFile(p_h->h_cache_file,
+                                p_h->h_block_cache,
+                                p_h->p_block_cache_index[block]+block_offset,
+                                count,
+                                p_buf,
+                                &read);
+  if(gidafs_ret!=eGidaFsError_None || read!=count) {
+    LOG_ERROR("Unable to read cached data from block %" PRIu64
+                ": Error code %u!\n",
+              block,
+              gidafs_ret);
+    return e_XmountCache_Error_FailedReadingBlockCache;
+  }
+
+  return e_XmountCache_Error_None;
 }
 
 /*
  * XmountCache_BlockCacheWrite
  */
 te_XmountCache_Error XmountCache_BlockCacheWrite(pts_XmountCacheHandle p_h,
                                                  char *p_buf,
                                                  uint64_t block,
                                                  uint64_t block_offset,
                                                  uint64_t count)
 {
-  te_XmountCache_Error ret=e_XmountCache_Error_None;
+  uint64_t written=0;
+  teGidaFsError gidafs_ret=eGidaFsError_None;
+
+  // Params check
+  if(p_h==NULL) return e_XmountCache_Error_InvalidHandle;
+  if(p_buf==NULL) return e_XmountCache_Error_InvalidBuffer;
+  if(block>=p_h->block_cache_index_len) return e_XmountCache_Error_InvalidIndex;
+  if(block_offset>XMOUNT_CACHE_BLOCK_SIZE ||
+     block_offset+count>XMOUNT_CACHE_BLOCK_SIZE)
+  {
+    return e_XmountCache_Error_ReadBeyondBlockBounds;
+  }
+  if(p_h->p_block_cache_index[block]==XMOUNT_CACHE_INVALID_INDEX) {
+    return e_XmountCache_Error_UncachedBlock;
+  }
+
+  gidafs_ret=GidaFsLib_WriteFile(p_h->h_cache_file,
+                                 p_h->h_block_cache,
+                                 p_h->p_block_cache_index[block]+block_offset,
+                                 count,
+                                 p_buf,
+                                 &written);
+  if(gidafs_ret!=eGidaFsError_None || written!=count) {
+    LOG_ERROR("Unable to write data to cached block %" PRIu64
+                ": Error code %u!\n",
+              block,
+              gidafs_ret);
+    return e_XmountCache_Error_FailedWritingBlockCache;
+  }
+
+  return e_XmountCache_Error_None;
 }
 
 /*
  * XmountCache_BlockCacheAppend
  */
 te_XmountCache_Error XmountCache_BlockCacheAppend(pts_XmountCacheHandle p_h,
                                                   char *p_buf,
                                                   uint64_t block)
 {
+  uint64_t written=0;
+  teGidaFsError gidafs_ret=eGidaFsError_None;
   te_XmountCache_Error ret=e_XmountCache_Error_None;
+
+  // Params check
+  if(p_h==NULL) return e_XmountCache_Error_InvalidHandle;
+  if(p_buf==NULL) return e_XmountCache_Error_InvalidBuffer;
+  if(block>=p_h->block_cache_index_len) return e_XmountCache_Error_InvalidIndex;
+
+  // Get current block cache size
+  gidafs_ret=GidaFsLib_GetFileSize(p_h->h_cache_file,
+                                   p_h->h_block_cache,
+                                   &(p_h->p_block_cache_index[block]));
+  if(gidafs_ret!=eGidaFsError_None) {
+    LOG_ERROR("Unable to get current block cache size: Error code %u!\n",
+              gidafs_ret);
+    return e_XmountCache_Error_FailedGettingIndexSize;
+  }
+
+  // Append new block
+  gidafs_ret=GidaFsLib_WriteFile(p_h->h_cache_file,
+                                 p_h->h_block_cache,
+                                 p_h->p_block_cache_index[block],
+                                 XMOUNT_CACHE_BLOCK_SIZE,
+                                 p_buf,
+                                 &written);
+  if(gidafs_ret!=eGidaFsError_None || written!=XMOUNT_CACHE_BLOCK_SIZE) {
+    LOG_ERROR("Unable to write data to cached block %" PRIu64
+                ": Error code %u!\n",
+              block,
+              gidafs_ret);
+    return e_XmountCache_Error_FailedWritingBlockCache;
+  }
+
+  // Update on-disk block cache index
+  ret=XmountCache_UpdateIndex(p_h,block);
+  if(ret!=e_XmountCache_Error_None) {
+    LOG_ERROR("Unable to update block cache index %" PRIu64
+                ": Error code %u!\n",
+              block,
+              ret);
+    return ret;
+  }
+
+  return e_XmountCache_Error_None;
 }
 
 /*
  * XmountCache_IsBlockCached
  */
 te_XmountCache_Error XmountCache_IsBlockCached(pts_XmountCacheHandle p_h,
                                                uint64_t block)
 {
-  te_XmountCache_Error ret=e_XmountCache_Error_None;
+  // Params check
+  if(p_h==NULL) return e_XmountCache_Error_InvalidHandle;
+  if(block>=p_h->block_cache_index_len) return e_XmountCache_Error_InvalidIndex;
+
+  // Check if given block has been cached previously
+  if(p_h->p_block_cache_index[block]==XMOUNT_CACHE_INVALID_INDEX) {
+    // Block is not in cache
+    return e_XmountCache_Error_UncachedBlock;
+  }
+
+  return e_XmountCache_Error_None;
 }
 
 /*******************************************************************************
  * Private functions implementations
  ******************************************************************************/
 /*
  * XmountCache_CreateHandle
  */
 te_XmountCache_Error XmountCache_CreateHandle(pts_XmountCacheHandle *pp_h,
                                               const char *p_file)
 {
   pts_XmountCacheHandle p_h=NULL;
 
-  // Check given handle pointer
-  if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
-
   // Alloc memory for handle
   p_h=(pts_XmountCacheHandle)calloc(1,sizeof(ts_XmountCacheHandle));
   if(p_h==NULL) {
     *pp_h=NULL;
     return e_XmountCache_Error_Alloc;
   }
 
   // Init values. The p_cache_file alloc and memcpy works corrently as strlen()
   // counts the amount of bytes, not chars. No UTF8-issue here.
   p_h->p_cache_file=(char*)calloc(1,strlen(p_file)+1);
   if(p_h->p_cache_file==NULL) {
     free(p_h);
     *pp_h=NULL;
     return e_XmountCache_Error_Alloc;
   }
   memcpy(p_h->p_cache_file,p_file,strlen(p_file));
   p_h->h_cache_file=NULL;
   p_h->h_block_cache=NULL;
   p_h->h_block_cache_index=NULL;
   p_h->p_block_cache_index=NULL;
 
   // Return new handle
   *pp_h=p_h;
   return e_XmountCache_Error_None;
 }
 
 /*
  * XmountCache_DestroyHandle
  */
 te_XmountCache_Error XmountCache_DestroyHandle(pts_XmountCacheHandle *pp_h) {
-  pts_XmountCacheHandle p_h=NULL;
-
-  // Check given handle pointer
-  if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
-  if(*pp_h==NULL) return e_XmountCache_Error_InvalidHandle;
-  p_h=*pp_h;
+  pts_XmountCacheHandle p_h=*pp_h;
 
   // Free handle
   if(p_h->p_cache_file!=NULL) free(p_h->p_cache_file);
   if(p_h->p_block_cache_index!=NULL) free(p_h->p_block_cache_index);
   free(p_h);
 
   // Return destroyed handle
   *pp_h=NULL;
   return e_XmountCache_Error_None;
 }
 
 /*
  * XmountCache_FileExists
  */
 te_XmountCache_Error XmountCache_FileExists(const char *p_file) {
   struct stat statbuf;
 
   if(lstat(p_file,&statbuf)==0) return e_XmountCache_Error_None;
   else return e_XmountCache_Error_InexistingFile;
 }
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//! Create / load cache file to enable virtual write support
-/*!
- * \return TRUE on success, FALSE on error
- */
-int InitCacheFile() {
-  uint64_t blockindex_size=0;
-  uint64_t image_size=0;
-  uint64_t read=0;
-  uint8_t is_new_cache_file=0;
-  teGidaFsError gidafs_ret=eGidaFsError_None;
-
-  // Get input image size for later use
-  if(!GetMorphedImageSize(&image_size)) {
-    LOG_ERROR("Couldn't get morphed image size!\n")
-    return FALSE;
-  }
-
-  if(!glob_xmount.cache.overwrite_cache) {
-    // Try to open an existing cache file or create a new one
-    gidafs_ret=GidaFsLib_OpenFs(&(glob_xmount.cache.h_cache_file),
-                                glob_xmount.cache.p_cache_file);
-    if(gidafs_ret!=eGidaFsError_None &&
-       gidafs_ret!=eGidaFsError_FailedOpeningFsFile)
-    {
-      // TODO: Check for old cache file type and inform user it isn't supported
-      // anymore!
-      LOG_ERROR("Couldn't open cache file '%s': Error code %u!\n",
-                glob_xmount.cache.p_cache_file,
-                gidafs_ret)
-      return FALSE;
-    } else if(gidafs_ret==eGidaFsError_FailedOpeningFsFile) {
-      // Unable to open cache file. It might simply not exist.
-      LOG_DEBUG("Cache file '%s' does not exist. Creating new one\n",
-                glob_xmount.cache.p_cache_file)
-      gidafs_ret=GidaFsLib_NewFs(&(glob_xmount.cache.h_cache_file),
-                                 glob_xmount.cache.p_cache_file,
-                                 0);
-      if(gidafs_ret!=eGidaFsError_None) {
-        // There is really a problem opening/creating the file
-        LOG_ERROR("Couldn't open cache file '%s': Error code %u!\n",
-                  glob_xmount.cache.p_cache_file,
-                  gidafs_ret)
-        return FALSE;
-      }
-      is_new_cache_file=1;
-    }
-  } else {
-    // Overwrite existing cache file or create a new one
-    gidafs_ret=GidaFsLib_NewFs(&(glob_xmount.cache.h_cache_file),
-                               glob_xmount.cache.p_cache_file,
-                               0);
-    if(gidafs_ret!=eGidaFsError_None) {
-      // There is really a problem opening/creating the file
-      LOG_ERROR("Couldn't open cache file '%s': Error code %u!\n",
-                glob_xmount.cache.p_cache_file,
-                gidafs_ret)
-      return FALSE;
-    }
-    is_new_cache_file=1;
-  }
-
-#define INITCACHEFILE__CLOSE_CACHE do {                                 \
-  gidafs_ret=GidaFsLib_CloseFs(&(glob_xmount.cache.h_cache_file));      \
-  if(gidafs_ret!=eGidaFsError_None) {                                   \
-    LOG_ERROR("Unable to close cache file: Error code %u: Ignoring!\n", \
-              gidafs_ret)                                               \
-  }                                                                     \
-} while(0)
-
-#define INITCACHEFILE__CLOSE_BLOCK_CACHE do {                                 \
-  gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file,              \
-                                 &(glob_xmount.cache.h_block_cache));         \
-  if(gidafs_ret!=eGidaFsError_None) {                                         \
-    LOG_ERROR("Unable to close block cache file: Error code %u: Ignoring!\n", \
-              gidafs_ret)                                                     \
-  }                                                                           \
-} while(0)
-
-#define INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX do {                         \
-  gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file,            \
-                                 &(glob_xmount.cache.h_block_cache_index)); \
-  if(gidafs_ret!=eGidaFsError_None) {                                       \
-    LOG_ERROR("Unable to close block cache index file: Error code %u: "     \
-                "Ignoring!\n",                                              \
-              gidafs_ret)                                                   \
-  }                                                                         \
-} while(0)
-
-  // TODO: Check if cache file uses same block size as we do
-
-  if(is_new_cache_file==1) {
-    // New cache file, create needed xmount subdirectory
-    gidafs_ret=GidaFsLib_CreateDir(glob_xmount.cache.h_cache_file,
-                                   XMOUNT_CACHE_FOLDER,
-                                   eGidaFsNodeFlag_RWXu);
-    if(gidafs_ret!=eGidaFsError_None) {
-      LOG_ERROR("Unable to create cache file directory '%s': Error code %u!\n",
-                XMOUNT_CACHE_FOLDER,
-                gidafs_ret)
-      INITCACHEFILE__CLOSE_CACHE;
-      return FALSE;
-    }
-  }
-
-  // Open / Create block cache file
-  gidafs_ret=GidaFsLib_OpenFile(glob_xmount.cache.h_cache_file,
-                                XMOUNT_CACHE_BLOCK_FILE,
-                                &(glob_xmount.cache.h_block_cache),
-                                eGidaFsOpenFileFlag_ReadWrite |
-                                  (is_new_cache_file==1 ?
-                                    eGidaFsOpenFileFlag_CreateAlways : 0),
-                                eGidaFsNodeFlag_Rall |
-                                  eGidaFsNodeFlag_Wusr);
-  if(gidafs_ret!=eGidaFsError_None) {
-    LOG_ERROR("Unable to open / create block cache file '%s': Error code %u!\n",
-              XMOUNT_CACHE_BLOCK_FILE,
-              gidafs_ret)
-    INITCACHEFILE__CLOSE_CACHE;
-    return FALSE;
-  }
-
-  // Open / Create block cache index file
-  gidafs_ret=GidaFsLib_OpenFile(glob_xmount.cache.h_cache_file,
-                                XMOUNT_CACHE_BLOCK_INDEX_FILE,
-                                &(glob_xmount.cache.h_block_cache_index),
-                                eGidaFsOpenFileFlag_ReadWrite |
-                                  (is_new_cache_file==1 ?
-                                    eGidaFsOpenFileFlag_CreateAlways : 0),
-                                eGidaFsNodeFlag_Rall |
-                                  eGidaFsNodeFlag_Wusr);
-  if(gidafs_ret!=eGidaFsError_None) {
-    LOG_ERROR("Unable to open / create block cache index file '%s': "
-                "Error code %u!\n",
-              XMOUNT_CACHE_BLOCK_FILE,
-              gidafs_ret)
-    INITCACHEFILE__CLOSE_BLOCK_CACHE;
-    INITCACHEFILE__CLOSE_CACHE;
-    return FALSE;
-  }
-
-  // Calculate how many cache blocks are needed and how big the cache block
-  // index must be
-  glob_xmount.cache.block_cache_index_len=image_size/CACHE_BLOCK_SIZE;
-  if((image_size%CACHE_BLOCK_SIZE)!=0) {
-    glob_xmount.cache.block_cache_index_len++;
-  }
-
-  LOG_DEBUG("Cache blocks: %u (0x%04X) entries using %zd (0x%08zX) bytes\n",
-            glob_xmount.cache.block_cache_index_len,
-            glob_xmount.cache.block_cache_index_len,
-            glob_xmount.cache.block_cache_index_len*
-              sizeof(t_CacheFileBlockIndex),
-            glob_xmount.cache.block_cache_index_len*
-              sizeof(t_CacheFileBlockIndex))
-
-  // Prepare in-memory buffer for block cache index
-  XMOUNT_MALLOC(glob_xmount.cache.p_block_cache_index,
-                t_CacheFileBlockIndex*,
-                glob_xmount.cache.block_cache_index_len*
-                  sizeof(t_CacheFileBlockIndex))
-
-  if(is_new_cache_file==1) {
-    // Generate initial block cache index
-    for(uint64_t i=0;i<glob_xmount.cache.block_cache_index_len;i++) {
-      glob_xmount.cache.p_block_cache_index[i]=CACHE_BLOCK_FREE;
-    }
-    // Write initial block cache index to cache file
-    if(UpdateBlockCacheIndex(XMOUNT_BLOCK_CACHE_INVALID_INDEX,0)!=TRUE) {
-      LOG_ERROR("Unable to generate initial block cache index file '%s': "
-                  "Error code %u!\n",
-                XMOUNT_CACHE_BLOCK_FILE,
-                gidafs_ret)
-      INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
-      INITCACHEFILE__CLOSE_BLOCK_CACHE;
-      INITCACHEFILE__CLOSE_CACHE;
-      XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
-      return FALSE;
-    }
-  } else {
-    // Existing cache file, make sure block cache index has correct size
-    gidafs_ret=GidaFsLib_GetFileSize(glob_xmount.cache.h_cache_file,
-                                     glob_xmount.cache.h_block_cache_index,
-                                     &blockindex_size);
-    if(gidafs_ret!=eGidaFsError_None) {
-      LOG_ERROR("Unable to get block cache index file size: Error code %u!\n",
-                gidafs_ret)
-      INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
-      INITCACHEFILE__CLOSE_BLOCK_CACHE;
-      INITCACHEFILE__CLOSE_CACHE;
-      XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
-      return FALSE;
-    }
-    if(blockindex_size%sizeof(t_CacheFileBlockIndex)!=0 ||
-       (blockindex_size/sizeof(t_CacheFileBlockIndex))!=
-         glob_xmount.cache.block_cache_index_len)
-    {
-      // TODO: Be more helpfull in error message
-      LOG_ERROR("Block cache index size is incorrect for given input image!\n")
-      INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
-      INITCACHEFILE__CLOSE_BLOCK_CACHE;
-      INITCACHEFILE__CLOSE_CACHE;
-      XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
-      return FALSE;
-    }
-    // Read block cache index into memory
-    gidafs_ret=GidaFsLib_ReadFile(glob_xmount.cache.h_cache_file,
-                                  glob_xmount.cache.h_block_cache_index,
-                                  0,
-                                  blockindex_size,
-                                  glob_xmount.cache.p_block_cache_index,
-                                  &read);
-    if(gidafs_ret!=eGidaFsError_None || read!=blockindex_size) {
-      LOG_ERROR("Unable to read block cache index: Error code %u!\n",
-                gidafs_ret);
-      INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
-      INITCACHEFILE__CLOSE_BLOCK_CACHE;
-      INITCACHEFILE__CLOSE_CACHE;
-      XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
-      return FALSE;
-    }
-  }
-
-#undef INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX
-#undef INITCACHEFILE__CLOSE_BLOCK_CACHE
-#undef INITCACHEFILE__CLOSE_CACHE
-
-  return TRUE;
-}
-
-//! Update block cache index
-/*!
- * \return TRUE on success, FALSE on error
+/*
+ * XmountCache_UpdateIndex
  */
-int UpdateBlockCacheIndex(uint64_t index, t_CacheFileBlockIndex value) {
+te_XmountCache_Error XmountCache_UpdateIndex(pts_XmountCacheHandle p_h,
+                                             uint64_t entry)
+{
   uint64_t update_size=0;
   uint64_t written=0;
+  uint64_t *p_buf;
   teGidaFsError gidafs_ret=eGidaFsError_None;
-  t_CacheFileBlockIndex *p_buf;
 
-  if(index!=XMOUNT_BLOCK_CACHE_INVALID_INDEX) {
-    // Update specific index element in cache file
-    p_buf=glob_xmount.cache.p_block_cache_index+index;
-    update_size=sizeof(t_CacheFileBlockIndex);
+  if(entry!=XMOUNT_CACHE_INVALID_INDEX) {
+    // Update specific index entry in cache file
+    p_buf=p_h->p_block_cache_index+entry;
+    update_size=sizeof(uint64_t);
   } else {
     // Dump whole block cache index to cache file
-    p_buf=glob_xmount.cache.p_block_cache_index;
-    update_size=glob_xmount.cache.block_cache_index_len*
-                  sizeof(t_CacheFileBlockIndex);
+    p_buf=p_h->p_block_cache_index;
+    update_size=p_h->block_cache_index_len*sizeof(uint64_t);
   }
 
   // Update cache file
-  gidafs_ret=GidaFsLib_WriteFile(glob_xmount.cache.h_cache_file,
-                                 glob_xmount.cache.h_block_cache_index,
+  gidafs_ret=GidaFsLib_WriteFile(p_h->h_cache_file,
+                                 p_h->h_block_cache_index,
                                  0,
                                  update_size,
                                  p_buf,
                                  &written);
   if(gidafs_ret!=eGidaFsError_None || written!=update_size) {
-    LOG_ERROR("Unable to update block cache index file '%s': "
-                "Error code %u!\n",
-              XMOUNT_CACHE_BLOCK_INDEX_FILE,
+    LOG_ERROR("Unable to update block cache index: Error code %u!\n",
               gidafs_ret)
-    return FALSE;
+    return e_XmountCache_Error_FailedUpdatingIndex;
   }
 
-  return TRUE;
+  return e_XmountCache_Error_None;
 }
diff --git a/src/xmount_cache.h b/src/xmount_cache.h
index cfc318a..5431e3f 100644
--- a/src/xmount_cache.h
+++ b/src/xmount_cache.h
@@ -1,176 +1,203 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * 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 3 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, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #ifndef XMOUNT_CACHE_H
 #define XMOUNT_CACHE_H
 
 #include <gidafs.h>
 
 /*******************************************************************************
  * Public definitions / macros
  ******************************************************************************/
 //! Default block cache block size to use (1 megabyte)
 #define XMOUNT_CACHE_BLOCK_SIZE (1024*1024)
 
 /*******************************************************************************
  * Public types / structures / enums
  ******************************************************************************/
 typedef struct s_XmountCacheHandle *pts_XmountCacheHandle;
 
 typedef enum e_XmountCache_Error {
   //! No error
   e_XmountCache_Error_None=0,
   //! Error to allocate memory
   e_XmountCache_Error_Alloc,
   //! Invalid cache handle
   e_XmountCache_Error_InvalidHandle,
   //! Invalid pointer to a cache handle
   e_XmountCache_Error_InvalidHandlePointer,
   //! A given string is invalid
   e_XmountCache_Error_InvalidString,
   //! A given file path / name is invalid
   e_XmountCache_Error_InvalidFile,
   //! A given file does not exist
   e_XmountCache_Error_InexistingFile,
   //! A given file exists
   e_XmountCache_Error_ExistingFile,
   //! Unable to create needed xmount structures inside cache file
   e_XmountCache_Error_FailedCacheInit,
   //! Unable to open xmount cache file
   e_XmountCache_Error_FailedOpeningCache,
+  //! Failed to get block cache index size
+  e_XmountCache_Error_FailedGettingIndexSize,
+  //! Invalid block cache index size
+  e_XmountCache_Error_InvalidIndexSize,
+  //! Unable to read block cache index
+  e_XmountCache_Error_FailedReadingIndex,
+  //! Failed closing cache block index
+  e_XmountCache_Error_FailedClosingIndex,
+  //! Failed closing cache block index
+  e_XmountCache_Error_FailedClosingBlockCache,
+  //! Failed closing cache block index
+  e_XmountCache_Error_FailedClosingCache,
+  //! Failed to update block cache index
+  e_XmountCache_Error_FailedUpdatingIndex,
+  //! Invalid block cache index specified
+  e_XmountCache_Error_InvalidIndex,
+  //! Block has not yet been cached
+  e_XmountCache_Error_UncachedBlock,
+  //! Invalid buffer specified
+  e_XmountCache_Error_InvalidBuffer,
+  //! Request would read beyond a single cache block
+  e_XmountCache_Error_ReadBeyondBlockBounds,
+  //! Failed reading cached data
+  e_XmountCache_Error_FailedReadingBlockCache,
+  //! Failed writing cached data
+  e_XmountCache_Error_FailedWritingBlockCache,
 } te_XmountCache_Error;
 
 /*******************************************************************************
  * Public functions declarations
  ******************************************************************************/
 /*!
  * \brief Create new xmount cache file
  *
  * Creates a new xmount cache file in the given file. If the given file already
  * exists, this function will fail except if overwrite is set to 1.
  *
  * \param pp_handle Pointer to an xmount cache handle
  * \param p_file File to use as cache file
  * \param image_size Size of image in bytes for which this cache will be used
  * \param overwrite If set to 1, overwrites existig cache file
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_Create(pts_XmountCacheHandle *pp_h,
                                         const char *p_file,
                                         uint64_t image_size,
                                         uint8_t overwrite);
 
 /*!
  * \brief Open an existing xmount cache file
  *
  * Opens the given xmount cache file.
  *
  * \param pp_handle Pointer to an xmount cache handle
  * \param p_file File to use as cache file
  * \param image_size Size of image in bytes for which this cache will be used
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_Open(pts_XmountCacheHandle *pp_h,
                                       const char *p_file,
                                       uint64_t image_size);
 
 /*!
  * \brief Closes a previously openend xmount cache file
  *
  * Closes the given xmount cache file and frees any used resources.
  *
  * \param pp_handle Pointer to an xmount cache handle
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_Close(pts_XmountCacheHandle *pp_h);
 
 /*!
  * \brief Read data from block cache
  *
  * Reads count bytes at offset block_offset from block number block and writes
  * the read data into the pre-allocated buffer p_buf. The given block has to
  * have been previously cached by a call to XmountCache_BlockCacheAppend().
  *
  * WARNING: This function does only work on single blocks. It is not possible to
  * read beyond a block end.
  *
  * \param p_handle Xmount cache handle
  * \param p_buf Buffer to store read data into
  * \param block Number of block to read data from
  * \param block_offset Offset inside block to start reading from
  * \param count Amount of bytes to read
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_BlockCacheRead(pts_XmountCacheHandle p_h,
                                                 char *p_buf,
                                                 uint64_t block,
                                                 uint64_t block_offset,
                                                 uint64_t count);
 
 /*!
  * \brief Write data to block cache
  *
  * Writes count bytes from buffer p_buf to block number block at offset
  * block_offset. The given block has to have been previously cached by a call to
  * XmountCache_BlockCacheAppend().
  *
  * WARNING: This function does only work on single blocks. It is not possible to
  * write beyond a block end.
  *
  * \param p_handle Xmount cache handle
  * \param p_buf Buffer with data to write
  * \param block Number of block to write data to
  * \param block_offset Offset inside block to start writing from
  * \param count Amount of bytes to write
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_BlockCacheWrite(pts_XmountCacheHandle p_h,
                                                  char *p_buf,
                                                  uint64_t block,
                                                  uint64_t block_offset,
                                                  uint64_t count);
 
 /*!
  * \brief Add a new block to the cache
  *
  * Adds the data inside p_buf to the cache file and saves it under the block
  * number block. Every block must contain exactly XMOUNT_CACHE_BLOCK_SIZE bytes.
  * Every block can only be cached once. Appending the same block twice will
  * fail.
  *
  * \param p_handle Xmount cache handle
  * \param p_buf Buffer with block data
  * \param block Number of block under which to save given data
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_BlockCacheAppend(pts_XmountCacheHandle p_h,
                                                   char *p_buf,
                                                   uint64_t block);
 
 /*!
  * \brief Chech if a block has previously been chached
  *
- * Checks if the given block has previously been cached.
+ * Checks if the given block has previously been cached. If it hasn't,
+ * e_XmountCache_Error_UncachedBlock is returned.
  *
  * \param p_handle Xmount cache handle
  * \param block Number of block to check
  * \return e_XmountCache_Error_None on success
  */
 te_XmountCache_Error XmountCache_IsBlockCached(pts_XmountCacheHandle p_h,
                                                uint64_t block);
 
 #endif // XMOUNT_CACHE_H
diff --git a/src/xmount_morphing.c b/src/xmount_morphing.c
index bcc5a44..ea3fb42 100644
--- a/src/xmount_morphing.c
+++ b/src/xmount_morphing.c
@@ -1,324 +1,316 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * 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 3 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, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #include <errno.h>
+#include <string.h> // For memcpy
 
 #include "xmount_morphing.h"
 #include "xmount.h"
 #include "macros.h"
 
 #define LOG_WARNING(...) {            \
   LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
 }
 #define LOG_ERROR(...) {            \
   LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
 }
 #define LOG_DEBUG(...) {                              \
   LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
 }
 
 //! Get size of morphed image
 /*!
  * \param p_size Buf to save size to
  * \return TRUE on success, FALSE on error
  */
 int GetMorphedImageSize(uint64_t *p_size) {
   int ret;
 
   ret=glob_xmount.morphing.p_functions->Size(glob_xmount.morphing.p_handle,
                                              p_size);
   if(ret!=0) {
     LOG_ERROR("Unable to get morphed image size: %s!\n",
               glob_xmount.morphing.p_functions->GetErrorMessage(ret));
     return FALSE;
   }
 
   return TRUE;
 }
 
 //! Read data from morphed image
 /*!
  * \param p_buf Pointer to buffer to write read data to (must be preallocated!)
  * \param offset Offset at which data should be read
  * \param size Size of data which should be read (size of buffer)
  * \param p_read Number of read bytes on success
  * \return TRUE on success, negated error code on error
  */
 int ReadMorphedImageData(char *p_buf,
                                 off_t offset,
                                 size_t size,
                                 size_t *p_read)
 {
   uint64_t block_off=0;
   uint64_t cur_block=0;
   uint64_t cur_to_read=0;
   uint64_t image_size=0;
   size_t read=0;
   size_t to_read=0;
   int ret;
-  teGidaFsError gidafs_ret=eGidaFsError_None;
+  uint8_t is_block_cached=FALSE;
+  te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
 
   // Make sure we aren't reading past EOF of image file
   if(GetMorphedImageSize(&image_size)!=TRUE) {
     LOG_ERROR("Couldn't get size of morphed image!\n");
     return -EIO;
   }
   if(offset>=image_size) {
     // Offset is beyond image size
     LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
     *p_read=0;
     return FALSE;
   }
   if(offset+size>image_size) {
     // Attempt to read data past EOF of morphed image file
     to_read=image_size-offset;
     LOG_DEBUG("Attempt to read data past EOF of morphed image. Corrected size "
                 "from %zu to %" PRIu64 ".\n",
               size,
               to_read);
   } else to_read=size;
 
   // Calculate block to start reading data from
-  cur_block=offset/CACHE_BLOCK_SIZE;
-  block_off=offset%CACHE_BLOCK_SIZE;
+  cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
+  block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
 
   // Read image data
   while(to_read!=0) {
     // Calculate how many bytes we have to read from this block
-    if(block_off+to_read>CACHE_BLOCK_SIZE) {
-      cur_to_read=CACHE_BLOCK_SIZE-block_off;
+    if(block_off+to_read>XMOUNT_CACHE_BLOCK_SIZE) {
+      cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-block_off;
     } else cur_to_read=to_read;
 
+    // Determine if we have to read cached data
+    is_block_cached=FALSE;
+    if(glob_xmount.output.writable==TRUE) {
+      cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
+      if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
+      else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
+        LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
+                    "Error code %u!\n",
+                  cur_block,
+                  cache_ret);
+        return -EIO;
+      }
+    }
+
     // Check if block is cached
-    if(glob_xmount.output.writable==TRUE &&
-       glob_xmount.cache.p_block_cache_index[cur_block]!=CACHE_BLOCK_FREE)
-    {
+    if(is_block_cached==TRUE) {
       // Write support enabled and need to read altered data from cachefile
-      LOG_DEBUG("Reading %zu bytes at offset %" PRIu64
-                  " from block cache file\n",
-                cur_to_read,
-                glob_xmount.cache.p_block_cache_index[cur_block]+block_off)
+      LOG_DEBUG("Reading %zu bytes from block cache file\n",cur_to_read);
 
-      gidafs_ret=GidaFsLib_ReadFile(glob_xmount.cache.h_cache_file,
-                                    glob_xmount.cache.h_block_cache,
-                                    glob_xmount.cache.
-                                      p_block_cache_index[cur_block]+block_off,
-                                    cur_to_read,
-                                    p_buf,
-                                    &read);
-      if(gidafs_ret!=eGidaFsError_None || read!=cur_to_read) {
-        LOG_ERROR("Unable to read cached data from block %" PRIu64
-                    ": Error code %u!\n",
+      cache_ret=XmountCache_BlockCacheRead(glob_xmount.h_cache,
+                                           p_buf,
+                                           cur_block,
+                                           block_off,
+                                           cur_to_read);
+      if(cache_ret!=e_XmountCache_Error_None) {
+        LOG_ERROR("Unable to read %" PRIu64
+                    " bytes of cached data from cache block %" PRIu64
+                    " at cache block offset %" PRIu64 ": Error code %u!\n",
+                  cur_to_read,
                   cur_block,
-                  gidafs_ret);
+                  block_off,
+                  cache_ret);
         return -EIO;
       }
     } else {
       // No write support or data not cached
       ret=glob_xmount.morphing.p_functions->Read(glob_xmount.morphing.p_handle,
                                                  p_buf,
-                                                 (cur_block*CACHE_BLOCK_SIZE)+
+                                                 (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
                                                    block_off,
                                                  cur_to_read,
                                                  &read);
       if(ret!=0 || read!=cur_to_read) {
         LOG_ERROR("Couldn't read %zu bytes at offset %zu from morphed image: "
                     "%s!\n",
                   cur_to_read,
                   offset,
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret));
         return -EIO;
       }
       LOG_DEBUG("Read %" PRIu64 " bytes at offset %" PRIu64
                   " from morphed image file\n",
                 cur_to_read,
-                (cur_block*CACHE_BLOCK_SIZE)+block_off);
+                (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+block_off);
     }
 
     cur_block++;
     block_off=0;
     p_buf+=cur_to_read;
     to_read-=cur_to_read;
   }
 
   *p_read=to_read;
   return TRUE;
 }
 
 //! Write data to morphed image
 /*!
  * \param p_buf Buffer with data to write
  * \param offset Offset to start writing at
  * \param count Amount of bytes to write
  * \param p_written Amount of successfully written bytes
  * \return TRUE on success, negated error code on error
  */
 int WriteMorphedImageData(const char *p_buf,
                                  off_t offset,
                                  size_t count,
                                  size_t *p_written)
 {
   uint64_t block_off=0;
   uint64_t cur_block=0;
   uint64_t cur_to_read=0;
   uint64_t cur_to_write=0;
   uint64_t image_size=0;
   uint64_t read=0;
   size_t written=0;
   size_t to_write=0;
   int ret;
-  teGidaFsError gidafs_ret=eGidaFsError_None;
   char *p_buf2=NULL;
+  uint8_t is_block_cached=FALSE;
+  te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
 
   // Make sure we aren't writing past EOF of image file
   if(GetMorphedImageSize(&image_size)!=TRUE) {
     LOG_ERROR("Couldn't get size of morphed image!\n");
     return -EIO;
   }
   if(offset>=image_size) {
     // Offset is beyond image size
     LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
     *p_written=0;
     return 0;
   }
   if(offset+count>image_size) {
     // Attempt to write data past EOF of morphed image file
     to_write=image_size-offset;
     LOG_DEBUG("Attempt to write data past EOF of morphed image. Corrected size "
                 "from %zu to %" PRIu64 ".\n",
               count,
               to_write);
   } else to_write=count;
 
   // Calculate block to start writing data to
-  cur_block=offset/CACHE_BLOCK_SIZE;
-  block_off=offset%CACHE_BLOCK_SIZE;
+  cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
+  block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
 
   while(to_write!=0) {
     // Calculate how many bytes we have to write to this block
-    if(block_off+to_write>CACHE_BLOCK_SIZE) {
-      cur_to_write=CACHE_BLOCK_SIZE-block_off;
+    if(block_off+to_write>XMOUNT_CACHE_BLOCK_SIZE) {
+      cur_to_write=XMOUNT_CACHE_BLOCK_SIZE-block_off;
     } else cur_to_write=to_write;
 
+    // Determine if block is already in cache
+    is_block_cached=FALSE;
+    cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
+    if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
+    else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
+      LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
+                  "Error code %u!\n",
+                cur_block,
+                cache_ret);
+      return -EIO;
+    }
+
     // Check if block is cached
-    if(glob_xmount.cache.p_block_cache_index[cur_block]!=CACHE_BLOCK_FREE) {
+    if(is_block_cached==TRUE) {
       // Block is cached
-      gidafs_ret=GidaFsLib_WriteFile(glob_xmount.cache.h_cache_file,
-                                     glob_xmount.cache.h_block_cache,
-                                     glob_xmount.cache.
-                                       p_block_cache_index[cur_block]+block_off,
-                                     cur_to_write,
-                                     p_buf,
-                                     &written);
-      if(gidafs_ret!=eGidaFsError_None || written!=cur_to_write) {
-        LOG_ERROR("Unable to write data to cached block %" PRIu64
-                    ": Error code %u!\n",
+      cache_ret=XmountCache_BlockCacheWrite(glob_xmount.h_cache,
+                                            p_buf,
+                                            cur_block,
+                                            block_off,
+                                            cur_to_write);
+      if(cache_ret!=e_XmountCache_Error_None) {
+        LOG_ERROR("Unable to write %" PRIu64
+                    " bytes of data to cache block %" PRIu64
+                    " at cache block offset %" PRIu64 ": Error code %u!\n",
+                  cur_to_write,
                   cur_block,
-                  gidafs_ret);
+                  block_off,
+                  cache_ret);
         return -EIO;
       }
 
-      LOG_DEBUG("Wrote %" PRIu64 " bytes at offset %" PRIu64
-                  " to block cache file\n",
-                cur_to_write,
-                glob_xmount.cache.p_block_cache_index[cur_block]+block_off);
+      LOG_DEBUG("Wrote %" PRIu64 " bytes to block cache\n",cur_to_write);
     } else {
       // Uncached block. Need to cache entire new block
       // Prepare new write buffer
-      XMOUNT_MALLOC(p_buf2,char*,CACHE_BLOCK_SIZE);
-      memset(p_buf2,0x00,CACHE_BLOCK_SIZE);
+      XMOUNT_MALLOC(p_buf2,char*,XMOUNT_CACHE_BLOCK_SIZE);
+      memset(p_buf2,0x00,XMOUNT_CACHE_BLOCK_SIZE);
 
       // Read full block from morphed image
-      cur_to_read=CACHE_BLOCK_SIZE;
-      if((cur_block*CACHE_BLOCK_SIZE)+CACHE_BLOCK_SIZE>image_size) {
-        cur_to_read=CACHE_BLOCK_SIZE-(((cur_block*CACHE_BLOCK_SIZE)+
-                                         CACHE_BLOCK_SIZE)-image_size);
+      cur_to_read=XMOUNT_CACHE_BLOCK_SIZE;
+      if((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+XMOUNT_CACHE_BLOCK_SIZE>image_size) {
+        cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-(((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
+                                         XMOUNT_CACHE_BLOCK_SIZE)-image_size);
       }
       ret=glob_xmount.morphing.p_functions->Read(glob_xmount.morphing.p_handle,
                                                  p_buf2,
-                                                 cur_block*CACHE_BLOCK_SIZE,
+                                                 cur_block*XMOUNT_CACHE_BLOCK_SIZE,
                                                  cur_to_read,
                                                  &read);
       if(ret!=0 || read!=cur_to_read) {
         LOG_ERROR("Couldn't read %" PRIu64 " bytes at offset %zu "
                     "from morphed image: %s!\n",
                   cur_to_read,
                   offset,
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret));
         XMOUNT_FREE(p_buf2);
         return -EIO;
       }
 
       // Set changed data
       memcpy(p_buf2+block_off,p_buf,cur_to_write);
 
-      // Write new block to block cache
-      // Get current block cache size
-      gidafs_ret=GidaFsLib_GetFileSize(glob_xmount.cache.h_cache_file,
-                                       glob_xmount.cache.h_block_cache,
-                                       &(glob_xmount.cache.
-                                         p_block_cache_index[cur_block]));
-      if(gidafs_ret!=eGidaFsError_None) {
-        LOG_ERROR("Unable to get current block cache size: Error code %u!\n",
-                  gidafs_ret);
-        XMOUNT_FREE(p_buf2);
-        return -EIO;
-      }
-      // Append new block
-      gidafs_ret=GidaFsLib_WriteFile(glob_xmount.cache.h_cache_file,
-                                     glob_xmount.cache.h_block_cache,
-                                     glob_xmount.cache.
-                                       p_block_cache_index[cur_block],
-                                     CACHE_BLOCK_SIZE,
-                                     p_buf2,
-                                     &written);
-      if(gidafs_ret!=eGidaFsError_None || written!=cur_to_write) {
-        LOG_ERROR("Unable to write data to cached block %" PRIu64
+      cache_ret=XmountCache_BlockCacheAppend(glob_xmount.h_cache,
+                                             p_buf,
+                                             cur_block);
+      if(cache_ret!=e_XmountCache_Error_None) {
+        LOG_ERROR("Unable to append new block cache block %" PRIu64
                     ": Error code %u!\n",
                   cur_block,
-                  gidafs_ret);
+                  cache_ret);
         XMOUNT_FREE(p_buf2);
         return -EIO;
       }
       XMOUNT_FREE(p_buf2);
-      // Update on-disk block cache index
-      ret=UpdateBlockCacheIndex(cur_block,
-                                glob_xmount.cache.p_block_cache_index[
-                                  cur_block]);
-      if(ret!=TRUE) {
-        LOG_ERROR("Unable to update block cache index %" PRIu64
-                    ": Error code %u!\n",
-                  cur_block,
-                  gidafs_ret);
-        return -EIO;
-      }
 
-      LOG_DEBUG("Updated cache file block index: Number=%" PRIu64
-                  ", Data offset=%" PRIu64 "\n",
-                cur_block,
-                glob_xmount.cache.p_block_cache_index[cur_block]);
+      LOG_DEBUG("Appended new block cache block %" PRIu64 "\n",cur_block);
     }
 
     block_off=0;
     cur_block++;
     p_buf+=cur_to_write;
     to_write-=cur_to_write;
   }
 
   *p_written=to_write;
   return TRUE;
 }