Page Menu
Home
Phabricator
Search
Configure Global Search
Log In
Files
F4324345
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Size
126 KB
Referenced Files
None
Subscribers
None
View Options
diff --git a/src/xmount.c b/src/xmount.c
index 94a2b27..b84d26a 100755
--- a/src/xmount.c
+++ b/src/xmount.c
@@ -1,1752 +1,1909 @@
/*******************************************************************************
* 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 int 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 FindMorphingLib();
static int FindOutputLib();
/*
* 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*);
+static int LibXmount_Morphing_Write(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 ");
#define PRINTUSAGE__LIST_SUPP_LIB_TYPES(fun,handle,ret_ok) do { \
first=1; \
if(fun(handle,&p_buf)==ret_ok) { \
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"); \
} while(0)
// List supported input formats
PRINTUSAGE__LIST_SUPP_LIB_TYPES(XmountInput_GetSupportedFormats,
glob_xmount.h_input,
e_XmountInput_Error_None);
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
PRINTUSAGE__LIST_SUPP_LIB_TYPES(XmountMorphing_GetSupportedTypes,
glob_xmount.h_morphing,
e_XmountMorphError_None);
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");
#define PRINTUSAGE__LIST_LIB_OPT_HELP(fun,handle,ret_ok) do { \
if(fun(handle,&p_buf)==ret_ok) { \
printf("%s",p_buf); \
free(p_buf); \
} \
} while(0)
// List input, morphing and output lib options
PRINTUSAGE__LIST_LIB_OPT_HELP(XmountInput_GetOptionsHelpText,
glob_xmount.h_input,
e_XmountInput_Error_None);
PRINTUSAGE__LIST_LIB_OPT_HELP(XmountMorphing_GetOptionsHelpText,
glob_xmount.h_morphing,
e_XmountMorphError_None);
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");
}
#undef PRINTUSAGE__LIST_LIB_OPT_HELP
#undef PRINTUSAGE__LIST_SUPPORTED_LIB_OPTS
}
//! 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;
te_XmountMorphError morph_ret=e_XmountMorphError_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;
input_ret=XmountInput_EnableDebugging(glob_xmount.h_input);
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to enable input debugging: Error code %u!\n",
input_ret);
return FALSE;
}
+ morph_ret=XmountMorphing_EnableDebugging(glob_xmount.h_morphing);
+ if(morph_ret!=e_XmountMorphError_None) {
+ LOG_ERROR("Unable to enable morphing debugging: Error code %u!\n",
+ morph_ret);
+ return FALSE;
+ }
} 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++;
morph_ret=XmountMorphing_SetType(glob_xmount.h_morphing,
pp_argv[i]);
if(morph_ret!=e_XmountMorphError_None) {
LOG_ERROR("Unable to set morphing type: Error code %u!\n",
morph_ret);
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++;
morph_ret=XmountMorphing_SetOptions(glob_xmount.h_morphing,
pp_argv[i]);
if(morph_ret!=e_XmountMorphError_None) {
LOG_ERROR("Unable to parse morphing library options: "
"Error code %u!\n",
morph_ret);
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(XmountLib_SplitLibParams(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
#define PARSECMDLINE__PRINT_LOADED_LIBINFO(text,libret,fun,handle,err_ok) do { \
printf(text); \
libret=fun(handle,&p_buf); \
if(p_buf==NULL || libret!=err_ok) { \
LOG_ERROR("Unable to get library infos: Error code %u!\n",libret); \
return FALSE; \
} \
printf("%s",p_buf); \
XMOUNT_FREE(p_buf); \
} while(0)
PARSECMDLINE__PRINT_LOADED_LIBINFO(" loaded input libraries:\n",
input_ret,
XmountInput_GetLibsInfoText,
glob_xmount.h_input,
e_XmountInput_Error_None);
PARSECMDLINE__PRINT_LOADED_LIBINFO(" loaded morphing libraries:\n",
morph_ret,
XmountMorphing_GetLibsInfoText,
glob_xmount.h_morphing,
e_XmountMorphError_None);
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.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.p_first_input_image_name,NULL);
if(p_buf==NULL) {
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");
}
}
}
#undef PARSECMDLINE__PRINT_LOADED_LIBINFO
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)
{
+ // TODO: Reimplement
+/*
char hash[16];
md5_state_t md5_state;
char *p_buf;
int ret;
size_t read_data;
XMOUNT_MALLOC(p_buf,char*,HASH_AMOUNT*sizeof(char));
ret=ReadMorphedImageData(p_buf,0,HASH_AMOUNT,&read_data);
if(ret!=TRUE || read_data==0) {
LOG_ERROR("Couldn't read data from morphed image file!\n")
free(p_buf);
return FALSE;
}
// Calculate MD5 hash
md5_init(&md5_state);
md5_append(&md5_state,(const md5_byte_t*)p_buf,read_data);
md5_finish(&md5_state,(md5_byte_t*)hash);
// Convert MD5 hash into two 64bit integers
*p_hash_low=*((uint64_t*)hash);
*p_hash_high=*((uint64_t*)(hash+8));
free(p_buf);
-
+*/
return TRUE;
}
//! Create info file
/*!
* \return TRUE on success, FALSE on error
*/
static int InitInfoFile() {
- int ret;
char *p_buf;
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
te_XmountMorphError morph_ret=e_XmountMorphError_None;
// 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);
#define INITINFOFILE__GET_CONTENT(libret,fun,handle,err_ok,err_msg) do { \
libret=fun(handle,&p_buf); \
if(p_buf==NULL || libret!=err_ok) { \
LOG_ERROR(err_msg "Error code %u!\n",libret); \
return FALSE; \
} \
XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf); \
XMOUNT_FREE(p_buf); \
} while(0)
// Get and add infos from input lib(s)
INITINFOFILE__GET_CONTENT(input_ret,
XmountInput_GetInfoFileContent,
glob_xmount.h_input,
e_XmountInput_Error_None,
"Unable to get info file content from input lib: ");
// Add static morphing header
XMOUNT_STRAPP(glob_xmount.output.p_info_file,IMAGE_INFO_MORPHING_HEADER);
// Get and add infos from morphing lib
INITINFOFILE__GET_CONTENT(morph_ret,
XmountMorphing_GetInfoFileContent,
glob_xmount.h_morphing,
e_XmountMorphError_None,
"Unable to get info file content from morphing "
"lib: ");
#undef INITINFOFILE__GET_CONTENT
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_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;
uint32_t input_lib_count=0;
uint32_t morphing_lib_count=0;
pts_OutputLib p_output_lib=NULL;
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
te_XmountMorphError morph_ret=e_XmountMorphError_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,
XMOUNT_INPUT_LIBRARY_NAMING_SCHEME,
strlen(XMOUNT_INPUT_LIBRARY_NAMING_SCHEME))==0)
{
// Found possible input lib. Try to load it
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;
}
} if(strncmp(p_dirent->d_name,
XMOUNT_MORPHING_LIBRARY_NAMING_SCHEME,
strlen(XMOUNT_MORPHING_LIBRARY_NAMING_SCHEME))==0)
{
// Found possible morphing lib. Try to load it
morph_ret=XmountMorphing_AddLibrary(glob_xmount.h_morphing,
p_dirent->d_name);
if(morph_ret!=e_XmountMorphError_None) {
LOG_ERROR("Unable to add morphing library '%s': Error code %u!\n",
p_dirent->d_name,
morph_ret);
continue;
}
} 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;
}
morph_ret=XmountMorphing_GetLibraryCount(glob_xmount.h_morphing,
&morphing_lib_count);
if(morph_ret!=e_XmountMorphError_None) {
LOG_ERROR("Unable to get morphing 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",
input_lib_count,
morphing_lib_count,
glob_xmount.output.libs_count);
free(p_library_path);
closedir(p_dir);
return ((input_lib_count>0 &&
morphing_lib_count>0 &&
glob_xmount.output.libs_count>0) ? TRUE : 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 int InitResources() {
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
te_XmountMorphError morph_ret=e_XmountMorphError_None;
// Args
glob_xmount.args.overwrite_cache=FALSE;
glob_xmount.args.p_cache_file=NULL;
// Input
input_ret=XmountInput_CreateHandle(&(glob_xmount.h_input));
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to create input handle: Error code %u!\n",input_ret);
return FALSE;
}
// Morphing
morph_ret=XmountMorphing_CreateHandle(&(glob_xmount.h_morphing),
&LibXmount_Morphing_ImageCount,
&LibXmount_Morphing_Size,
&LibXmount_Morphing_Read,
&LibXmount_Morphing_Write);
- if(input_ret!=e_XmountMorphError_None) {
+ if(morph_ret!=e_XmountMorphError_None) {
LOG_ERROR("Unable to create morphing handle: Error code %u!\n",morph_ret);
return FALSE;
}
// 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;
glob_xmount.image_hash_lo=0;
glob_xmount.image_hash_hi=0;
return TRUE;
}
/*
* FreeResources
*/
static void FreeResources() {
int ret;
- te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
+ te_XmountMorphError morph_ret=e_XmountMorphError_None;
+ 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);
+ morph_ret=XmountMorphing_DestroyHandle(&(glob_xmount.h_morphing));
+ if(morph_ret!=e_XmountMorphError_None) {
+ LOG_ERROR("Unable to destroy morphing handle: Error code %u: Ignoring!\n",
+ morph_ret);
}
// Input
// Just in case close was not already called, call it now
input_ret=XmountInput_Close(glob_xmount.h_input);
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to close input image(s): Error code %u: Ignoring!\n",
input_ret);
}
input_ret=XmountInput_DestroyHandle(&(glob_xmount.h_input));
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to destroy input handle: Error code %u: Ignoring!\n",
input_ret);
}
// 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) {
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
input_ret=XmountInput_GetImageCount(glob_xmount.h_input,p_count);
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to get input image count: Error code %u!\n",input_ret);
return -EIO;
}
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) {
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
input_ret=XmountInput_GetSize(glob_xmount.h_input,image,p_size);
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to get size of input image %" PRIu64 ": Error code %u!\n",
image,
input_ret);
return -EIO;
}
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)
{
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
input_ret=XmountInput_ReadData(glob_xmount.h_input,
image,
p_buf,
offset,
count,
p_read);
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to read data of input image %" PRIu64
": Error code %u!\n",
image,
input_ret);
return -EIO;
}
return 0;
}
static int LibXmount_Morphing_Write(uint64_t image,
char *p_buf,
off_t offset,
size_t count,
size_t *p_written)
{
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
/*
input_ret=XmountInput_ReadData(glob_xmount.h_input,
image,
p_buf,
offset,
count,
p_read);
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to read data of input image %" PRIu64
": Error code %u!\n",
image,
input_ret);
return -EIO;
}
*/
return 0;
}
/*******************************************************************************
* 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;
+ te_XmountMorphError morph_ret=e_XmountMorphError_None;
- ret=GetMorphedImageSize(p_size);
+ morph_ret=XmountMorphing_GetSize(glob_xmount.h_morphing,p_size);
+ if(morph_ret!=e_XmountMorphError_None) {
+ LOG_ERROR("Unable to get morphed image size: Error code %u!\n",morph_ret);
+ return FALSE;
+ }
- return ret==TRUE ? 0 : ret;
+ return TRUE;
}
//! 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);
+ uint64_t block_off=0;
+ uint64_t cur_block=0;
+ uint64_t cur_to_read=0;
+ uint64_t image_size=0;
+ size_t read=0;
+ size_t to_read=0;
+ uint8_t is_block_cached=FALSE;
+ te_XmountMorphError morph_ret=e_XmountMorphError_None;
+ te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
+
+ // Make sure we aren't reading past EOF of image file
+ morph_ret=XmountMorphing_GetSize(glob_xmount.h_morphing,&image_size);
+ if(morph_ret!=e_XmountMorphError_None) {
+ LOG_ERROR("Couldn't get size of morphed image: Error code %u!\n",morph_ret);
+ return -EIO;
+ }
+ if(offset>=image_size) {
+ // Offset is beyond image size
+ LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
+ *p_read=0;
+ return FALSE;
+ }
+ if(offset+count>image_size) {
+ // Attempt to read data past EOF of morphed image file
+ to_read=image_size-offset;
+ LOG_DEBUG("Attempt to read data past EOF of morphed image. Corrected size "
+ "from %zu to %" PRIu64 ".\n",
+ count,
+ to_read);
+ } else to_read=count;
+
+ // Calculate block to start reading data from
+ cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
+ block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
+
+ // Read image data
+ while(to_read!=0) {
+ // Calculate how many bytes we have to read from this block
+ if(block_off+to_read>XMOUNT_CACHE_BLOCK_SIZE) {
+ cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-block_off;
+ } else cur_to_read=to_read;
+
+ // Determine if we have to read cached data
+ is_block_cached=FALSE;
+ if(glob_xmount.output.writable==TRUE) {
+ cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
+ if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
+ else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
+ LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
+ "Error code %u!\n",
+ cur_block,
+ cache_ret);
+ return -EIO;
+ }
+ }
+
+ // Check if block is cached
+ if(is_block_cached==TRUE) {
+ // Write support enabled and need to read altered data from cachefile
+ LOG_DEBUG("Reading %zu bytes from block cache file\n",cur_to_read);
+
+ cache_ret=XmountCache_BlockCacheRead(glob_xmount.h_cache,
+ p_buf,
+ cur_block,
+ block_off,
+ cur_to_read);
+ if(cache_ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to read %" PRIu64
+ " bytes of cached data from cache block %" PRIu64
+ " at cache block offset %" PRIu64 ": Error code %u!\n",
+ cur_to_read,
+ cur_block,
+ block_off,
+ cache_ret);
+ return -EIO;
+ }
+ } else {
+ // No write support or data not cached
+ morph_ret=XmountMorphing_ReadData(glob_xmount.h_morphing,
+ p_buf,
+ (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
+ block_off,
+ cur_to_read,
+ &read);
+ if(morph_ret!=e_XmountMorphError_None || read!=cur_to_read) {
+ LOG_ERROR("Couldn't read %zu bytes at offset %zu from morphed image: "
+ "Error code %u!\n",
+ cur_to_read,
+ offset,
+ morph_ret);
+ return -EIO;
+ }
+ LOG_DEBUG("Read %" PRIu64 " bytes at offset %" PRIu64
+ " from morphed image file\n",
+ cur_to_read,
+ (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+block_off);
+ }
+
+ cur_block++;
+ block_off=0;
+ p_buf+=cur_to_read;
+ to_read-=cur_to_read;
+ }
+
+ *p_read=to_read;
+ return TRUE;
}
//! 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);
+ uint64_t block_off=0;
+ uint64_t cur_block=0;
+ uint64_t cur_to_read=0;
+ uint64_t cur_to_write=0;
+ uint64_t image_size=0;
+ uint64_t read=0;
+ size_t to_write=0;
+ char *p_buf2=NULL;
+ uint8_t is_block_cached=FALSE;
+ te_XmountMorphError morph_ret=e_XmountMorphError_None;
+ te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
+
+ // Make sure we aren't writing past EOF of image file
+ morph_ret=XmountMorphing_GetSize(glob_xmount.h_morphing,&image_size);
+ if(morph_ret!=e_XmountMorphError_None) {
+ LOG_ERROR("Couldn't get size of morphed image: Error code %u!\n",morph_ret);
+ return -EIO;
+ }
+ if(offset>=image_size) {
+ // Offset is beyond image size
+ LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
+ *p_written=0;
+ return 0;
+ }
+ if(offset+count>image_size) {
+ // Attempt to write data past EOF of morphed image file
+ to_write=image_size-offset;
+ LOG_DEBUG("Attempt to write data past EOF of morphed image. Corrected size "
+ "from %zu to %" PRIu64 ".\n",
+ count,
+ to_write);
+ } else to_write=count;
+
+ // Calculate block to start writing data to
+ cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
+ block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
+
+ while(to_write!=0) {
+ // Calculate how many bytes we have to write to this block
+ if(block_off+to_write>XMOUNT_CACHE_BLOCK_SIZE) {
+ cur_to_write=XMOUNT_CACHE_BLOCK_SIZE-block_off;
+ } else cur_to_write=to_write;
+
+ // Determine if block is already in cache
+ is_block_cached=FALSE;
+ cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
+ if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
+ else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
+ LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
+ "Error code %u!\n",
+ cur_block,
+ cache_ret);
+ return -EIO;
+ }
+
+ // Check if block is cached
+ if(is_block_cached==TRUE) {
+ // Block is cached
+ cache_ret=XmountCache_BlockCacheWrite(glob_xmount.h_cache,
+ p_buf,
+ cur_block,
+ block_off,
+ cur_to_write);
+ if(cache_ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to write %" PRIu64
+ " bytes of data to cache block %" PRIu64
+ " at cache block offset %" PRIu64 ": Error code %u!\n",
+ cur_to_write,
+ cur_block,
+ block_off,
+ cache_ret);
+ return -EIO;
+ }
+
+ LOG_DEBUG("Wrote %" PRIu64 " bytes to block cache\n",cur_to_write);
+ } else {
+ // Uncached block. Need to cache entire new block
+ // Prepare new write buffer
+ XMOUNT_MALLOC(p_buf2,char*,XMOUNT_CACHE_BLOCK_SIZE);
+ memset(p_buf2,0x00,XMOUNT_CACHE_BLOCK_SIZE);
+
+ // Read full block from morphed image
+ cur_to_read=XMOUNT_CACHE_BLOCK_SIZE;
+ if((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+XMOUNT_CACHE_BLOCK_SIZE>image_size) {
+ cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-(((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
+ XMOUNT_CACHE_BLOCK_SIZE)-image_size);
+ }
+ morph_ret=XmountMorphing_ReadData(glob_xmount.h_morphing,
+ p_buf,
+ cur_block*XMOUNT_CACHE_BLOCK_SIZE,
+ cur_to_read,
+ &read);
+ if(morph_ret!=e_XmountMorphError_None || read!=cur_to_read) {
+ LOG_ERROR("Couldn't read %" PRIu64 " bytes at offset %zu "
+ "from morphed image: Error code %u!\n",
+ cur_to_read,
+ offset,
+ morph_ret);
+ XMOUNT_FREE(p_buf2);
+ return -EIO;
+ }
+
+ // Set changed data
+ memcpy(p_buf2+block_off,p_buf,cur_to_write);
+
+ cache_ret=XmountCache_BlockCacheAppend(glob_xmount.h_cache,
+ p_buf,
+ cur_block);
+ if(cache_ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to append new block cache block %" PRIu64
+ ": Error code %u!\n",
+ cur_block,
+ cache_ret);
+ XMOUNT_FREE(p_buf2);
+ return -EIO;
+ }
+ XMOUNT_FREE(p_buf2);
+
+ LOG_DEBUG("Appended new block cache block %" PRIu64 "\n",cur_block);
+ }
+
+ block_off=0;
+ cur_block++;
+ p_buf+=cur_to_write;
+ to_write-=cur_to_write;
+ }
+
+ *p_written=to_write;
+ return TRUE;
}
/*******************************************************************************
* Main
******************************************************************************/
int main(int argc, char *argv[]) {
uint64_t input_image_count=0;
struct stat file_stat;
int ret;
int fuse_ret;
char *p_err_msg;
te_XmountInput_Error input_ret=e_XmountInput_Error_None;
+ te_XmountMorphError morph_ret=e_XmountMorphError_None;
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
if(InitResources()==FALSE) {
LOG_ERROR("Unable to initialize internal resources!\n");
return 1;
}
// 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
input_ret=XmountInput_GetImageCount(glob_xmount.h_input,&input_image_count);
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Unable to get input image count: Error code %u!\n",input_ret);
return 1;
}
if(input_image_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
input_ret=XmountInput_Open(glob_xmount.h_input);
if(input_ret!=e_XmountInput_Error_None) {
LOG_ERROR("Failed opening input image(s): Error code %u!\n",input_ret);
FreeResources();
return 1;
}
- // 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.image_hash_lo),
&(glob_xmount.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.image_hash_lo)))+i));
for(int i=0;i<8;i++)
printf("%02hhx",*(((char*)(&(glob_xmount.image_hash_hi)))+i));
printf("\n");
}
if(!ExtractOutputFileNames(glob_xmount.p_first_input_image_name)) {
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));
+ morph_ret=XmountMorphing_StartMorphing(glob_xmount.h_morphing);
+ if(morph_ret!=e_XmountMorphError_None) {
+ LOG_ERROR("Unable to start morphing: Error code %u!\n",morph_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_morphing.c b/src/xmount_morphing.c
index f7207c1..3c164a8 100644
--- a/src/xmount_morphing.c
+++ b/src/xmount_morphing.c
@@ -1,862 +1,737 @@
/*******************************************************************************
* 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 <dlfcn.h> // For dlopen, dlclose, dlsym
#include "../libxmount_morphing/libxmount_morphing.h"
#include "xmount_morphing.h"
#include "xmount.h"
#include "macros.h"
/*******************************************************************************
* Private definitions / macros
******************************************************************************/
+#define XMOUNT_MORPHING_DEFAULT_MORPH_TYPE "combine"
+
#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 morphing libs
typedef struct s_XmountMorphingLib {
//! Filename of lib (without path)
char *p_name;
//! Handle to the loaded lib
void *p_lib;
//! Array of supported morphing types
char *p_supported_morphing_types;
//! Struct containing lib functions
ts_LibXmountMorphingFunctions lib_functions;
} ts_XmountMorphingLib, *pts_XmountMorphingLib;
//! Structures and vars needed for morph support
typedef struct s_XmountMorphHandle {
//! Loaded morphing lib count
uint32_t libs_count;
//! Array containing infos about loaded morphing libs
pts_XmountMorphingLib *pp_libs;
//! Specified morphing type (--morph)
char *p_morph_type;
//! Amount of specified morphing lib params (--morphopts)
uint32_t lib_params_count;
//! Specified morphing lib params (--morphopts)
pts_LibXmountOptions *pp_lib_params;
//! Handle to initialized morphing lib
void *p_handle;
+ //! Debug
+ uint8_t debug;
//! Morphing functions of initialized lib
pts_LibXmountMorphingFunctions p_functions;
//! Input image functions passed to morphing lib
ts_LibXmountMorphingInputFunctions input_image_functions;
} ts_XmountMorphHandle;
/*******************************************************************************
* Private functions declarations
******************************************************************************/
/*!
* \brief Find a morphing lib for a given morph type
*
* Searches trough the list of loaded morphing libraries to find one that
* supports the given morph type. On success, that library is associated with
* the given handle.
*
* \param p_h Morphing handle
* \return e_XmountInput_Error_None on success
*/
te_XmountMorphError XmountMorphing_FindMorphLib(pts_XmountMorphHandle p_h);
/*******************************************************************************
* Public functions implementations
******************************************************************************/
/*
* XmountMorphing_CreateHandle
*/
-te_XmountMorphError XmountMorphing_CreateHandle(pts_XmountMorphHandle *pp_h) {
+te_XmountMorphError
+ XmountMorphing_CreateHandle(pts_XmountMorphHandle *pp_h,
+ tfun_XmountMorphing_InputImageCount p_img_count,
+ tfun_XmountMorphing_InputImageSize p_img_size,
+ tfun_XmountMorphing_InputImageRead p_img_read,
+ tfun_XmountMorphing_InputImageWrite p_img_write)
+{
pts_XmountMorphHandle p_h=NULL;
// Params check
if(pp_h==NULL) return e_XmountMorphError_InvalidHandlePointer;
// Alloc new handle
p_h=(pts_XmountMorphHandle)calloc(1,sizeof(ts_XmountMorphHandle));
if(p_h==NULL) return e_XmountMorphError_Alloc;
// Init values
p_h->pp_libs=NULL;
p_h->p_morph_type=NULL;
p_h->pp_lib_params=NULL;
p_h->p_handle=NULL;
p_h->p_functions=NULL;
- p_h->input_image_functions.ImageCount=&LibXmount_Morphing_ImageCount;
- p_h->input_image_functions.Size=&LibXmount_Morphing_Size;
- p_h->input_image_functions.Read=&LibXmount_Morphing_Read;
+ p_h->input_image_functions.ImageCount=p_img_count;
+ p_h->input_image_functions.Size=p_img_size;
+ p_h->input_image_functions.Read=p_img_read;
+ //p_h->input_image_functions.Write=p_img_write;
*pp_h=p_h;
return e_XmountMorphError_None;
}
/*
* XmountMorphing_DestroyHandle
*/
te_XmountMorphError XmountMorphing_DestroyHandle(pts_XmountMorphHandle *pp_h) {
+ int ret=0;
+ pts_XmountMorphHandle p_h=NULL;
+
// Params check
if(pp_h==NULL) return e_XmountMorphError_InvalidHandlePointer;
+ if(*pp_h==NULL) return e_XmountMorphError_InvalidHandle;
+ p_h=*pp_h;
+
+ if(p_h->p_functions!=NULL) {
+ if(p_h->p_handle!=NULL) {
+ // Destroy morphing handle
+ ret=p_h->p_functions->DestroyHandle(&(p_h->p_handle));
+ if(ret!=0) {
+ LOG_ERROR("Unable to destroy morphing handle: %s!\n",
+ p_h->p_functions->GetErrorMessage(ret));
+ }
+ }
+ }
+ if(p_h->pp_lib_params!=NULL) {
+ for(uint32_t i=0;i<p_h->lib_params_count;i++) {
+ XMOUNT_FREE(p_h->pp_lib_params[i]);
+ }
+ XMOUNT_FREE(p_h->pp_lib_params);
+ }
+ if(p_h->p_morph_type!=NULL) XMOUNT_FREE(p_h->p_morph_type);
+ if(p_h->pp_libs!=NULL) {
+ // Unload morphing libs
+ for(uint32_t i=0;i<p_h->libs_count;i++) {
+ if(p_h->pp_libs[i]==NULL) continue;
+ if(p_h->pp_libs[i]->p_supported_morphing_types!=NULL)
+ XMOUNT_FREE(p_h->pp_libs[i]->p_supported_morphing_types);
+ if(p_h->pp_libs[i]->p_lib!=NULL)
+ dlclose(p_h->pp_libs[i]->p_lib);
+ if(p_h->pp_libs[i]->p_name!=NULL)
+ XMOUNT_FREE(p_h->pp_libs[i]->p_name);
+ XMOUNT_FREE(p_h->pp_libs[i]);
+ }
+ XMOUNT_FREE(p_h->pp_libs);
+ }
- // TODO: Impement
-
+ *pp_h=NULL;
return e_XmountMorphError_None;
}
/*
* XmountMorphing_EnableDebugging
*/
te_XmountMorphError XmountMorphing_EnableDebugging(pts_XmountMorphHandle p_h) {
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
- // TODO: Impement
-
+ p_h->debug=1;
return e_XmountMorphError_None;
}
/*
* XmountMorphing_AddLibrary
*/
te_XmountMorphError XmountMorphing_AddLibrary(pts_XmountMorphHandle p_h,
const char *p_lib_name)
{
uint32_t supported_types_len=0;
t_LibXmount_Morphing_GetApiVersion pfun_morphing_GetApiVersion;
t_LibXmount_Morphing_GetSupportedTypes pfun_morphing_GetSupportedTypes;
t_LibXmount_Morphing_GetFunctions pfun_morphing_GetFunctions;
void *p_libxmount=NULL;
pts_XmountMorphingLib p_morphing_lib=NULL;
char *p_buf=NULL;
char *p_library_path=NULL;
char *p_supported_types=NULL;
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
if(p_lib_name==NULL) return e_XmountMorphError_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 XMOUNTMORPHING_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); \
return e_XmountMorphError_FailedLoadingSymbol; \
} \
}
// Try to load given library
p_libxmount=dlopen(p_library_path,RTLD_NOW);
if(p_libxmount==NULL) {
LOG_ERROR("Unable to load morphing library '%s': %s!\n",
p_library_path,
dlerror());
return e_XmountMorphError_FailedLoadingLibrary;
}
// Load library symbols
XMOUNTMORPHING_LOADLIBS__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);
return e_XmountMorphError_WrongLibraryApiVersion;
}
- LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetSupportedTypes",
- pfun_morphing_GetSupportedTypes);
- LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetFunctions",
- pfun_morphing_GetFunctions);
+ XMOUNTMORPHING_LOADLIBS__LOAD_SYMBOL("LibXmount_Morphing_GetSupportedTypes",
+ pfun_morphing_GetSupportedTypes);
+ XMOUNTMORPHING_LOADLIBS__LOAD_SYMBOL("LibXmount_Morphing_GetFunctions",
+ pfun_morphing_GetFunctions);
// Construct new entry for our library list
XMOUNT_MALLOC(p_morphing_lib,
pts_XmountMorphingLib,
sizeof(ts_XmountMorphingLib));
// 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_lib_name);
p_morphing_lib->p_lib=p_libxmount;
// Get and set supported types
p_supported_types=pfun_morphing_GetSupportedTypes();
supported_types_len=0;
p_buf=p_supported_types;
while(*p_buf!='\0') {
supported_types_len+=(strlen(p_buf)+1);
p_buf+=(strlen(p_buf)+1);
}
supported_types_len++;
XMOUNT_MALLOC(p_morphing_lib->p_supported_morphing_types,
char*,
supported_types_len);
memcpy(p_morphing_lib->p_supported_morphing_types,
p_supported_types,
supported_types_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_lib_name);
XMOUNT_FREE(p_morphing_lib->p_supported_morphing_types);
XMOUNT_FREE(p_morphing_lib->p_name);
XMOUNT_FREE(p_morphing_lib);
dlclose(p_libxmount);
return e_XmountMorphError_MissingLibraryFunction;
}
// Add entry to the input library list
XMOUNT_REALLOC(p_h->pp_libs,
pts_XmountMorphingLib*,
sizeof(pts_XmountMorphingLib)*(p_h->libs_count+1));
p_h->pp_libs[p_h->libs_count++]=p_morphing_lib;
LOG_DEBUG("Morphing library '%s' loaded successfully\n",p_lib_name);
return e_XmountMorphError_None;
}
/*
* XmountMorphing_GetLibraryCount
*/
te_XmountMorphError XmountMorphing_GetLibraryCount(pts_XmountMorphHandle p_h,
uint32_t *p_count)
{
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
// TODO: Impement
return e_XmountMorphError_None;
}
/*
* XmountMorphing_GetSupportedTypes
*/
te_XmountMorphError XmountMorphing_GetSupportedTypes(pts_XmountMorphHandle p_h,
char **pp_types)
{
char *p_buf=NULL;
char *p_types=NULL;
uint32_t cur_len=0;
uint32_t vector_len=0;
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
if(pp_types==NULL) return e_XmountMorphError_InvalidBuffer;
// Loop over all loaded libs, extract supported types 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_morphing_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_morphing_types);
if(cur_len==0) continue;
p_types=(char*)realloc(p_types,vector_len+cur_len);
if(p_types==NULL) return e_XmountInput_Error_Alloc;
memcpy(p_types+vector_len,
p_h->pp_libs[i]->p_supported_morphing_types,
cur_len);
vector_len+=cur_len;
}
// Null-terminate vector
p_types=(char*)realloc(p_types,vector_len+1);
if(p_types==NULL) return e_XmountInput_Error_Alloc;
p_types[vector_len]='\0';
*pp_types=p_types;
return e_XmountMorphError_None;
}
/*
* XmountMorphing_SetOptions
*/
te_XmountMorphError XmountMorphing_SetOptions(pts_XmountMorphHandle p_h,
char *p_options)
{
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
if(p_options==NULL) return e_XmountMorphError_InvalidString;
// Make sure library parameters haven't been set previously
if(p_h->pp_lib_params!=NULL) {
LOG_ERROR("Morphing library options already set!\n");
return e_XmountMorphError_LibOptionsAlreadySet;
}
// Save options
if(XmountLib_SplitLibParams(p_options,
&(p_h->lib_params_count),
&(p_h->pp_lib_params))!=0)
{
LOG_ERROR("Unable to parse morphing library options '%s'!\n",p_options);
return e_XmountMorphError_FailedParsingOptions;
}
return e_XmountMorphError_None;
}
/*
* XmountMorphing_GetOptionsHelpText
*/
te_XmountMorphError XmountMorphing_GetOptionsHelpText(pts_XmountMorphHandle p_h,
char **pp_help_text)
{
- const char *p_buf=NULL;
+ char *p_buf=NULL;
char *p_help=NULL;
int ret=0;
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
if(pp_help_text==NULL) return e_XmountMorphError_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");
p_h->pp_libs[i]->lib_functions.FreeBuffer(p_buf);
}
*pp_help_text=p_help;
return e_XmountMorphError_None;
}
/*
* XmountMorphingt_GetLibsInfoText
*/
te_XmountMorphError XmountMorphing_GetLibsInfoText(pts_XmountMorphHandle 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_XmountMorphError_InvalidHandle;
if(pp_info_text==NULL) return e_XmountMorphError_InvalidBuffer;
// Loop over all loaded libs, extract name and supported types 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_morphing_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_XmountMorphError_None;
}
/*
* XmountMorphing_SetType
*/
te_XmountMorphError XmountMorphing_SetType(pts_XmountMorphHandle p_h,
char *p_type)
{
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
if(p_type==NULL) return e_XmountMorphError_InvalidString;
XMOUNT_STRSET(p_h->p_morph_type,p_type);
return e_XmountMorphError_None;
}
/*
- * XmountMorphing_StartMorph
+ * XmountMorphing_StartMorphing
*/
-te_XmountMorphError XmountMorphing_StartMorph(pts_XmountMorphHandle p_h) {
+te_XmountMorphError XmountMorphing_StartMorphing(pts_XmountMorphHandle p_h) {
+ const char *p_err_msg=NULL;
+ int ret=0;
+ te_XmountMorphError morph_ret=e_XmountMorphError_None;
+
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
- // TODO: Impement
+ // Set default morph type if none was set previously
+ if(p_h->p_morph_type==NULL) {
+ XMOUNT_STRSET(p_h->p_morph_type,XMOUNT_MORPHING_DEFAULT_MORPH_TYPE);
+ }
+
+ // Find morphing lib
+ morph_ret=XmountMorphing_FindMorphLib(p_h);
+ if(morph_ret!=e_XmountMorphError_None) {
+ LOG_ERROR("Unable to find a library supporting the morphing type '%s'!\n",
+ p_h->p_morph_type);
+ return morph_ret;
+ }
+
+ // Init morphing
+ ret=p_h->p_functions->CreateHandle(&(p_h->p_handle),
+ p_h->p_morph_type,
+ p_h->debug);
+ if(ret!=0) {
+ LOG_ERROR("Unable to create morphing handle: %s!\n",
+ p_h->p_functions->GetErrorMessage(ret));
+ return e_XmountMorphError_FailedCreatingMorphHandle;
+ }
+
+ // Parse morphing lib specific options
+ if(p_h->pp_lib_params!=NULL) {
+ p_err_msg=NULL;
+ ret=p_h->p_functions->OptionsParse(p_h->p_handle,
+ p_h->lib_params_count,
+ p_h->pp_lib_params,
+ &p_err_msg);
+ if(ret!=0) {
+ if(p_err_msg!=NULL) {
+ LOG_ERROR("Unable to parse morphing library specific options: %s: %s!\n",
+ p_h->p_functions->GetErrorMessage(ret),
+ p_err_msg);
+ p_h->p_functions->FreeBuffer(p_err_msg);
+ } else {
+ LOG_ERROR("Unable to parse morphing library specific options: %s!\n",
+ p_h->p_functions->GetErrorMessage(ret));
+ }
+ return e_XmountInput_Error_FailedParsingLibParams;
+ }
+ }
+
+ // Morph image
+ ret=p_h->p_functions->Morph(p_h->p_handle,&(p_h->input_image_functions));
+ if(ret!=0) {
+ LOG_ERROR("Unable to start morphing: %s!\n",
+ p_h->p_functions->GetErrorMessage(ret));
+ return e_XmountMorphError_FailedCreatingMorphHandle;
+ }
return e_XmountMorphError_None;
}
/*
- * XmountInput_StopMorph
+ * XmountInput_StopMorphing
*/
-te_XmountMorphError XmountInput_StopMorph(pts_XmountMorphHandle p_h) {
+te_XmountMorphError XmountInput_StopMorphing(pts_XmountMorphHandle p_h) {
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
// TODO: Impement
return e_XmountMorphError_None;
}
/*
* XmountMorphing_GetSize
*/
te_XmountMorphError XmountMorphing_GetSize(pts_XmountMorphHandle p_h,
uint64_t *p_size)
{
int ret=0;
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
if(p_size==NULL) return e_XmountMorphError_InvalidBuffer;
// Get morphed image size
ret=p_h->p_functions->Size(p_h->p_handle,p_size);
if(ret!=0) {
LOG_ERROR("Unable to get morphed image size: %s!\n",
p_h->p_functions->GetErrorMessage(ret));
return e_XmountMorphError_FailedGettingImageSize;
}
return e_XmountMorphError_None;
}
/*
* XmountMorphing_ReadData
*/
te_XmountMorphError XmountMorphing_ReadData(pts_XmountMorphHandle p_h,
char *p_buf,
uint64_t offset,
uint64_t count,
uint64_t *p_read)
{
+ uint64_t image_size=0;
+ size_t read=0;
+ size_t to_read=0;
+ int ret;
+ te_XmountMorphError morph_ret=e_XmountMorphError_None;
+
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
- // TODO: Impement
+ // Make sure we aren't reading past EOF of image file
+ morph_ret=XmountMorphing_GetSize(p_h,&image_size);
+ if(morph_ret!=e_XmountMorphError_None) {
+ LOG_ERROR("Couldn't get size of morphed image: Error code %u!\n",morph_ret);
+ return morph_ret;
+ }
+ if(offset>=image_size) {
+ // Offset is beyond image size
+ LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
+ *p_read=0;
+ return e_XmountMorphError_OffsetExceedsImageSize;
+ }
+ if(offset+count>image_size) {
+ // Attempt to read data past EOF of morphed image file
+ to_read=image_size-offset;
+ LOG_DEBUG("Attempt to read data past EOF of morphed image. Corrected size "
+ "from %zu to %" PRIu64 ".\n",
+ count,
+ to_read);
+ } else to_read=count;
+
+ ret=p_h->p_functions->Read(p_h->p_handle,
+ p_buf,
+ offset,
+ to_read,
+ p_read);
+ if(ret!=0) {
+ LOG_ERROR("Couldn't read %zu bytes at offset %zu from morphed image: %s!\n",
+ to_read,
+ offset,
+ p_h->p_functions->GetErrorMessage(ret));
+ return e_XmountMorphError_FailedReadingData;
+ }
+
+ LOG_DEBUG("Read %" PRIu64 " bytes at offset %" PRIu64
+ " from morphed image file\n",
+ to_read,
+ offset);
return e_XmountMorphError_None;
}
/*
* XmountMorphing_WriteData
*/
te_XmountMorphError XmountMorphing_WriteData(pts_XmountMorphHandle p_h,
const char *p_buf,
uint64_t offset,
- uint64_t count)
+ uint64_t count,
+ uint64_t *p_written)
{
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
// TODO: Impement
return e_XmountMorphError_None;
}
/*
* XmountMorphing_GetInfoFileContent
*/
te_XmountMorphError XmountMorphing_GetInfoFileContent(pts_XmountMorphHandle p_h,
char **pp_content)
{
int ret=0;
char *p_buf=NULL;
char *p_content=NULL;
// Params check
if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
if(pp_content==NULL) return e_XmountMorphError_InvalidBuffer;
ret=p_h->p_functions->GetInfofileContent(p_h->p_handle,(const char**)&p_buf);
if(ret!=0) {
LOG_ERROR("Unable to get info file content from morphing lib: %s!\n",
p_h->p_functions->GetErrorMessage(ret));
return e_XmountMorphError_FailedGettingInfoFileContent;
}
// Add infos to main buffer and free p_buf
if(p_buf!=NULL) {
XMOUNT_STRAPP(p_content,p_buf);
p_h->p_functions->FreeBuffer(p_buf);
} else {
XMOUNT_STRAPP(p_content,"None\n");
}
*pp_content=p_content;
return e_XmountMorphError_None;
}
/*******************************************************************************
* Private functions implementations
******************************************************************************/
/*
* XmountMorphing_FindMorphLib
*/
te_XmountMorphError XmountMorphing_FindMorphLib(pts_XmountMorphHandle p_h) {
char *p_buf;
LOG_DEBUG("Trying to find suitable library for morph type '%s'.\n",
p_h->p_morph_type);
// Loop over all loaded libs
for(uint32_t i=0;i<p_h->libs_count;i++) {
LOG_DEBUG("Checking morphing library %s\n",p_h->pp_libs[i]->p_name);
p_buf=p_h->pp_libs[i]->p_supported_morphing_types;
while(*p_buf!='\0') {
if(strcmp(p_buf,p_h->p_morph_type)==0) {
// Library supports morph type, set lib functions
LOG_DEBUG("Morphing library '%s' pretends to handle that morph type.\n",
p_h->pp_libs[i]->p_name);
p_h->p_functions=&(p_h->pp_libs[i]->lib_functions);
return e_XmountMorphError_None;
}
p_buf+=(strlen(p_buf)+1);
}
}
LOG_DEBUG("Couldn't find any suitable library.\n");
// No library supporting morph type found
- return e_XmountInput_Error_UnsupportedType;
-}
-
-
-//! Read data from morphed image
-/*!
- * \param p_buf Pointer to buffer to write read data to (must be preallocated!)
- * \param offset Offset at which data should be read
- * \param size Size of data which should be read (size of buffer)
- * \param p_read Number of read bytes on success
- * \return TRUE on success, negated error code on error
- */
-/*
-int ReadMorphedImageData(char *p_buf,
- off_t offset,
- size_t size,
- size_t *p_read)
-{
- uint64_t block_off=0;
- uint64_t cur_block=0;
- uint64_t cur_to_read=0;
- uint64_t image_size=0;
- size_t read=0;
- size_t to_read=0;
- int ret;
- uint8_t is_block_cached=FALSE;
- te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
-
- // Make sure we aren't reading past EOF of image file
- if(GetMorphedImageSize(&image_size)!=TRUE) {
- LOG_ERROR("Couldn't get size of morphed image!\n");
- return -EIO;
- }
- if(offset>=image_size) {
- // Offset is beyond image size
- LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
- *p_read=0;
- return FALSE;
- }
- if(offset+size>image_size) {
- // Attempt to read data past EOF of morphed image file
- to_read=image_size-offset;
- LOG_DEBUG("Attempt to read data past EOF of morphed image. Corrected size "
- "from %zu to %" PRIu64 ".\n",
- size,
- to_read);
- } else to_read=size;
-
- // Calculate block to start reading data from
- cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
- block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
-
- // Read image data
- while(to_read!=0) {
- // Calculate how many bytes we have to read from this block
- if(block_off+to_read>XMOUNT_CACHE_BLOCK_SIZE) {
- cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-block_off;
- } else cur_to_read=to_read;
-
- // Determine if we have to read cached data
- is_block_cached=FALSE;
- if(glob_xmount.output.writable==TRUE) {
- cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
- if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
- else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
- LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
- "Error code %u!\n",
- cur_block,
- cache_ret);
- return -EIO;
- }
- }
-
- // Check if block is cached
- if(is_block_cached==TRUE) {
- // Write support enabled and need to read altered data from cachefile
- LOG_DEBUG("Reading %zu bytes from block cache file\n",cur_to_read);
-
- cache_ret=XmountCache_BlockCacheRead(glob_xmount.h_cache,
- p_buf,
- cur_block,
- block_off,
- cur_to_read);
- if(cache_ret!=e_XmountCache_Error_None) {
- LOG_ERROR("Unable to read %" PRIu64
- " bytes of cached data from cache block %" PRIu64
- " at cache block offset %" PRIu64 ": Error code %u!\n",
- cur_to_read,
- cur_block,
- block_off,
- cache_ret);
- return -EIO;
- }
- } else {
- // No write support or data not cached
- ret=glob_xmount.morphing.p_functions->Read(glob_xmount.morphing.p_handle,
- p_buf,
- (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
- block_off,
- cur_to_read,
- &read);
- if(ret!=0 || read!=cur_to_read) {
- LOG_ERROR("Couldn't read %zu bytes at offset %zu from morphed image: "
- "%s!\n",
- cur_to_read,
- offset,
- glob_xmount.morphing.p_functions->GetErrorMessage(ret));
- return -EIO;
- }
- LOG_DEBUG("Read %" PRIu64 " bytes at offset %" PRIu64
- " from morphed image file\n",
- cur_to_read,
- (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+block_off);
- }
-
- cur_block++;
- block_off=0;
- p_buf+=cur_to_read;
- to_read-=cur_to_read;
- }
-
- *p_read=to_read;
- return TRUE;
-}
-*/
-
-//! Write data to morphed image
-/*!
- * \param p_buf Buffer with data to write
- * \param offset Offset to start writing at
- * \param count Amount of bytes to write
- * \param p_written Amount of successfully written bytes
- * \return TRUE on success, negated error code on error
- */
-/*
-int WriteMorphedImageData(const char *p_buf,
- off_t offset,
- size_t count,
- size_t *p_written)
-{
- uint64_t block_off=0;
- uint64_t cur_block=0;
- uint64_t cur_to_read=0;
- uint64_t cur_to_write=0;
- uint64_t image_size=0;
- uint64_t read=0;
- size_t written=0;
- size_t to_write=0;
- int ret;
- char *p_buf2=NULL;
- uint8_t is_block_cached=FALSE;
- te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
-
- // Make sure we aren't writing past EOF of image file
- if(GetMorphedImageSize(&image_size)!=TRUE) {
- LOG_ERROR("Couldn't get size of morphed image!\n");
- return -EIO;
- }
- if(offset>=image_size) {
- // Offset is beyond image size
- LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
- *p_written=0;
- return 0;
- }
- if(offset+count>image_size) {
- // Attempt to write data past EOF of morphed image file
- to_write=image_size-offset;
- LOG_DEBUG("Attempt to write data past EOF of morphed image. Corrected size "
- "from %zu to %" PRIu64 ".\n",
- count,
- to_write);
- } else to_write=count;
-
- // Calculate block to start writing data to
- cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
- block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
-
- while(to_write!=0) {
- // Calculate how many bytes we have to write to this block
- if(block_off+to_write>XMOUNT_CACHE_BLOCK_SIZE) {
- cur_to_write=XMOUNT_CACHE_BLOCK_SIZE-block_off;
- } else cur_to_write=to_write;
-
- // Determine if block is already in cache
- is_block_cached=FALSE;
- cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
- if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
- else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
- LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
- "Error code %u!\n",
- cur_block,
- cache_ret);
- return -EIO;
- }
-
- // Check if block is cached
- if(is_block_cached==TRUE) {
- // Block is cached
- cache_ret=XmountCache_BlockCacheWrite(glob_xmount.h_cache,
- p_buf,
- cur_block,
- block_off,
- cur_to_write);
- if(cache_ret!=e_XmountCache_Error_None) {
- LOG_ERROR("Unable to write %" PRIu64
- " bytes of data to cache block %" PRIu64
- " at cache block offset %" PRIu64 ": Error code %u!\n",
- cur_to_write,
- cur_block,
- block_off,
- cache_ret);
- return -EIO;
- }
-
- LOG_DEBUG("Wrote %" PRIu64 " bytes to block cache\n",cur_to_write);
- } else {
- // Uncached block. Need to cache entire new block
- // Prepare new write buffer
- XMOUNT_MALLOC(p_buf2,char*,XMOUNT_CACHE_BLOCK_SIZE);
- memset(p_buf2,0x00,XMOUNT_CACHE_BLOCK_SIZE);
-
- // Read full block from morphed image
- cur_to_read=XMOUNT_CACHE_BLOCK_SIZE;
- if((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+XMOUNT_CACHE_BLOCK_SIZE>image_size) {
- cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-(((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
- XMOUNT_CACHE_BLOCK_SIZE)-image_size);
- }
- ret=glob_xmount.morphing.p_functions->Read(glob_xmount.morphing.p_handle,
- p_buf2,
- cur_block*XMOUNT_CACHE_BLOCK_SIZE,
- cur_to_read,
- &read);
- if(ret!=0 || read!=cur_to_read) {
- LOG_ERROR("Couldn't read %" PRIu64 " bytes at offset %zu "
- "from morphed image: %s!\n",
- cur_to_read,
- offset,
- glob_xmount.morphing.p_functions->GetErrorMessage(ret));
- XMOUNT_FREE(p_buf2);
- return -EIO;
- }
-
- // Set changed data
- memcpy(p_buf2+block_off,p_buf,cur_to_write);
-
- cache_ret=XmountCache_BlockCacheAppend(glob_xmount.h_cache,
- p_buf,
- cur_block);
- if(cache_ret!=e_XmountCache_Error_None) {
- LOG_ERROR("Unable to append new block cache block %" PRIu64
- ": Error code %u!\n",
- cur_block,
- cache_ret);
- XMOUNT_FREE(p_buf2);
- return -EIO;
- }
- XMOUNT_FREE(p_buf2);
-
- LOG_DEBUG("Appended new block cache block %" PRIu64 "\n",cur_block);
- }
-
- block_off=0;
- cur_block++;
- p_buf+=cur_to_write;
- to_write-=cur_to_write;
- }
-
- *p_written=to_write;
- return TRUE;
+ return e_XmountMorphError_UnsupportedType;
}
-*/
diff --git a/src/xmount_morphing.h b/src/xmount_morphing.h
index bd98b7a..1d6c82c 100644
--- a/src/xmount_morphing.h
+++ b/src/xmount_morphing.h
@@ -1,342 +1,343 @@
/*******************************************************************************
* 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_MORPHING_H
#define XMOUNT_MORPHING_H
/*******************************************************************************
* Public definitions / macros
******************************************************************************/
-//! Naming scheme of input libraries
+//! Naming scheme of morphing libraries
#define XMOUNT_MORPHING_LIBRARY_NAMING_SCHEME "libxmount_morph_"
/*******************************************************************************
* Public types / structures / enums
******************************************************************************/
//! Morphing handle
typedef struct s_XmountMorphHandle *pts_XmountMorphHandle;
/*!
* \brief Function to get the amount of input images
*
* Function to get the amount of input images
*
* \param p_count Count of input images
* \return 0 on success
*/
typedef int (*tfun_XmountMorphing_InputImageCount)(uint64_t *p_count);
/*!
* \brief Function to get the size of the morphed data
*
* 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
*/
typedef int (*tfun_XmountMorphing_InputImageSize)(uint64_t image, uint64_t *p_size);
//! 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
*/
typedef int (*tfun_XmountMorphing_InputImageRead)(uint64_t image,
char *p_buf,
off_t offset,
size_t count,
size_t *p_read);
//! Function to write data to 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
*/
typedef int (*tfun_XmountMorphing_InputImageWrite)(uint64_t image,
char *p_buf,
off_t offset,
size_t count,
size_t *p_written);
typedef enum e_XmountMorphError {
//! No error
e_XmountMorphError_None=0,
//! Error to allocate memory
e_XmountMorphError_Alloc,
- //! Invalid input handle
+ //! Invalid morphing handle
e_XmountMorphError_InvalidHandle,
- //! Invalid pointer to an input handle
+ //! Invalid pointer to a morphing handle
e_XmountMorphError_InvalidHandlePointer,
//! A given buffer is invalid
e_XmountMorphError_InvalidBuffer,
//! A given string is invalid
e_XmountMorphError_InvalidString,
- //! A given array is invalid
- //e_XmountMorphError_InvalidArray,
//! Library options have already been set
e_XmountMorphError_LibOptionsAlreadySet,
//! Library options couldn't be parsed
e_XmountMorphError_FailedParsingOptions,
//! Unable to get info file content from library
e_XmountMorphError_FailedGettingInfoFileContent,
//! Unable to load library file
e_XmountMorphError_FailedLoadingLibrary,
//! Unable to load a library symbol
e_XmountMorphError_FailedLoadingSymbol,
//! Library has wrong API version
e_XmountMorphError_WrongLibraryApiVersion,
//! Library is missing a function
e_XmountMorphError_MissingLibraryFunction,
//! Unsupported morphing type
- e_XmountInput_Error_UnsupportedType,
-/*
- //! Specified image number is incorrect
- e_XmountInput_Error_NoSuchImage,
- //! Unable to create input image handle
- e_XmountInput_Error_FailedCreatingImageHandle,
- //! Unable to parse input library options
- e_XmountInput_Error_FailedParsingLibParams,
- //! Unable to open input image
- e_XmountInput_Error_FailedOpeningImage,
-*/
+ e_XmountMorphError_UnsupportedType,
+ //! Unable to create morphing image handle
+ e_XmountMorphError_FailedCreatingMorphHandle,
+ //! Unable to parse morphing library options
+ e_XmountMorphError_FailedParsingLibParams,
//! Unable to get image size
e_XmountMorphError_FailedGettingImageSize,
-/*
- //! A specified offset is larger than a specified image
- e_XmountInput_Error_OffsetExceedsImageSize,
- //! A specified size limit is larger than a specified image
- e_XmountInput_Error_SizelimitExceedsImageSize,
- //! Unable to read data from input image
- e_XmountInput_Error_FailedReadingData
-*/
+ //! A specified offset is larger than the image
+ e_XmountMorphError_OffsetExceedsImageSize,
+ //! Unable to read data from morphed image
+ e_XmountMorphError_FailedReadingData
} te_XmountMorphError;
/*******************************************************************************
* Public functions declarations
******************************************************************************/
/*!
- * \brief Create new input handle
+ * \brief Create new morphing handle
*
- * Creates a new input handle.
+ * Creates a new morphing handle.
*
- * \param pp_h Pointer to input handle
- * \return e_XmountInput_Error_None on success
+ * \param pp_h Pointer to morphing handle
+ * \return e_XmountMorphError_None on success
*/
-te_XmountMorphError XmountMorphing_CreateHandle(pts_XmountMorphHandle *pp_h,
- tfun_XmountMorphing_InputImageCount fun_image_count,
- tfun_XmountMorphing_InputImageSize fun_image_size,
- tfun_XmountMorphing_InputImageRead fun_image_read,
- tfun_XmountMorphing_InputImageWrite fun_image_write);
+te_XmountMorphError
+ XmountMorphing_CreateHandle(pts_XmountMorphHandle *pp_h,
+ tfun_XmountMorphing_InputImageCount p_img_count,
+ tfun_XmountMorphing_InputImageSize p_img_size,
+ tfun_XmountMorphing_InputImageRead p_img_read,
+ tfun_XmountMorphing_InputImageWrite p_img_write);
/*!
- * \brief Destroy input handle
+ * \brief Destroy morphing handle
*
* Invalidates the given handle and frees all used resources.
*
- * \param pp_h Pointer to input handle
- * \return e_XmountInput_Error_None on success
+ * \param pp_h Pointer to morphing handle
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_DestroyHandle(pts_XmountMorphHandle *pp_h);
/*!
* \brief Enable internal debugging
*
* Enables the generation of intrernal debugging messages.
*
- * \param p_h Input handle
- * \return e_XmountInput_Error_None on success
+ * \param p_h Morphing handle
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_EnableDebugging(pts_XmountMorphHandle p_h);
/*!
- * \brief Load an input library
+ * \brief Load a morphing library
*
- * Loads a given input library.
+ * Loads a given morphing library.
*
- * \param p_h Input handle
+ * \param p_h Morphing handle
* \param p_lib Library name (without path)
- * \return e_XmountInput_Error_None on success
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_AddLibrary(pts_XmountMorphHandle p_h,
const char *p_lib_name);
/*!
- * \brief Get loaded input library count
+ * \brief Get loaded morphing library count
*
- * Returns the number of successfully loaded input libraries.
+ * Returns the number of successfully loaded morphing libraries.
*
- * \param p_h Input handle
+ * \param p_h Morphing handle
* \param p_count Library count is returned in this variable
- * \return e_XmountInput_Error_None on success
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_GetLibraryCount(pts_XmountMorphHandle p_h,
uint32_t *p_count);
/*!
* \brief Return all supported morphing types
*
* Returns a null-terminated vector of all supported morphing types.
*
* The returned vector must be freed by the caller.
*
* \param p_h Morphing handle
* \param pp_types Supported types vector is returned in this var
* \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_GetSupportedTypes(pts_XmountMorphHandle p_h,
char **pp_types);
/*!
* \brief Set library options
*
* Parses the given library option string (as given after --inopts).
*
- * \param p_h Input handle
+ * \param p_h Morphing handle
* \param p_options Library option string
- * \return e_XmountInput_Error_None on success
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_SetOptions(pts_XmountMorphHandle 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.
+ * Returns a string containing help messages for all loaded morphing 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 p_h Morphing handle
* \param pp_help_text Help text is returned in this parameter
- * \return e_XmountInput_Error_None on success
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_GetOptionsHelpText(pts_XmountMorphHandle p_h,
char **pp_help_text);
/*!
* \brief Returns a string containing infos about loaded libs
*
- * Returns a string containing infos about loaded input libraries. The string is
- * pre-formated to be used in xmount's info output.
+ * Returns a string containing infos about loaded morphing 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 p_h Morphing handle
* \param pp_info_text Info text is returned in this parameter
- * \return e_XmountInput_Error_None on success
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_GetLibsInfoText(pts_XmountMorphHandle p_h,
char **pp_info_text);
/*!
* \brief Set morphing type
*
* Set the morphing type that should be applied to the input image.
*
- * \param p_h Input handle
+ * \param p_h Morphing handle
* \param p_type Morphing type string as specified with xmount's --morph option.
* \return e_XmountMorphError_None on success
*/
-te_XmountMorphError XmountMorphing_SaetType(pts_XmountMorphHandle p_h,
- char *p_type);
+te_XmountMorphError XmountMorphing_SetType(pts_XmountMorphHandle p_h,
+ char *p_type);
/*!
- * \brief Opens all added input images
+ * \brief Start the morphing process
*
- * Opens all added input images.
+ * Begins the morphing process.
*
- * \param p_h Input handle
- * \return e_XmountInput_Error_None on success
+ * \param p_h Morphing handle
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_StartMorphing(pts_XmountMorphHandle p_h);
/*!
- * \brief Closes all previously opened input images
+ * \brief Stop the morphing process
*
- * Closes all previously opened input images.
+ * Ends the morphing process.
*
- * \param p_h Input handle
- * \return e_XmountInput_Error_None on success
+ * \param p_h Morphing handle
+ * \return e_XmountMorphError_None on success
*/
-te_XmountMorphError XmountInput_StopMorphing(pts_XmountMorphHandle p_h);
+te_XmountMorphError XmountMorphing_StopMorphing(pts_XmountMorphHandle p_h);
/*!
- * \brief Get the size of an input image
+ * \brief Get the size of the morphed image
*
- * Returns the size (in bytes) of the specified input image.
+ * Returns the size (in bytes) of the morphed image.
*
- * \param p_h Input handle
+ * \param p_h Morphing handle
* \param image_nr Image number for which to return the size
* \param p_size On success, size is returned in this variable
- * \return e_XmountInput_Error_None on success
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_GetSize(pts_XmountMorphHandle p_h,
uint64_t *p_size);
/*!
- * \brief Read data from an input image
+ * \brief Read data from the morphed image
*
- * Reads count bytes from input image image_nr starting at given offset and
+ * Reads count bytes from the morphed image starting at given offset and
* copies the data into p_buf.
*
* The given buffer must be pre-allocated to hold as many bytes as should be
* read!
*
- * \param p_h Input handle
- * \param image_nr Image number for which to return the size
+ * \param p_h Morphing handle
* \param p_buf Buffer into which to copy read data
* \param offset Offset at which to start reading
* \param count Amount of bytes to read
* \param p_read On success, amount of bytes read is returned in this variable
- * \return e_XmountInput_Error_None on success
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_ReadData(pts_XmountMorphHandle p_h,
char *p_buf,
uint64_t offset,
uint64_t count,
uint64_t *p_read);
+/*!
+ * \brief Writes data to the morphed image
+ *
+ * Writes count bytes from p_buf to the morphed image starting at the given
+ * offset.
+ *
+ * \param p_h Morphing handle
+ * \param p_buf Buffer with data to write
+ * \param offset Offset at which to start writing
+ * \param count Amount of bytes to write
+ * \param p_written On success, amount of bytes written is returned here
+ * \return e_XmountMorphError_None on success
+ */
te_XmountMorphError XmountMorphing_WriteData(pts_XmountMorphHandle p_h,
const char *p_buf,
uint64_t offset,
- uint64_t count);
+ uint64_t count,
+ uint64_t *p_written);
/*!
* \brief Get info text to be added to xmount's info file
*
- * Generates a string containing informations about currently opened input
- * images.
+ * Generates a string containing informations about the currently morphed image.
*
* The caller must free the returned string.
*
- * \param p_h Input handle
+ * \param p_h Morphing handle
* \param pp_content Buffer in which text is returned
- * \return e_XmountInput_Error_None on success
+ * \return e_XmountMorphError_None on success
*/
te_XmountMorphError XmountMorphing_GetInfoFileContent(pts_XmountMorphHandle p_h,
char **pp_content);
#endif // XMOUNT_MORPHING_H
File Metadata
Details
Attached
Mime Type
text/x-diff
Expires
Mon, Dec 23, 10:55 AM (1 h, 5 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1176891
Default Alt Text
(126 KB)
Attached To
Mode
rXMOUNT xmount
Attached
Detach File
Event Timeline
Log In to Comment