diff --git a/src/xmount.c b/src/xmount.c
index d5f4459..91a9bb2 100755
--- a/src/xmount.c
+++ b/src/xmount.c
@@ -1,2060 +1,1949 @@
 /*******************************************************************************
 * 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;
   if(XmountInput_GetSupportedFormats(glob_xmount.h_input,
                                      &p_buf)==e_XmountInput_Error_None)
   {
     while(*p_buf!='\0') {
       if(first==1) {
         printf("\"%s\"",p_buf);
         first=0;
       } else printf(", \"%s\"",p_buf);
       p_buf+=(strlen(p_buf)+1);
     }
     free(p_buf);
   }
   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 / Output 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
   if(XmountInput_GetOptionsHelpText(glob_xmount.h_input,
                                     &p_buf)==e_XmountInput_Error_None)
   {
     printf("%s",p_buf);
     free(p_buf);
   }
   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;
   uint64_t buf;
   char *p_buf;
   char **pp_buf;
   int ret;
   te_XmountInput_Error input_ret=e_XmountInput_Error_None;
 
   // 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.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.args.p_cache_file)
       } else if(strcmp(pp_argv[i],"--in")==0) {
         // Input image format and source files
         if((i+2)<argc) {
           i++;
           // Save format
           p_buf=pp_argv[i];
           // Parse input image filename(s) and save to temporary array
           i++;
           buf=0;
           pp_buf=NULL;
           while(i<(argc-1) && strncmp(pp_argv[i],"--",2)!=0) {
             buf++;
             XMOUNT_REALLOC(pp_buf,char**,buf*sizeof(char*));
             pp_buf[buf-1]=pp_argv[i];
             i++;
           }
           i--;
           if(buf==0) {
             LOG_ERROR("No input files specified for \"--in %s\"!\n",p_buf);
             return FALSE;
           }
           // Add input image
           if((input_ret=XmountInput_AddImage(glob_xmount.h_input,
                                              p_buf,
                                              buf,
                                              (const char**)pp_buf)
              )!=e_XmountInput_Error_None)
           {
             LOG_ERROR("Unable to load input image: Error code %u!\n",input_ret);
             XMOUNT_FREE(pp_buf);
             return FALSE;
           }
+          // Save first image path to generate fsname later on
+          if(glob_xmount.p_first_input_image_name==NULL) {
+            XMOUNT_STRSET(glob_xmount.p_first_input_image_name,
+                          pp_buf[0]);
+          }
         } else {
           LOG_ERROR("You must specify an input image format and source file!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--inopts")==0) {
         // Set input lib options
         if((i+1)<argc) {
           i++;
           input_ret=XmountInput_SetOptions(glob_xmount.h_input,pp_argv[i]);
           if(input_ret!=e_XmountInput_Error_None) {
             LOG_ERROR("Unable to parse input library options: Error code %u!\n",
                       input_ret);
             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++;
           buf=StrToUint64(pp_argv[i],&ret);
           if(ret==0) {
             LOG_ERROR("Unable to convert '%s' to a number!\n",pp_argv[i]);
             return FALSE;
           }
           input_ret=XmountInput_SetInputOffset(glob_xmount.h_input,buf);
           if(input_ret!=e_XmountInput_Error_None) {
             LOG_ERROR("Unable to set input offset: Error code %u!\n",input_ret);
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify an offset!\n")
           return FALSE;
         }
       } 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.args.p_cache_file,pp_argv[i])
           glob_xmount.output.writable=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.args.p_cache_file)
       } else if(strcmp(pp_argv[i],"--sizelimit")==0) {
         // Set input image size limit
         if((i+1)<argc) {
           i++;
           buf=StrToUint64(pp_argv[i],&ret);
           if(ret==0) {
             LOG_ERROR("Unable to convert '%s' to a number!\n",pp_argv[i]);
             return FALSE;
           }
           input_ret=XmountInput_SetInputSizeLimit(glob_xmount.h_input,buf);
           if(input_ret!=e_XmountInput_Error_None) {
             LOG_ERROR("Unable to set input size limit: Error code %u!\n",
                       input_ret);
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify a size limit!\n")
           return FALSE;
         }
       } 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");
+        input_ret=XmountInput_GetLibsInfoText(glob_xmount.h_input,&p_buf);
+        if(p_buf==NULL || input_ret!=e_XmountInput_Error_None) {
+          LOG_ERROR("Unable to get input library infos: Error code %u!\n",
+                    input_ret);
+          return FALSE;
         }
+        printf("%s",p_buf);
+        XMOUNT_FREE(p_buf);
         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) {
+    if(glob_xmount.p_first_input_image_name!=NULL) {
       // 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);
+      p_buf=realpath(glob_xmount.p_first_input_image_name,NULL);
       if(p_buf==NULL) {
-        XMOUNT_STRSET(p_buf,glob_xmount.input.pp_images[0]->pp_files[0]);
+        XMOUNT_STRSET(p_buf,glob_xmount.p_first_input_image_name);
       }
       // 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;
+  te_XmountInput_Error input_ret=e_XmountInput_Error_None;
   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");
-    }
+  input_ret=XmountInput_GetInfoFileContent(glob_xmount.h_cache,&p_buf);
+  if(p_buf==NULL || input_ret!=e_XmountInput_Error_None) {
+    LOG_ERROR("Unable to get info file content for input image(s): "
+                "Error code %u!\n",
+              input_ret);
+    return FALSE;
   }
+  XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf);
+  XMOUNT_FREE(p_buf);
 
   // 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;
+  uint32_t input_lib_count=0;
   pts_MorphingLib p_morphing_lib=NULL;
   pts_OutputLib p_output_lib=NULL;
+  te_XmountInput_Error input_ret=e_XmountInput_Error_None;
 
   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) {
+    if(strncmp(p_dirent->d_name,
+               XMOUNT_INPUT_LIBRARY_NAMING_SCHEME,
+               strlen(XMOUNT_INPUT_LIBRARY_NAMING_SCHEME))==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);
+      input_ret=XmountInput_AddLibrary(glob_xmount.h_input,p_dirent->d_name);
+      if(input_ret!=e_XmountInput_Error_None) {
+        LOG_ERROR("Unable to add input library '%s': Error code %u!\n",
+                  p_dirent->d_name,
+                  input_ret);
         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
 
+  // Get loaded library counts
+  input_ret=XmountInput_GetLibraryCount(glob_xmount.h_input,&input_lib_count);
+  if(input_ret!=e_XmountInput_Error_None) {
+    LOG_ERROR("Unable to get input library count: Error code %u!\n",input_ret);
+    return FALSE;
+  }
+
   LOG_DEBUG("A total of %u input libs, %u morphing libs and %u output libs "
               "were loaded.\n",
-            glob_xmount.input.libs_count,
+            input_lib_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 &&
+  return ((input_lib_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;
+  glob_xmount.h_input=NULL;
 
   // 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.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;
+  glob_xmount.p_first_input_image_name=NULL;
+  // TODO: Move where needed
+  //glob_xmount.image_hash_lo=0;
+  //glob_xmount.image_hash_hi=0;
 }
 
 /*
  * FreeResources
  */
 static void FreeResources() {
   int ret;
   te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
 
   LOG_DEBUG("Freeing all resources\n");
 
   // Misc
+  if(glob_xmount.p_first_input_image_name!=NULL) {
+    XMOUNT_FREE(glob_xmount.p_first_input_image_name);
+  }
   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.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",
                 cache_ret);
     }
   }
 
   // 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();
 }
 
 /*******************************************************************************
  * 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, 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 e430dfa..829f789 100755
--- a/src/xmount.h
+++ b/src/xmount.h
@@ -1,93 +1,95 @@
 /*******************************************************************************
 * 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
   pts_XmountInputHandle h_input;
   //! Morphing related data
   ts_MorphingData morphing;
   //! 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;
+  //! First input image's path/name
+  char *p_first_input_image_name;
   //! 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_input.c b/src/xmount_input.c
index 4b27dc7..8fdea95 100644
--- a/src/xmount_input.c
+++ b/src/xmount_input.c
@@ -1,445 +1,749 @@
 /*******************************************************************************
 * 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> // For calloc
 #include <string.h> // For memcpy
-#include <errno.h>
+//#include <errno.h>
+#include <dlfcn.h> // For dlopen, dlclose, dlsym
 
 #include "xmount_input.h"
 #include "xmount.h"
 #include "macros.h"
+#include "../libxmount_input/libxmount_input.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__); \
 }
 
 /*******************************************************************************
  * Private types / structures / enums
  ******************************************************************************/
 
 //! Structure containing infos about input libs
 typedef struct s_XmountInputLib {
   //! Filename of lib (without path)
   char *p_name;
   //! Handle to the loaded lib
   void *p_lib;
   //! Array of supported input types
   char *p_supported_input_types;
   //! Struct containing lib functions
   ts_LibXmountInputFunctions lib_functions;
 } ts_XmountInputLib, *pts_XmountInputLib;
 
 //! Structure containing infos about input images
 typedef struct s_XmountInputImage {
   //! Image type
   char *p_type;
   //! Image source file count
   uint64_t files_count;
   //! Image source files
   char **pp_files;
   //! Input lib functions for this image
   pts_LibXmountInputFunctions p_functions;
   //! Image handle
   void *p_handle;
   //! Image size
   uint64_t size;
 } ts_XmountInputImage, *pts_XmountInputImage;
 
 typedef struct s_XmountInputHandle {
   //! Loaded input lib count
   uint32_t libs_count;
   //! Array containing infos about loaded input libs
   pts_XmountInputLib *pp_libs;
   //! Amount of input lib params (--inopts)
   uint32_t lib_params_count;
   //! Input lib params (--inopts)
   pts_LibXmountOptions *pp_lib_params;
   //! Input image count
   uint64_t images_count;
   //! Input images
   pts_XmountInputImage *pp_images;
   //! Input image offset (--offset)
   uint64_t image_offset;
   //! Input image size limit (--sizelimit)
   uint64_t image_size_limit;
 
   // TODO: Move
   //! MD5 hash of partial input image (lower 64 bit) (after morph)
   //uint64_t image_hash_lo;
   //! MD5 hash of partial input image (higher 64 bit) (after morph)
   //uint64_t image_hash_hi;
 } ts_XmountInputHandle;
 
 /*******************************************************************************
  * Private functions declarations
  ******************************************************************************/
