struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
{
struct file * f;
struct inode *inode;
int error;
error = -ENFILE;
f = get_empty_filp();
if (!f)
goto cleanup_dentry;
f->f_flags = flags;
f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;
inode = dentry->d_inode;
if (f->f_mode & FMODE_WRITE) {
error = get_write_access(inode);
if (error)
goto cleanup_file;
}
f->f_mapping = inode->i_mapping;
f->f_dentry = dentry;
f->f_vfsmnt = mnt;
f->f_pos = 0;
f->f_op = fops_get(inode->i_fop);
file_move(f, &inode->i_sb->s_files);
if (f->f_op && f->f_op->open) {
error = f->f_op->open(inode,f);
if (error)
goto cleanup_all;
}
f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
/* NB: we're sure to have correct a_ops only after f_op->open */
if (f->f_flags & O_DIRECT) {
if (!f->f_mapping->a_ops || !f->f_mapping->a_ops->direct_IO) {
fput(f);
f = ERR_PTR(-EINVAL);
}
}
return f;
cleanup_all:
fops_put(f->f_op);
if (f->f_mode & FMODE_WRITE)
put_write_access(inode);
file_kill(f);
f->f_dentry = NULL;
f->f_vfsmnt = NULL;
cleanup_file:
put_filp(f);
cleanup_dentry:
dput(dentry);
mntput(mnt);
return ERR_PTR(error);
}
static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
int flags, struct file *f,
int (*open)(struct inode *, struct file *),
const struct cred *cred)
{
struct inode *inode;
int error;
f->f_flags = flags;
f->f_mode = (__force fmode_t)((flags+1) & O_ACCMODE) | FMODE_LSEEK |
FMODE_PREAD | FMODE_PWRITE;
inode = dentry->d_inode;
if (f->f_mode & FMODE_WRITE) {
error = __get_file_write_access(inode, mnt);
if (error)
goto cleanup_file;
if (!special_file(inode->i_mode))
file_take_write(f);
}
f->f_mapping = inode->i_mapping;
f->f_path.dentry = dentry;
f->f_path.mnt = mnt;
f->f_pos = 0;
f->f_op = fops_get(inode->i_fop);
file_move(f, &inode->i_sb->s_files);
error = security_dentry_open(f, cred);
if (error)
goto cleanup_all;
if (!open && f->f_op)
open = f->f_op->open;
if (open) {
error = open(inode, f);
if (error)
goto cleanup_all;
}
f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
/* NB: we're sure to have correct a_ops only after f_op->open */
if (f->f_flags & O_DIRECT) {
if (!f->f_mapping->a_ops ||
((!f->f_mapping->a_ops->direct_IO) &&
(!f->f_mapping->a_ops->get_xip_mem))) {
fput(f);
f = ERR_PTR(-EINVAL);
}
}
return f;
cleanup_all:
fops_put(f->f_op);
if (f->f_mode & FMODE_WRITE) {
put_write_access(inode);
if (!special_file(inode->i_mode)) {
/*
* We don't consider this a real
* mnt_want/drop_write() pair
* because it all happenend right
* here, so just reset the state.
*/
file_reset_write(f);
mnt_drop_write(mnt);
}
}
file_kill(f);
f->f_path.dentry = NULL;
f->f_path.mnt = NULL;
cleanup_file:
put_filp(f);
dput(dentry);
mntput(mnt);
return ERR_PTR(error);
}
static struct file *__dentry_open(struct _dentry *dentry, struct vfsmount *mnt,
int flags, struct file *f,
int (*open)(struct _inode *, struct file *))
{
struct _inode *inode;
int error;
struct super_block *sb;
struct _file *_f = tx_cache_get_file(f);
_f->f_flags = flags;
_f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK |
FMODE_PREAD | FMODE_PWRITE;
inode = d_get_inode(dentry);
sb = inode->i_sb;
if (_f->f_mode & FMODE_WRITE) {
error = get_write_access(parent(inode));
if (error)
goto cleanup_file;
}
f->f_mapping = inode->i_mapping;
_f->f_path.dentry = parent(dentry);
_f->f_path.mnt = mnt;
_f->f_pos = 0;
f->f_op = fops_get(inode->i_fop);
file_move(f, &sb->s_files);
if (!open && f->f_op)
open = f->f_op->open;
if (open) {
error = open(inode, f);
if (error)
goto cleanup_all;
}
_f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
file_ra_state_init(&f->f_ra,
tx_cache_get_inode(f->f_mapping->host)->i_mapping);
/* NB: we're sure to have correct a_ops only after f_op->open */
if (_f->f_flags & O_DIRECT) {
if (!f->f_mapping->a_ops ||
((!f->f_mapping->a_ops->direct_IO) &&
(!f->f_mapping->a_ops->get_xip_page))) {
fput(f);
f = ERR_PTR(-EINVAL);
}
}
return f;
cleanup_all:
fops_put(f->f_op);
if (_f->f_mode & FMODE_WRITE)
put_write_access(parent(inode));
file_kill(f);
_f->f_path.dentry = NULL;
_f->f_path.mnt = NULL;
cleanup_file:
/* Avoid issues if we recycle this object */
if(live_transaction())
early_release(&f->xobj, 1);
put_filp(f);
dput(parent(dentry));
mntput(mnt);
return ERR_PTR(error);
}
int main(int argc, char *argv[])
{
int len = strlen(argv[1]);
char fileInput[len + 1];
strcpy(fileInput, argv[1]);
int countFiles = argc - 1;
char *fileName = strtok(fileInput, ".");
char *extension = strtok(NULL, ".");
int extLen = strlen(extension);
char outName[] = "merged.";
strcat(outName, extension);
FILE *result = fopen(outName, "w");
if (!result)
{
kill(NULL);
}
char buffer[BUFFER_SIZE];
char apple[4] = {0x33, 0x34, 0x35, 0x36};
char leaf[4] = {0x21, 0x22, 0x23, 0x24};
int i;
for (i = 1; i <= countFiles; i++)
{
FILE *currentPart = fopen(argv[i], "r");
if (!currentPart)
{
file_kill(result, outName, argv[i]);
}
while (1)
{
size_t readBytes = fread(buffer, 1, BUFFER_SIZE, currentPart);
if (0 == readBytes)
{
break;
}
size_t writtenBytes;
char *curreentSign = buffer + readBytes -4;
if (0 == memcmp(curreentSign, apple, 4))
{
writtenBytes = fwrite(buffer, 1 ,readBytes - 4, result);
}
else if(0 == memcmp(curreentSign, leaf, 4))
{
writtenBytes = fwrite(buffer, 1 ,(readBytes - 4) / 2, result);
}
else
{
continue;
}
if (0 == writtenBytes)
{
break;
}
}
if (ferror(currentPart))
{
fclose((currentPart));
file_kill(result, outName, "Error reading from part\n");
}
if (ferror(result))
{
fclose(currentPart);
file_kill(result, outName, "Error writing to result\n");
}
fclose(currentPart);
}
fclose(result);
printf("Done!");
return 0;
}