static void fs_sis_write_stream(struct fs_file *_file)
{
struct sis_fs_file *file = (struct sis_fs_file *)_file;
i_assert(_file->output == NULL);
file->fs_output = fs_write_stream(file->super);
if (file->hash_input == NULL)
_file->output = file->fs_output;
else {
/* compare if files are equal */
_file->output = o_stream_create_cmp(file->fs_output,
file->hash_input);
}
}
static void test_fs_metawrap_write_empty(void)
{
struct fs *fs;
const char *error;
test_begin("fs metawrap write empty file");
if (fs_init("metawrap", "test", &fs_set, &fs, &error) < 0)
i_fatal("fs_init() failed: %s", error);
struct fs_file *file = fs_file_init(fs, "foo", FS_OPEN_MODE_REPLACE);
struct ostream *output = fs_write_stream(file);
test_assert(fs_write_stream_finish(file, &output) > 0);
fs_file_deinit(&file);
fs_deinit(&fs);
test_end();
}
static int fs_crypt_write_stream_finish(struct fs_file *_file, bool success)
{
struct crypt_fs_file *file = (struct crypt_fs_file *)_file;
struct istream *input;
int ret;
if (_file->output != NULL) {
if (_file->output == file->super_output)
_file->output = NULL;
else
o_stream_unref(&_file->output);
}
if (!success) {
if (file->super_output != NULL) {
/* no encryption */
i_assert(file->temp_output == NULL);
fs_write_stream_abort_error(_file->parent, &file->super_output,
"write(%s) failed: %s",
o_stream_get_name(file->super_output),
o_stream_get_error(file->super_output));
} else if (file->temp_output != NULL) {
o_stream_destroy(&file->temp_output);
}
return -1;
}
if (file->super_output != NULL) {
/* no encrypt */
i_assert(file->temp_output == NULL);
return fs_write_stream_finish(_file->parent, &file->super_output);
}
if (file->temp_output == NULL) {
/* finishing up */
i_assert(file->super_output == NULL);
return fs_write_stream_finish_async(_file->parent);
}
/* finish writing the temporary file */
input = iostream_temp_finish(&file->temp_output, IO_BLOCK_SIZE);
file->super_output = fs_write_stream(_file->parent);
o_stream_nsend_istream(file->super_output, input);
ret = fs_write_stream_finish(_file->parent, &file->super_output);
i_stream_unref(&input);
return ret;
}
static void test_fs_async_write(const char *test_name, struct fs *fs)
{
struct fs_file *file;
struct test_fs_file *test_file;
struct ostream *output;
unsigned int i;
test_begin(t_strdup_printf("%s: async write", test_name));
for (i = 0; i < 3; i++) {
file = fs_file_init(fs, "foo", FS_OPEN_MODE_REPLACE |
FS_OPEN_FLAG_ASYNC);
output = fs_write_stream(file);
o_stream_nsend_str(output, "12345");
if (i < 2) {
test_assert(fs_write_stream_finish(file, &output) == 0);
test_assert(output == NULL);
test_assert(fs_write_stream_finish_async(file) == 0);
}
test_file = test_fs_file_get(fs, "foo");
test_file->wait_async = FALSE;
switch (i) {
case 0:
test_assert(fs_write_stream_finish_async(file) > 0);
test_assert(test_file->contents->used > 0);
break;
case 1:
test_file->io_failure = TRUE;
test_assert(fs_write_stream_finish_async(file) < 0);
test_assert(test_file->contents->used == 0);
break;
case 2:
fs_write_stream_abort_error(file, &output, "test");
test_assert(test_file->contents->used == 0);
break;
}
fs_file_deinit(&file);
}
test_end();
}
static int fs_compress_write_stream_finish(struct fs_file *_file, bool success)
{
struct compress_fs_file *file = (struct compress_fs_file *)_file;
struct istream *input;
int ret;
if (_file->output != NULL) {
if (_file->output->closed)
success = FALSE;
if (_file->output == file->super_output)
_file->output = NULL;
else
o_stream_unref(&_file->output);
}
if (!success) {
if (file->temp_output != NULL)
o_stream_destroy(&file->temp_output);
if (file->super_output != NULL)
fs_write_stream_abort(_file->parent, &file->super_output);
return -1;
}
if (file->super_output != NULL) {
i_assert(file->temp_output == NULL);
return fs_write_stream_finish(_file->parent, &file->super_output);
}
if (file->temp_output == NULL) {
/* finishing up */
i_assert(file->super_output == NULL);
return fs_write_stream_finish(_file->parent, &file->temp_output);
}
/* finish writing the temporary file */
input = iostream_temp_finish(&file->temp_output, IO_BLOCK_SIZE);
file->super_output = fs_write_stream(_file->parent);
o_stream_nsend_istream(file->super_output, input);
ret = fs_write_stream_finish(_file->parent, &file->super_output);
i_stream_unref(&input);
return ret;
}
static void fs_crypt_write_stream(struct fs_file *_file)
{
struct crypt_fs_file *file = (struct crypt_fs_file *)_file;
const char *error;
i_assert(_file->output == NULL);
if (fs_crypt_load_keys(file->fs, &error) < 0) {
_file->output = o_stream_create_error_str(EIO,
"Couldn't read settings: %s", error);
return;
}
if (file->fs->keys.public_key == NULL) {
if (_file->fs->set.debug)
i_debug("No public key provided, "
"NOT encrypting stream %s",
fs_file_path(_file));
file->super_output = fs_write_stream(_file->parent);
_file->output = file->super_output;
return;
}
enum io_stream_encrypt_flags flags;
if (strstr(file->fs->enc_algo, "gcm") != NULL ||
strstr(file->fs->enc_algo, "ccm") != NULL) {
flags = IO_STREAM_ENC_INTEGRITY_AEAD;
} else {
flags = IO_STREAM_ENC_INTEGRITY_HMAC;
}
file->temp_output =
iostream_temp_create_named(_file->fs->temp_path_prefix,
IOSTREAM_TEMP_FLAG_TRY_FD_DUP,
fs_file_path(_file));
_file->output = o_stream_create_encrypt(file->temp_output,
file->fs->enc_algo, file->fs->keys.public_key,
flags);
}