-
+/*!
+ * \brief Find an input lib for a given input image
+ *
+ * Searches trough the list of loaded input libraries to find one that supports
+ * the given input image's format. On success, that library is associated with
+ * the given image.
+ *
+ * \param p_h Input handle
+ * \param p_input_image Input image to search input lib for
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountInput_Error FindInputLib(pts_XmountInputHandle p_h,
+                                  pts_XmountInputImage p_input_image);
 
 /*******************************************************************************
  * Public functions implementations
  ******************************************************************************/
 /*
  * XmountInput_CreateHandle
  */
 te_XmountInput_Error XmountInput_CreateHandle(pts_XmountInputHandle *pp_h) {
   pts_XmountInputHandle p_h=NULL;
 
   // Params check
   if(pp_h==NULL) return e_XmountInput_Error_InvalidHandlePointer;
 
   // Alloc new handle
   p_h=(pts_XmountInputHandle)calloc(1,sizeof(ts_XmountInputHandle));
   if(p_h==NULL) {
     return e_XmountInput_Error_Alloc;
   }
 
   // Init values
   p_h->pp_libs=NULL;
   p_h->pp_lib_params=NULL;
   p_h->pp_images=NULL;
 
   *pp_h=p_h;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_DestroyHandle
  */
 te_XmountInput_Error XmountInput_DestroyHandle(pts_XmountInputHandle *pp_h) {
   pts_XmountInputHandle p_h=NULL;
 
   // Params check
   if(pp_h==NULL) return e_XmountInput_Error_InvalidHandlePointer;
   if(*pp_h==NULL) return e_XmountInput_Error_InvalidHandle;
   p_h=*pp_h;
 
   // Free resources
   if(p_h->libs_count>0 && p_h->pp_libs!=NULL) {
     // TODO
   }
   if(p_h->lib_params_count!=0 && p_h->pp_lib_params!=NULL) {
     // Free library parameter array
     for(uint32_t i=0;i<p_h->lib_params_count;i++) {
       free(p_h->pp_lib_params[i]);
     }
     free(p_h->pp_lib_params);
   }
   if(p_h->images_count!=0 && p_h->pp_images!=NULL) {
     // TODO
   }
 
   return e_XmountInput_Error_None;
 }
 
 /*
- * XmountInput_LoadLibs
+ * XmountInput_AddLibrary
  */
-te_XmountInput_Error XmountInput_LoadLibs(pts_XmountInputHandle p_h) {
-  // TODO: Implement
+te_XmountInput_Error XmountInput_AddLibrary(pts_XmountInputHandle p_h,
+                                            const char *p_lib_name)
+{
+  uint32_t supported_formats_len=0;
+  t_LibXmount_Input_GetApiVersion pfun_input_GetApiVersion;
+  t_LibXmount_Input_GetSupportedFormats pfun_input_GetSupportedFormats;
+  t_LibXmount_Input_GetFunctions pfun_input_GetFunctions;
+  void *p_libxmount=NULL;
+  pts_XmountInputLib p_input_lib=NULL;
+  char *p_buf=NULL;
+  char *p_library_path=NULL;
+  char *p_supported_formats=NULL;
+
+  // Params check
+  if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
+  if(p_lib_name==NULL) return e_XmountInput_Error_InvalidString;
+
+  // Construct full library path
+  XMOUNT_STRSET(p_library_path,XMOUNT_LIBRARY_PATH);
+  if(p_library_path[strlen(p_library_path)]!='/') {
+    XMOUNT_STRAPP(p_library_path,"/");
+  }
+  XMOUNT_STRAPP(p_library_path,p_lib_name);
+
+#define XMOUNTINPUT_LOADLIBS__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;                                                    \
+  }                                                              \
+}
+
+  // Try to load given library
+  p_libxmount=dlopen(p_library_path,RTLD_NOW);
+  if(p_libxmount==NULL) {
+    LOG_ERROR("Unable to load input library '%s': %s!\n",
+              p_library_path,
+              dlerror());
+    return e_XmountInput_Error_FailedLoadingLibrary;
+  }
+
+  // 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);
+    return e_XmountInput_Error_WrongLibraryApiVersion;
+  }
+
+  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_XmountInputLib,sizeof(ts_XmountInputLib));
+  // 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_lib_name);
+  p_input_lib->p_lib=p_libxmount;
+
+  // Get and set supported formats
+  p_supported_formats=pfun_input_GetSupportedFormats();
+  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_lib_name);
+    free(p_input_lib->p_supported_input_types);
+    free(p_input_lib->p_name);
+    free(p_input_lib);
+    dlclose(p_libxmount);
+    return e_XmountInput_Error_MissingLibraryFunction;
+  }
+
+  // Add entry to the input library list
+  XMOUNT_REALLOC(p_h->pp_libs,
+                 pts_XmountInputLib*,
+                 sizeof(pts_XmountInputLib)*(p_h->libs_count+1));
+  p_h->pp_libs[p_h->libs_count++]=p_input_lib;
+
+  LOG_DEBUG("Input library '%s' loaded successfully\n",p_lib_name);
+
+#undef XMOUNTINPUT_LOADLIBS__LOAD_SYMBOL
+
+  return e_XmountInput_Error_None;
+}
+
+te_XmountInput_Error XmountInput_GetLibraryCount(pts_XmountInputHandle p_h,
+                                                 uint32_t *p_count)
+{
+  // Params check
+  if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
+  if(p_count==NULL) return e_XmountInput_Error_InvalidBuffer;
+
+  *p_count=p_h->libs_count;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_GetSupportedFormats
  */
 te_XmountInput_Error XmountInput_GetSupportedFormats(pts_XmountInputHandle p_h,
                                                      char **pp_formats)
 {
   char *p_buf=NULL;
   char *p_formats=NULL;
   uint32_t cur_len=0;
   uint32_t vector_len=0;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(pp_formats==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   // Loop over all loaded libs, extract supported formats and add to our vector
   // TODO: IMPROVEMENT: Final vector could be sorted
   for(uint32_t i=0;i<p_h->libs_count;i++) {
     p_buf=p_h->pp_libs[i]->p_supported_input_types;
     while(p_buf!=NULL && *p_buf!='\0') p_buf+=(strlen(p_buf)+1);
     cur_len=(uint32_t)(p_buf-p_h->pp_libs[i]->p_supported_input_types);
     if(cur_len==0) continue;
     p_formats=(char*)realloc(p_formats,vector_len+cur_len);
     if(p_formats==NULL) return e_XmountInput_Error_Alloc;
     memcpy(p_formats+vector_len,
            p_h->pp_libs[i]->p_supported_input_types,
            cur_len);
     vector_len+=cur_len;
   }
 
   // Null-terminate vector
   p_formats=(char*)realloc(p_formats,vector_len+1);
   if(p_formats==NULL) return e_XmountInput_Error_Alloc;
   p_formats[vector_len]='\0';
 
   *pp_formats=p_formats;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_SetOptions
  */
 te_XmountInput_Error XmountInput_SetOptions(pts_XmountInputHandle p_h,
                                             char *p_options)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(p_options==NULL) return e_XmountInput_Error_InvalidString;
 
   // Make sure library parameters haven't been set previously
   if(p_h->pp_lib_params!=NULL) {
     LOG_ERROR("Input library options already set!\n");
     return e_XmountInput_Error_LibOptionsAlreadySet;
   }
 
   // Save options
   if(XmountLib_SplitLibParams(p_options,
                               &(p_h->lib_params_count),
                               &(p_h->pp_lib_params))!=0)
   {
     LOG_ERROR("Unable to parse input library options '%s'!\n",p_options);
     return e_XmountInput_Error_FailedParsingOptions;
   }
 
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_GetOptionsHelpText
  */
 te_XmountInput_Error XmountInput_GetOptionsHelpText(pts_XmountInputHandle p_h,
                                                     char **pp_help_text)
 {
   const char *p_buf=NULL;
   char *p_help=NULL;
   int ret=0;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(pp_help_text==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   // Loop over all loaded libs, extract help and add to our text buffer
   // TODO: IMPROVEMENT: Final text should be sorted by lib's name
   for(uint32_t i=0;i<p_h->libs_count;i++) {
     ret=p_h->pp_libs[i]->lib_functions.OptionsHelp(&p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to get options help for library '%s': %s!\n",
                 p_h->pp_libs[i]->p_name,
                 p_h->pp_libs[i]->lib_functions.GetErrorMessage(ret));
       continue;
     }
     if(p_buf==NULL) continue;
     XMOUNT_STRAPP(p_help,"  - ");
     XMOUNT_STRAPP(p_help,p_h->pp_libs[i]->p_name);
     XMOUNT_STRAPP(p_help,"\n");
     XMOUNT_STRAPP(p_help,p_buf);
     XMOUNT_STRAPP(p_help,"\n");
     ret=p_h->pp_libs[i]->lib_functions.FreeBuffer(p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to free options help text from library '%s': %s!\n",
                 p_h->pp_libs[i]->p_name,
                 p_h->pp_libs[i]->lib_functions.GetErrorMessage(ret));
     }
   }
 
   *pp_help_text=p_help;
   return e_XmountInput_Error_None;
 }
 
+/*
+ * XmountInput_GetLibsInfoText
+ */
+te_XmountInput_Error XmountInput_GetLibsInfoText(pts_XmountInputHandle p_h,
+                                                 char **pp_info_text)
+{
+  char *p_buf=NULL;
+  char *p_info_text=NULL;
+  uint8_t first=0;
+
+  // Params check
+  if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
+  if(pp_info_text==NULL) return e_XmountInput_Error_InvalidBuffer;
+
+  // Loop over all loaded libs, extract name and supported formats and add to
+  // our text buffer
+  // TODO: IMPROVEMENT: Final text should be sorted by lib's name
+  for(uint32_t i=0;i<p_h->libs_count;i++) {
+    XMOUNT_STRAPP(p_info_text,"    - ");
+    XMOUNT_STRAPP(p_info_text,p_h->pp_libs[i]->p_name);
+    XMOUNT_STRAPP(p_info_text," supporting ");
+    XMOUNT_STRAPP(p_info_text,"    - ");
+    XMOUNT_STRAPP(p_info_text,"    - ");
+    p_buf=p_h->pp_libs[i]->p_supported_input_types;
+    first=1;
+    while(*p_buf!='\0') {
+      if(first==1) {
+        XMOUNT_STRAPP(p_info_text,"\"");
+        XMOUNT_STRAPP(p_info_text,p_buf);
+        XMOUNT_STRAPP(p_info_text,"\"");
+        first=0;
+      } else {
+        XMOUNT_STRAPP(p_info_text,", \"");
+        XMOUNT_STRAPP(p_info_text,p_buf);
+        XMOUNT_STRAPP(p_info_text,"\"");
+      }
+      p_buf+=(strlen(p_buf)+1);
+    }
+    XMOUNT_STRAPP(p_info_text,"\n");
+  }
+
+  *pp_info_text=p_info_text;
+  return e_XmountInput_Error_None;
+}
+
 /*
  * XmountInput_AddImage
  */
 te_XmountInput_Error XmountInput_AddImage(pts_XmountInputHandle p_h,
                                           const char *p_format,
                                           uint64_t files_count,
                                           const char **pp_files)
 {
   pts_XmountInputImage p_image=NULL;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(p_format==NULL) return e_XmountInput_Error_InvalidString;
   if(pp_files==NULL) return e_XmountInput_Error_InvalidArray;
 
   // Alloc and fill new image structure
   XMOUNT_CALLOC(p_image,pts_XmountInputImage,sizeof(ts_XmountInputImage));
   XMOUNT_STRSET(p_image->p_type,p_format);
   p_image->files_count=files_count;
   XMOUNT_CALLOC(p_image->pp_files,char**,p_image->files_count*sizeof(char*));
   for(uint64_t i=0;i<p_image->files_count;i++) {
     XMOUNT_STRSET(p_image->pp_files[i],pp_files[i]);
   }
   p_image->p_functions=NULL;
   p_image->p_handle=NULL;
 
   // TODO: Find lib and open input file
 
   // Add image to our image array
   XMOUNT_REALLOC(p_h->pp_images,pts_XmountInputImage*,p_h->images_count+1);
   p_h->pp_images[p_h->images_count++]=p_image;
 
   return e_XmountInput_Error_None;
 }
 
+/*!
+ * \brief Get input image count
+ *
+ * Get input image count.
+ *
+ * \param p_h Input handle
+ * \param p_count Input image count is returned in this variable
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountInput_Error XmountInput_GetImageCount(pts_XmountInputHandle p_h,
+                                               uint64_t *p_count)
+{
+  // Params check
+  if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
+  if(p_count==NULL) return e_XmountInput_Error_InvalidBuffer;
+
+  *p_count=p_h->images_count;
+  return e_XmountInput_Error_None;
+}
+
 /*
  * XmountInput_SetInputOffset
  */
 te_XmountInput_Error XmountInput_SetInputOffset(pts_XmountInputHandle p_h,
                                                 uint64_t offset)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
 
   LOG_DEBUG("Setting input image offset to \"%" PRIu64 "\"\n",offset);
 
   p_h->image_offset=offset;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_SetInputSizeLimit
  */
 te_XmountInput_Error XmountInput_SetInputSizeLimit(pts_XmountInputHandle p_h,
                                                    uint64_t size_limit)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
 
   LOG_DEBUG("Setting input image size limit to \"%" PRIu64 "\"\n",size_limit);
 
   p_h->image_size_limit=size_limit;
   return e_XmountInput_Error_None;
 }
 
+/*
+ * XmountInput_Open
+ */
+te_XmountInput_Error XmountInput_Open(pts_XmountInputHandle p_h) {
+  // Params check
+  if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
+
+  // TODO: Implement
+
+  return e_XmountInput_Error_None;
+}
+
+/*
+ * XmountInput_Close
+ */
+te_XmountInput_Error XmountInput_Close(pts_XmountInputHandle p_h) {
+  // Params check
+  if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
+
+  // TODO: Implement
+
+  return e_XmountInput_Error_None;
+}
+
 /*
  * XmountInput_GetSize
  */
 te_XmountInput_Error XmountInput_GetSize(pts_XmountInputHandle p_h,
                                          uint64_t image_nr,
                                          uint64_t *p_size)
 {
   // TODO: Implement
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_ReadData
  */
 te_XmountInput_Error XmountInput_ReadData(pts_XmountInputHandle p_h,
                                           uint64_t image_nr,
                                           char *p_buf,
                                           uint64_t offset,
                                           uint64_t count)
 {
   // TODO: Implement
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_WriteData
  */
 te_XmountInput_Error XmountInput_WriteData(pts_XmountInputHandle p_h,
                                            uint64_t image_nr,
                                            const char *p_buf,
                                            uint64_t offset,
                                            uint64_t count)
 {
   // TODO: Implement
   return e_XmountInput_Error_None;
 }
 
+/*
+ * XmountInput_GetInfoFileContent
+ */
+te_XmountInput_Error XmountInput_GetInfoFileContent(pts_XmountInputHandle p_h,
+                                                    char **pp_content)
+{
+  int ret=0;
+  char *p_buf=NULL;
+  char *p_content=NULL;
+
+  // Params check
+  if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
+  if(pp_content==NULL) return e_XmountInput_Error_InvalidBuffer;
+
+  for(uint64_t i=0;i<p_h->images_count;i++) {
+    ret=p_h->pp_images[i]->p_functions->
+      GetInfofileContent(p_h->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",
+                p_h->pp_images[i]->pp_files[0],
+                p_h->pp_images[i]->p_functions->GetErrorMessage(ret));
+      return e_XmountInput_Error_FailedGettingInfoFileContent;
+    }
+    // Add infos to main buffer and free p_buf
+    XMOUNT_STRAPP(p_content,"\n--> ");
+    XMOUNT_STRAPP(p_content,p_h->pp_images[i]->pp_files[0]);
+    XMOUNT_STRAPP(p_content," <--\n");
+    if(p_buf!=NULL) {
+      XMOUNT_STRAPP(p_content,p_buf);
+      p_h->pp_images[i]->p_functions->FreeBuffer(p_buf);
+    } else {
+      XMOUNT_STRAPP(p_content,"None\n");
+    }
+  }
+
+  *pp_content=p_content;
+  return e_XmountInput_Error_None;
+}
+
 /*******************************************************************************
  * Private functions implementations
  ******************************************************************************/
+/*
+ * FindInputLib
+ */
+te_XmountInput_Error FindInputLib(pts_XmountInputHandle p_h,
+                                  pts_XmountInputImage 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<p_h->libs_count;i++) {
+    LOG_DEBUG("Checking input library %s\n",p_h->pp_libs[i]->p_name);
+    p_buf=p_h->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",
+                  p_h->pp_libs[i]->p_name);
+        p_input_image->p_functions=&(p_h->pp_libs[i]->lib_functions);
+        return e_XmountInput_Error_None;
+      }
+      p_buf+=(strlen(p_buf)+1);
+    }
+  }
+
+  LOG_DEBUG("Couldn't find any suitable library.\n");
+
+  // No library supporting input type found
+  return e_XmountInput_Error_UnsupportedFormat;
+}
 
 //! Read data from input image
 /*!
  * \param p_image Image from which to read data
  * \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 0 on success, negated error code on error
  */
 /*
 int ReadInputImageData(pts_InputImage p_image,
                        char *p_buf,
                        off_t offset,
                        size_t size,
                        size_t *p_read)
 {
   int ret;
   size_t to_read=0;
   int read_errno=0;
 
   LOG_DEBUG("Reading %zu bytes at offset %zu from input image '%s'\n",
             size,
             offset,
             p_image->pp_files[0]);
 
   // Make sure we aren't reading past EOF of image file
   if(offset>=p_image->size) {
     // Offset is beyond image size
     LOG_DEBUG("Offset %zu is at / beyond size of input image '%s'\n",
               offset,
               p_image->pp_files[0]);
     *p_read=0;
     return 0;
   }
   if(offset+size>p_image->size) {
     // Attempt to read data past EOF of image file
     to_read=p_image->size-offset;
     LOG_DEBUG("Attempt to read data past EOF of input image '%s'. "
                 "Correcting size from %zu to %zu\n",
               p_image->pp_files[0],
               size,
               to_read);
   } else to_read=size;
 
   // Read data from image file (adding input image offset if one was specified)
   ret=p_image->p_functions->Read(p_image->p_handle,
                                  p_buf,
                                  offset+glob_xmount.input.image_offset,
                                  to_read,
                                  p_read,
                                  &read_errno);
   if(ret!=0) {
     LOG_ERROR("Couldn't read %zu bytes at offset %zu from input image "
                 "'%s': %s!\n",
               to_read,
               offset,
               p_image->pp_files[0],
               p_image->p_functions->GetErrorMessage(ret));
     if(read_errno==0) return -EIO;
     else return (read_errno*(-1));
   }
 
   return 0;
 }
 */
