static
void test_static_v1_input_short(void)
{
ssize_t siz;
const struct hash_method *hash = hash_method_lookup("sha256");
unsigned char hash_ctx[hash->context_size];
unsigned char hash_dgst[hash->digest_size];
hash->init(hash_ctx);
test_begin("test_static_v1_input_short");
struct istream *is_1 = i_stream_create_file(DCRYPT_SRC_DIR"/sample-v1_short.asc", IO_BLOCK_SIZE);
struct istream *is_2 = i_stream_create_base64_decoder(is_1);
i_stream_unref(&is_1);
struct istream *is_3 = i_stream_create_decrypt(is_2, test_v1_kp.priv);
i_stream_unref(&is_2);
struct istream *is_4 = i_stream_create_hash(is_3, hash, hash_ctx);
i_stream_unref(&is_3);
while((siz = i_stream_read(is_4))>0) { i_stream_skip(is_4, siz); }
if (is_4->stream_errno != 0)
i_debug("error: %s", i_stream_get_error(is_4));
test_assert(is_4->stream_errno == 0);
i_stream_unref(&is_4);
hash->result(hash_ctx, hash_dgst);
test_assert(strcmp(test_sample_v1_short_hash, binary_to_hex(hash_dgst, sizeof(hash_dgst))) == 0);
test_end();
}
static int fts_filter_stopwords_read_list(struct fts_filter_stopwords *filter,
const char **error_r)
{
struct istream *input;
const char *line, **words, *path;
int ret = 0;
path = t_strdup_printf(STOPWORDS_FILE_FORMAT,
filter->stopwords_dir, filter->lang->name);
input = i_stream_create_file(path, IO_BLOCK_SIZE);
while ((line = i_stream_read_next_line(input)) != NULL) T_BEGIN {
line = t_strcut(line, STOPWORDS_COMMENT_CHAR1);
line = t_strcut(line, STOPWORDS_COMMENT_CHAR2);
words = t_strsplit_spaces(line, " \t");
for (; *words != NULL; words++) {
const char *word = p_strdup(filter->pool, *words);
hash_table_insert(filter->stopwords, word, word);
}
} T_END;
if (input->stream_errno != 0) {
*error_r = t_strdup_printf("Failed to read stopword list %s: %s",
path, i_stream_get_error(input));
ret = -1;
}
i_stream_destroy(&input);
return ret;
}
static
void test_static_v2_input(void)
{
test_begin("test_static_v2_input");
ssize_t amt;
const struct hash_method *hash = hash_method_lookup("sha256");
unsigned char hash_ctx[hash->context_size];
unsigned char hash_dgst[hash->digest_size];
hash->init(hash_ctx);
struct istream *is_1 = i_stream_create_file(DCRYPT_SRC_DIR"/sample-v2.asc", IO_BLOCK_SIZE);
struct istream *is_2 = i_stream_create_base64_decoder(is_1);
i_stream_unref(&is_1);
struct istream *is_3 = i_stream_create_decrypt(is_2, test_v2_kp.priv);
i_stream_unref(&is_2);
struct istream *is_4 = i_stream_create_hash(is_3, hash, hash_ctx);
i_stream_unref(&is_3);
while((amt = i_stream_read(is_4))>0) { i_stream_skip(is_4, amt); }
if (is_4->stream_errno != 0)
i_debug("error: %s", i_stream_get_error(is_4));
test_assert(is_4->stream_errno == 0);
i_stream_unref(&is_4);
hash->result(hash_ctx, hash_dgst);
test_assert(strcmp(test_sample_v2_hash, binary_to_hex(hash_dgst, sizeof(hash_dgst))) == 0);
test_end();
/** this code is left here to show how the sample file is created
struct istream *is = i_stream_create_file("../lib-fts/udhr_fra.txt", 8192);
struct istream *is_2 = i_stream_create_hash(is, hash, hash_ctx);
int fd = open("sample-v2.bin", O_CREAT|O_TRUNC|O_WRONLY, S_IRWXU);
struct ostream *os = o_stream_create_fd_file(fd, 0, TRUE);
struct ostream *os_2 = o_stream_create_encrypt(os, "aes-256-gcm-sha256", test_v2_kp.pub, IO_STREAM_ENC_INTEGRITY_AEAD);
const unsigned char *ptr;
size_t siz;
while(i_stream_read_data(is_2, &ptr, &siz, 0)>0) {
o_stream_nsend(os_2, ptr, siz);
i_stream_skip(is_2, siz);
}
i_assert(o_stream_nfinish(os_2)==0);
o_stream_close(os_2);
i_stream_close(is_2);
hash->result(hash_ctx, hash_dgst);
printf("%s\n", binary_to_hex(hash_dgst, sizeof(hash_dgst)));
*/
}
static int test_input_file(const char *path)
{
struct istream *file_input, *input, *input2;
const unsigned char *data;
size_t size;
struct sha1_ctxt hash;
unsigned char hash_file[SHA1_RESULTLEN], hash_converter[SHA1_RESULTLEN];
int ret = 0;
lib_init();
file_input = i_stream_create_file(path, 64);
/* get hash when directly reading input */
input = i_stream_create_crlf(file_input);
sha1_init(&hash);
while (i_stream_read_data(input, &data, &size, 0) > 0) {
sha1_loop(&hash, data, size);
i_stream_skip(input, size);
}
sha1_result(&hash, hash_file);
i_stream_unref(&input);
/* get hash when going through converter */
i_stream_seek(file_input, 0);
input = i_stream_create_crlf(file_input);
input2 = i_stream_create_binary_converter(input);
sha1_init(&hash);
while (i_stream_read_data(input2, &data, &size, 0) > 0) {
sha1_loop(&hash, data, size);
i_stream_skip(input2, size);
}
sha1_result(&hash, hash_converter);
i_stream_unref(&input2);
i_stream_unref(&input);
if (memcmp(hash_file, hash_converter, SHA1_RESULTLEN) != 0) {
fprintf(stderr, "istream-binary-converter: mismatch on file %s\n",
path);
ret = 1;
}
i_stream_unref(&file_input);
lib_deinit();
return ret;
}
static int fs_crypt_read_file(const char *set_name, const char *path,
char **key_data_r, const char **error_r)
{
struct istream *input;
int ret;
input = i_stream_create_file(path, (size_t)-1);
while (i_stream_read(input) > 0) ;
if (input->stream_errno != 0) {
*error_r = t_strdup_printf("%s: read(%s) failed: %s",
set_name, path, i_stream_get_error(input));
ret = -1;
} else {
size_t size;
const unsigned char *data = i_stream_get_data(input, &size);
*key_data_r = i_strndup(data, size);
ret = 0;
}
i_stream_unref(&input);
return ret;
}