diff --git a/src/xmount_input.h b/src/xmount_input.h
index 24e025a..e9c5c69 100644
--- a/src/xmount_input.h
+++ b/src/xmount_input.h
@@ -1,268 +1,312 @@
 /*******************************************************************************
 * 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_INPUT_H
 #define XMOUNT_INPUT_H
 
-#include "../libxmount_input/libxmount_input.h"
-
-/*
-//! Structure containing infos about input libs
-typedef struct s_InputLib {
-  //! Filename of lib (without path)
-  char *p_name;
-  //! Handle to the loaded lib
-  void *p_lib;
-  //! Array of supported input types
-  char *p_supported_input_types;
-  //! Struct containing lib functions
-  ts_LibXmountInputFunctions lib_functions;
-} ts_InputLib, *pts_InputLib;
-
-//! Structure containing infos about input images
-typedef struct s_InputImage {
-  //! Image type
-  char *p_type;
-  //! Image source file count
-  uint64_t files_count;
-  //! Image source files
-  char **pp_files;
-  //! Input lib functions for this image
-  pts_LibXmountInputFunctions p_functions;
-  //! Image handle
-  void *p_handle;
-  //! Image size
-  uint64_t size;
-} ts_InputImage, *pts_InputImage;
-
-typedef struct s_InputData {
-  //! Loaded input lib count
-  uint32_t libs_count;
-  //! Array containing infos about loaded input libs
-  pts_InputLib *pp_libs;
-  //! Amount of input lib params (--inopts)
-  uint32_t lib_params_count;
-  //! Input lib params (--inopts)
-  pts_LibXmountOptions *pp_lib_params;
-  //! Input image count
-  uint64_t images_count;
-  //! Input images
-  pts_InputImage *pp_images;
-  //! Input image offset (--offset)
-  uint64_t image_offset;
-  //! Input image size limit (--sizelimit)
-  uint64_t image_size_limit;
-  //! MD5 hash of partial input image (lower 64 bit) (after morph)
-  uint64_t image_hash_lo;
-  //! MD5 hash of partial input image (higher 64 bit) (after morph)
-  uint64_t image_hash_hi;
-} ts_InputData;
-
-int ReadInputImageData(pts_InputImage, char*, off_t, size_t, size_t*);
-*/
+#include <stdint.h>
 
 /*******************************************************************************
  * Public definitions / macros
  ******************************************************************************/
-
+//! Naming scheme of input libraries
+#define XMOUNT_INPUT_LIBRARY_NAMING_SCHEME "libxmount_input_"
 
 /*******************************************************************************
  * Public types / structures / enums
  ******************************************************************************/
 typedef struct s_XmountInputHandle *pts_XmountInputHandle;
 
 typedef enum e_XmountInput_Error {
   //! No error
   e_XmountInput_Error_None=0,
   //! Error to allocate memory
   e_XmountInput_Error_Alloc,
   //! Invalid input handle
   e_XmountInput_Error_InvalidHandle,
   //! Invalid pointer to an input handle
   e_XmountInput_Error_InvalidHandlePointer,
   //! A given buffer is invalid
   e_XmountInput_Error_InvalidBuffer,
   //! A given string is invalid
   e_XmountInput_Error_InvalidString,
   //! A given array is invalid
   e_XmountInput_Error_InvalidArray,
   //! Library options have already been set
   e_XmountInput_Error_LibOptionsAlreadySet,
   //! Library options couldn't be parsed
   e_XmountInput_Error_FailedParsingOptions,
+  //! Unable to get info file content from library
+  e_XmountInput_Error_FailedGettingInfoFileContent,
+  //! Unable to load library file
+  e_XmountInput_Error_FailedLoadingLibrary,
+  //! Library has wrong API version
+  e_XmountInput_Error_WrongLibraryApiVersion,
+  //! Library is missing a function
+  e_XmountInput_Error_MissingLibraryFunction,
+  //! Unsupported input image format
+  e_XmountInput_Error_UnsupportedFormat,
 /*
 
   //! 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_XmountInput_Error;
 
 /*******************************************************************************
  * Public functions declarations
  ******************************************************************************/
 /*!
  * \brief Create new input handle
  *
  * Creates a new input handle.
  *
  * \param pp_h Pointer to input handle
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_CreateHandle(pts_XmountInputHandle *pp_h);
 
 /*!
  * \brief Destroy input handle
  *
  * Invalidates the given handle and frees all used resources.
  *
  * \param pp_h Pointer to input handle
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_DestroyHandle(pts_XmountInputHandle *pp_h);
 
 /*!
- * \brief XXX
+ * \brief Load an input library
+ *
+ * Loads a given input library.
+ *
+ * \param p_h Input handle
+ * \param p_lib Library name (without path)
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountInput_Error XmountInput_AddLibrary(pts_XmountInputHandle p_h,
+                                            const char *p_lib_name);
+
+/*!
+ * \brief Get loaded input library count
  *
- * XXX
+ * Returns the number of successfully loaded input libraries.
  *
  * \param p_h Input handle
+ * \param p_count Library count is returned in this variable
+ * \return e_XmountInput_Error_None on success
  */
-te_XmountInput_Error XmountInput_LoadLibs(pts_XmountInputHandle p_h);
+te_XmountInput_Error XmountInput_GetLibraryCount(pts_XmountInputHandle p_h,
+                                                 uint32_t *p_count);
 
 /*!
  * \brief Return all supported formats
  *
  * Returns a null-terminated vector of all supported input formats.
  *
  * The returned vector must be freed by the caller.
  *
  * \param p_h Input handle
  * \param pp_formats Supported formats vector is returned in this var
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetSupportedFormats(pts_XmountInputHandle p_h,
                                                      char **pp_formats);
 
 /*!
  * \brief Set library options
  *
  * Parses the given library option string (as given after --inopts).
  *
  * \param p_h Input handle
  * \param p_options Library option string
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_SetOptions(pts_XmountInputHandle p_h,
                                             char *p_options);
 
 /*!
  * \brief Return all library specific option help texts
  *
  * Returns a string containing help messages for all loaded input lib options.
  * The string is pre-formated to be used in xmount's help output.
  *
  * The caller must free the returned string.
  *
  * \param p_h Input handle
  * \param pp_help_text Help text is returned in this parameter
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetOptionsHelpText(pts_XmountInputHandle p_h,
                                                     char **pp_help_text);
 
 /*!
- * \brief Generate a text containing infos about loaded libs
+ * \brief Returns a string containing infos about loaded libs
  *
- * TODO
+ * Returns a string containing infos about loaded input libraries. The string is
+ * pre-formated to be used in xmount's info output.
  *
+ * The caller must free the returned string.
+ *
+ * \param p_h Input handle
+ * \param pp_info_text Info text is returned in this parameter
+ * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetLibsInfoText(pts_XmountInputHandle p_h,
                                                  char **pp_info_text);
 
 /*!
  * \brief Add an input image
  *
  * Adds the given input image to the list of available input images.
  *
  * \param p_h Input handle
  * \param p_format Input image format string as given by the user
  * \param files_count Amount of files specified by the user
  * \param pp_files Array containing all specified files
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_AddImage(pts_XmountInputHandle p_h,
                                           const char *p_format,
                                           uint64_t files_count,
                                           const char **pp_files);
 
+/*!
+ * \brief Get input image count
+ *
+ * Get input image count.
+ *
+ * \param p_h Input handle
+ * \param p_count Input image count is returned in this variable
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountInput_Error XmountInput_GetImageCount(pts_XmountInputHandle p_h,
+                                               uint64_t *p_count);
+
+/*!
+ * \brief Set an input image offset
+ *
+ * Sets the amount of bytes that should be ignored at the beginning of every
+ * input image.
+ *
+ * \param p_h Input handle
+ * \param offset Amount of bytes to ignore
+ * \return e_XmountInput_Error_None on success
+ */
 te_XmountInput_Error XmountInput_SetInputOffset(pts_XmountInputHandle p_h,
                                                 uint64_t offset);
 
+/*!
+ * \brief Set an input image size limit
+ *
+ * Sets the amount of bytes that should be ignored at the end of every
+ * input image.
+ *
+ * \param p_h Input handle
+ * \param size_limit Amount of bytes to ignore
+ * \return e_XmountInput_Error_None on success
+ */
 te_XmountInput_Error XmountInput_SetInputSizeLimit(pts_XmountInputHandle p_h,
                                                    uint64_t size_limit);
 
+/*!
+ * \brief Opens all added input images
+ *
+ * Opens all added input images.
+ *
+ * \param p_h Input handle
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountInput_Error XmountInput_Open(pts_XmountInputHandle p_h);
+
+/*!
+ * \brief Closes all previously opened input images
+ *
+ * Closes all previously opened input images.
+ *
+ * \param p_h Input handle
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountInput_Error XmountInput_Close(pts_XmountInputHandle p_h);
+
 te_XmountInput_Error XmountInput_GetSize(pts_XmountInputHandle p_h,
                                          uint64_t image_nr,
                                          uint64_t *p_size);
 
 te_XmountInput_Error XmountInput_ReadData(pts_XmountInputHandle p_h,
                                           uint64_t image_nr,
                                           char *p_buf,
                                           uint64_t offset,
                                           uint64_t count);
 
 te_XmountInput_Error XmountInput_WriteData(pts_XmountInputHandle p_h,
                                            uint64_t image_nr,
                                            const char *p_buf,
                                            uint64_t offset,
                                            uint64_t count);
 
+/*!
+ * \brief Get info text to be added to xmount's info file
+ *
+ * Generates a string containing informations about currently opened input
+ * images.
+ *
+ * The caller must free the returned string.
+ *
+ * \param p_h Input handle
+ * \param pp_content Buffer in which text is returned
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountInput_Error XmountInput_GetInfoFileContent(pts_XmountInputHandle p_h,
+                                                    char **pp_content);
+
 #endif // XMOUNT_INPUT_H