rpms/dovecot
7
0
Fork 0
Code Issues Pull Requests Releases Activity
a520dff18f
dovecot/dovecot-a744ae38a9e1.patch
Tomas Janousek b1451a6432 - update to a744ae38a9e1 from hg 
- update dovecot-sieve to 131e25f6862b from hg and enable it again
2007-07-25 11:02:09 +00:00

4504 lines
150 KiB
Diff
Raw Blame History

diff --git a/NEWS b/NEWS
index 2251856..954db2b 100644
--- a/NEWS
+++ b/NEWS
@@ -15,7 +15,7 @@ v1.1.UNSTABLE
It's similar to REFERENCES, but it doesn't do base subject merging
and it sorts the threads by their newest message.
+ When saving messages, update cache file immediately with the data
- that we expect client to fetch later. Maildir-only currently.
+ that we expect client to fetch later.
+ NFS attribute and data caches are are flushed whenever needed.
See mail_nfs_storage and mail_nfs_index settings.
+ Mailbox list indexes. Mailbox metadata is stored there, so STATUS
diff --git a/configure.in b/configure.in
index 156e9d7..3f93ca6 100644
--- a/configure.in
+++ b/configure.in
@@ -82,7 +82,7 @@ AC_ARG_WITH(passwd,
fi,
want_passwd=yes)
-AC_ARG_WITH(passwd,
+AC_ARG_WITH(nss,
[ --with-nss Build with NSS module support (default)],
if test x$withval = xno; then
want_nss=no
diff --git a/doc/dovecot-ldap-example.conf b/doc/dovecot-ldap-example.conf
index 334ae8f..62ec866 100644
--- a/doc/dovecot-ldap-example.conf
+++ b/doc/dovecot-ldap-example.conf
@@ -106,7 +106,8 @@ base = uid=someone, dc=foo, dc=bar, dc=org
# userdb prefetch instead of userdb ldap in dovecot.conf. In that case you'll
# also have to include user_attrs in pass_attrs field prefixed with "userdb_"
# string. For example:
-#pass_attrs = uid=user,userPassword=password,homeDirectory=userdb_home,uidNumber=userdb_uid,gidNumber=userdb_gid
+#pass_attrs = uid=user,userPassword=password,\
+# homeDirectory=userdb_home,uidNumber=userdb_uid,gidNumber=userdb_gid
# Filter for password lookups
#pass_filter = (&(objectClass=posixAccount)(uid=%u))
diff --git a/doc/dovecot-sql-example.conf b/doc/dovecot-sql-example.conf
index bfc4b82..55fc998 100644
--- a/doc/dovecot-sql-example.conf
+++ b/doc/dovecot-sql-example.conf
@@ -88,7 +88,9 @@
# password_query = SELECT concat(userid, '@', domain) AS user, password FROM users WHERE userid = '%n' AND domain = '%d'
# password_query = SELECT pw AS password FROM users WHERE userid = '%u' AND active = 'Y'
#
-#password_query = SELECT userid as user, password FROM users WHERE userid = '%u'
+#password_query = \
+# SELECT userid as user, password \
+# FROM users WHERE userid = '%u'
# Query to retrieve the user information.
#
@@ -114,4 +116,7 @@
# userdb prefetch instead of userdb sql in dovecot.conf. In that case you'll
# also have to return userdb fields in password_query prefixed with "userdb_"
# string. For example:
-#password_query = SELECT userid as user, password, home as userdb_home, uid as userdb_uid, gid as userdb_gid FROM users WHERE userid = '%u'
+#password_query = \
+# SELECT userid as user, password, \
+# home as userdb_home, uid as userdb_uid, gid as userdb_gid \
+# FROM users WHERE userid = '%u'
diff --git a/src/auth/auth-client-connection.c b/src/auth/auth-client-connection.c
index d596854..e913a2e 100644
--- a/src/auth/auth-client-connection.c
+++ b/src/auth/auth-client-connection.c
@@ -275,10 +275,9 @@ auth_client_connection_create(struct auth_master_listener *listener, int fd)
conn->fd = fd;
conn->input =
- i_stream_create_file(fd, default_pool,
- AUTH_CLIENT_MAX_LINE_LENGTH, FALSE);
+ i_stream_create_file(fd, AUTH_CLIENT_MAX_LINE_LENGTH, FALSE);
conn->output =
- o_stream_create_file(fd, default_pool, (size_t)-1, FALSE);
+ o_stream_create_file(fd, (size_t)-1, FALSE);
o_stream_set_flush_callback(conn->output, auth_client_output, conn);
conn->io = io_add(fd, IO_READ, auth_client_input, conn);
diff --git a/src/auth/auth-master-connection.c b/src/auth/auth-master-connection.c
index d18c70e..ddfe029 100644
--- a/src/auth/auth-master-connection.c
+++ b/src/auth/auth-master-connection.c
@@ -242,10 +242,8 @@ auth_master_connection_create(struct auth_master_listener *listener, int fd)
conn->listener = listener;
conn->refcount = 1;
conn->fd = fd;
- conn->input = i_stream_create_file(fd, default_pool,
- MAX_INBUF_SIZE, FALSE);
- conn->output = o_stream_create_file(fd, default_pool,
- (size_t)-1, FALSE);
+ conn->input = i_stream_create_file(fd, MAX_INBUF_SIZE, FALSE);
+ conn->output = o_stream_create_file(fd, (size_t)-1, FALSE);
o_stream_set_flush_callback(conn->output, master_output, conn);
conn->io = io_add(fd, IO_READ, master_input, conn);
diff --git a/src/auth/auth-worker-client.c b/src/auth/auth-worker-client.c
index 2fca127..58ba197 100644
--- a/src/auth/auth-worker-client.c
+++ b/src/auth/auth-worker-client.c
@@ -468,10 +468,9 @@ auth_worker_client_create(struct auth *auth, int fd)
client->auth = auth;
client->fd = fd;
client->input =
- i_stream_create_file(fd, default_pool,
- AUTH_WORKER_MAX_LINE_LENGTH, FALSE);
+ i_stream_create_file(fd, AUTH_WORKER_MAX_LINE_LENGTH, FALSE);
client->output =
- o_stream_create_file(fd, default_pool, (size_t)-1, FALSE);
+ o_stream_create_file(fd, (size_t)-1, FALSE);
o_stream_set_flush_callback(client->output, auth_worker_output, client);
client->io = io_add(fd, IO_READ, auth_worker_input, client);
diff --git a/src/auth/auth-worker-server.c b/src/auth/auth-worker-server.c
index 537650b..b36c61e 100644
--- a/src/auth/auth-worker-server.c
+++ b/src/auth/auth-worker-server.c
@@ -79,10 +79,9 @@ static struct auth_worker_connection *auth_worker_create(void)
conn = i_new(struct auth_worker_connection, 1);
conn->fd = fd;
- conn->input = i_stream_create_file(fd, default_pool,
- AUTH_WORKER_MAX_LINE_LENGTH, FALSE);
- conn->output =
- o_stream_create_file(fd, default_pool, (size_t)-1, FALSE);
+ conn->input = i_stream_create_file(fd, AUTH_WORKER_MAX_LINE_LENGTH,
+ FALSE);
+ conn->output = o_stream_create_file(fd, (size_t)-1, FALSE);
conn->io = io_add(fd, IO_READ, worker_input, conn);
conn->requests = buffer_create_dynamic(default_pool, 128);
diff --git a/src/auth/db-ldap.c b/src/auth/db-ldap.c
index 7b564d1..363461c 100644
--- a/src/auth/db-ldap.c
+++ b/src/auth/db-ldap.c
@@ -52,9 +52,11 @@ struct db_ldap_result_iterate_context {
char *attr, **vals;
const char *name, *value, *template, *val_1_arr[2];
+ const char *const *static_attrs;
BerElement *ber;
string_t *var, *debug;
+ unsigned int value_idx;
};
#define DEF_STR(name) DEF_STRUCT_STR(name, ldap_settings)
@@ -102,9 +104,9 @@ struct ldap_settings default_ldap_settings = {
MEMBER(scope) "subtree",
MEMBER(base) NULL,
MEMBER(ldap_version) 2,
- MEMBER(user_attrs) "uid,homeDirectory,,,uidNumber,gidNumber",
+ MEMBER(user_attrs) "homeDirectory=home,uidNumber=uid,gidNumber=gid",
MEMBER(user_filter) "(&(objectClass=posixAccount)(uid=%u))",
- MEMBER(pass_attrs) "uid,userPassword",
+ MEMBER(pass_attrs) "uid=user,userPassword=password",
MEMBER(pass_filter) "(&(objectClass=posixAccount)(uid=%u))",
MEMBER(default_pass_scheme) "crypt"
};
@@ -618,10 +620,10 @@ static void ldap_conn_close(struct ldap_connection *conn, bool flush_requests)
void db_ldap_set_attrs(struct ldap_connection *conn, const char *attrlist,
char ***attr_names_r, struct hash_table *attr_map,
- const char *const default_attr_map[],
const char *skip_attr)
{
const char *const *attr;
+ string_t *static_data;
char *name, *value, *p;
unsigned int i, j, size;
@@ -630,6 +632,7 @@ void db_ldap_set_attrs(struct ldap_connection *conn, const char *attrlist,
t_push();
attr = t_strsplit(attrlist, ",");
+ static_data = t_str_new(128);
/* @UNSAFE */
for (size = 0; attr[size] != NULL; size++) ;
@@ -637,13 +640,17 @@ void db_ldap_set_attrs(struct ldap_connection *conn, const char *attrlist,
for (i = j = 0; i < size; i++) {
p = strchr(attr[i], '=');
- if (p == NULL) {
- name = p_strdup(conn->pool, attr[i]);
- value = *default_attr_map == NULL ? name :
- p_strdup(conn->pool, *default_attr_map);
- } else {
+ if (p == NULL)
+ name = value = p_strdup(conn->pool, attr[i]);
+ else if (p != attr[i]) {
name = p_strdup_until(conn->pool, attr[i], p);
value = p_strdup(conn->pool, p + 1);
+ } else {
+ /* =<static key>=<static value> */
+ if (str_len(static_data) > 0)
+ str_append_c(static_data, ',');
+ str_append(static_data, p + 1);
+ continue;
}
if (*name != '\0' &&
@@ -651,9 +658,10 @@ void db_ldap_set_attrs(struct ldap_connection *conn, const char *attrlist,
hash_insert(attr_map, name, value);
(*attr_names_r)[j++] = name;
}
-
- if (*default_attr_map != NULL)
- default_attr_map++;
+ }
+ if (str_len(static_data) > 0) {
+ hash_insert(attr_map, "",
+ p_strdup(conn->pool, str_c(static_data)));
}
t_pop();
}
@@ -709,6 +717,7 @@ db_ldap_result_iterate_init(struct ldap_connection *conn, LDAPMessage *entry,
struct hash_table *attr_map)
{
struct db_ldap_result_iterate_context *ctx;
+ const char *static_data;
ctx = t_new(struct db_ldap_result_iterate_context, 1);
ctx->conn = conn;
@@ -716,6 +725,10 @@ db_ldap_result_iterate_init(struct ldap_connection *conn, LDAPMessage *entry,
ctx->auth_request = auth_request;
ctx->attr_map = attr_map;
+ static_data = hash_lookup(attr_map, "");
+ if (static_data != NULL)
+ ctx->static_attrs = t_strsplit(static_data, ",");
+
if (auth_request->auth->verbose_debug)
ctx->debug = t_str_new(256);
@@ -764,12 +777,13 @@ db_ldap_result_change_attr(struct db_ldap_result_iterate_context *ctx)
ctx->vals = ldap_get_values(ctx->conn->ld, ctx->entry,
ctx->attr);
ctx->value = ctx->vals[0];
+ ctx->value_idx = 0;
}
static void
db_ldap_result_return_value(struct db_ldap_result_iterate_context *ctx)
{
- bool first = ctx->value == ctx->vals[0];
+ bool first = ctx->value_idx == 0;
if (ctx->template != NULL) {
ctx->var_table[0].value = ctx->value;
@@ -791,6 +805,8 @@ db_ldap_result_return_value(struct db_ldap_result_iterate_context *ctx)
static bool db_ldap_result_int_next(struct db_ldap_result_iterate_context *ctx)
{
+ const char *p;
+
while (ctx->attr != NULL) {
if (ctx->vals == NULL) {
/* a new attribute */
@@ -798,7 +814,7 @@ static bool db_ldap_result_int_next(struct db_ldap_result_iterate_context *ctx)
} else {
/* continuing existing attribute */
if (ctx->value != NULL)
- ctx->value++;
+ ctx->value = ctx->vals[++ctx->value_idx];
}
if (ctx->value != NULL) {
@@ -812,6 +828,19 @@ static bool db_ldap_result_int_next(struct db_ldap_result_iterate_context *ctx)
ctx->ber);
}
+ if (ctx->static_attrs != NULL && *ctx->static_attrs != NULL) {
+ p = strchr(*ctx->static_attrs, '=');
+ if (p == NULL) {
+ ctx->name = *ctx->static_attrs;
+ ctx->value = "";
+ } else {
+ ctx->name = t_strdup_until(*ctx->static_attrs, p);
+ ctx->value = p + 1;
+ }
+ ctx->static_attrs++;
+ return TRUE;
+ }
+
db_ldap_result_iterate_finish(ctx);
return FALSE;
}
diff --git a/src/auth/db-ldap.h b/src/auth/db-ldap.h
index 621e8b9..36823c2 100644
--- a/src/auth/db-ldap.h
+++ b/src/auth/db-ldap.h
@@ -99,7 +99,6 @@ void db_ldap_search(struct ldap_connection *conn, struct ldap_request *request,
void db_ldap_set_attrs(struct ldap_connection *conn, const char *attrlist,
char ***attr_names_r, struct hash_table *attr_map,
- const char *const default_attr_map[],
const char *skip_attr);
struct ldap_connection *db_ldap_init(const char *config_path);
diff --git a/src/auth/db-passwd-file.c b/src/auth/db-passwd-file.c
index 74c1f3d..27ac55e 100644
--- a/src/auth/db-passwd-file.c
+++ b/src/auth/db-passwd-file.c
@@ -183,7 +183,7 @@ static bool passwd_file_open(struct passwd_file *pw)
pw->users = hash_create(default_pool, pw->pool, 100,
str_hash, (hash_cmp_callback_t *)strcmp);
- input = i_stream_create_file(pw->fd, default_pool, 4096, FALSE);
+ input = i_stream_create_file(pw->fd, 4096, FALSE);
while ((line = i_stream_read_next_line(input)) != NULL) {
if (*line == '\0' || *line == ':' || *line == '#')
continue; /* no username or comment */
diff --git a/src/auth/passdb-ldap.c b/src/auth/passdb-ldap.c
index 45db512..1d43851 100644
--- a/src/auth/passdb-ldap.c
+++ b/src/auth/passdb-ldap.c
@@ -15,10 +15,6 @@
#include <ldap.h>
#include <stdlib.h>
-static const char *default_attr_map[] = {
- "user", "password", NULL
-};
-
struct ldap_passdb_module {
struct passdb_module module;
@@ -434,7 +430,7 @@ passdb_ldap_preinit(struct auth_passdb *auth_passdb, const char *args)
if (conn->set.auth_bind_userdn != NULL)
conn->set.auth_bind = TRUE;
db_ldap_set_attrs(conn, conn->set.pass_attrs, &conn->pass_attr_names,
- conn->pass_attr_map, default_attr_map,
+ conn->pass_attr_map,
conn->set.auth_bind ? "password" : NULL);
module->module.cache_key =
auth_cache_parse_key(auth_passdb->auth->pool,
diff --git a/src/auth/userdb-ldap.c b/src/auth/userdb-ldap.c
index 3a8d2f5..170add0 100644
--- a/src/auth/userdb-ldap.c
+++ b/src/auth/userdb-ldap.c
@@ -26,10 +26,6 @@ struct userdb_ldap_request {
userdb_callback_t *userdb_callback;
};
-static const char *default_attr_map[] = {
- "", "home", "mail", "system_user", "uid", "gid", NULL
-};
-
static void
ldap_query_get_result(struct ldap_connection *conn, LDAPMessage *entry,
struct auth_request *auth_request)
@@ -37,6 +33,8 @@ ldap_query_get_result(struct ldap_connection *conn, LDAPMessage *entry,
struct db_ldap_result_iterate_context *ldap_iter;
const char *name, *const *values;
+ auth_request_init_userdb_reply(auth_request);
+
ldap_iter = db_ldap_result_iterate_init(conn, entry, auth_request,
conn->user_attr_map);
while (db_ldap_result_iterate_next_all(ldap_iter, &name, &values)) {
@@ -139,7 +137,7 @@ userdb_ldap_preinit(struct auth_userdb *auth_userdb, const char *args)
(hash_cmp_callback_t *)strcmp);
db_ldap_set_attrs(conn, conn->set.user_attrs, &conn->user_attr_names,
- conn->user_attr_map, default_attr_map, NULL);
+ conn->user_attr_map, NULL);
module->module.cache_key =
auth_cache_parse_key(auth_userdb->auth->pool,
conn->set.user_filter);
diff --git a/src/deliver/auth-client.c b/src/deliver/auth-client.c
index 083a70e..8a865bd 100644
--- a/src/deliver/auth-client.c
+++ b/src/deliver/auth-client.c
@@ -179,10 +179,8 @@ static struct auth_connection *auth_connection_new(const char *auth_socket)
conn = i_new(struct auth_connection, 1);
conn->fd = fd;
- conn->input =
- i_stream_create_file(fd, default_pool, MAX_INBUF_SIZE, FALSE);
- conn->output =
- o_stream_create_file(fd, default_pool, MAX_OUTBUF_SIZE, FALSE);
+ conn->input = i_stream_create_file(fd, MAX_INBUF_SIZE, FALSE);
+ conn->output = o_stream_create_file(fd, MAX_OUTBUF_SIZE, FALSE);
conn->io = io_add(fd, IO_READ, auth_input, conn);
return conn;
}
diff --git a/src/deliver/deliver.c b/src/deliver/deliver.c
index 42bb812..e38a621 100644
--- a/src/deliver/deliver.c
+++ b/src/deliver/deliver.c
@@ -229,7 +229,7 @@ static void config_file_init(const char *path)
i_fatal_status(EX_CONFIG, "open(%s) failed: %m", path);
t_push();
- input = i_stream_create_file(fd, default_pool, 1024, TRUE);
+ input = i_stream_create_file(fd, 1024, TRUE);
while ((line = i_stream_read_next_line(input)) != NULL) {
/* @UNSAFE: line is modified */
@@ -417,7 +417,7 @@ static struct istream *create_mbox_stream(int fd, const char *envelope_sender)
envelope_sender = address_sanitize(envelope_sender);
mbox_hdr = mbox_from_create(envelope_sender, ioloop_time);
- input = i_stream_create_file(fd, default_pool, 4096, FALSE);
+ input = i_stream_create_file(fd, 4096, FALSE);
input_filter =
i_stream_create_header_filter(input,
HEADER_FILTER_EXCLUDE |
@@ -428,14 +428,12 @@ static struct istream *create_mbox_stream(int fd, const char *envelope_sender)
NULL);
i_stream_unref(&input);
- input_list[0] = i_stream_create_from_data(default_pool, mbox_hdr,
- strlen(mbox_hdr));
+ input_list[0] = i_stream_create_from_data(mbox_hdr, strlen(mbox_hdr));
input_list[1] = input_filter;
- input_list[2] = i_stream_create_from_data(default_pool, "\n", 1);
+ input_list[2] = i_stream_create_from_data("\n", 1);
input_list[3] = NULL;
- input = i_stream_create_seekable(input_list, default_pool,
- MAIL_MAX_MEMORY_BUFFER,
+ input = i_stream_create_seekable(input_list, MAIL_MAX_MEMORY_BUFFER,
"/tmp/dovecot.deliver.");
i_stream_unref(&input_list[0]);
i_stream_unref(&input_list[1]);
@@ -754,28 +752,46 @@ int main(int argc, char *argv[])
if (mail_set_seq(mail, 1) < 0)
i_fatal("mail_set_seq() failed");
+ storage = NULL;
default_mailbox_name = mailbox;
- if (deliver_mail != NULL)
- (void)deliver_mail(ns, &storage, mail, destination, mailbox);
+ if (deliver_mail == NULL)
+ ret = -1;
+ else {
+ if (deliver_mail(ns, &storage, mail,
+ destination, mailbox) <= 0) {
+ /* if message was saved, don't bounce it even though
+ the script failed later. */
+ ret = saved_mail ? 0 : -1;
+ } else {
+ /* success. message may or may not have been saved. */
+ ret = 0;
+ }
+ }
- if (!saved_mail && !tried_default_save) {
+ if (ret < 0 && !tried_default_save) {
/* plugins didn't handle this. save into the default mailbox. */
i_stream_seek(input, 0);
- (void)deliver_save(ns, &storage, mailbox, mail, 0, NULL);
+ ret = deliver_save(ns, &storage, mailbox, mail, 0, NULL);
}
- if (!saved_mail && strcasecmp(mailbox, "INBOX") != 0) {
+ if (ret < 0 && strcasecmp(mailbox, "INBOX") != 0) {
/* still didn't work. try once more to save it
to INBOX. */
i_stream_seek(input, 0);
- (void)deliver_save(ns, &storage, "INBOX", mail, 0, NULL);
+ ret = deliver_save(ns, &storage, "INBOX", mail, 0, NULL);
}
- if (!saved_mail) {
+ if (ret < 0 ) {
const char *error_string, *msgid;
enum mail_error error;
int ret;
- error_string = mail_storage_get_last_error(ns->storage, &error);
+ if (storage == NULL) {
+ /* This shouldn't happen */
+ i_error("BUG: Saving failed for unknown storage");
+ return EX_TEMPFAIL;
+ }
+
+ error_string = mail_storage_get_last_error(storage, &error);
if (error != MAIL_ERROR_NOSPACE ||
getenv("QUOTA_FULL_TEMPFAIL") != NULL) {
/* Saving to INBOX should always work unless
diff --git a/src/deliver/duplicate.c b/src/deliver/duplicate.c
index bb6f5d5..a724cc9 100644
--- a/src/deliver/duplicate.c
+++ b/src/deliver/duplicate.c
@@ -94,7 +94,7 @@ static int duplicate_read(struct duplicate_file *file)
}
/* <timestamp> <id_size> <user_size> <id> <user> */
- input = i_stream_create_file(fd, default_pool, 4096, FALSE);
+ input = i_stream_create_file(fd, 4096, FALSE);
change_count = 0;
while (i_stream_read_data(input, &data, &size, sizeof(stamp) +
@@ -218,7 +218,7 @@ void duplicate_flush(void)
if (duplicate_file == NULL || !file->changed || file->new_fd == -1)
return;
- output = o_stream_create_file(file->new_fd, default_pool, 4096, FALSE);
+ output = o_stream_create_file(file->new_fd, 4096, FALSE);
iter = hash_iterate_init(file->hash);
while (hash_iterate(iter, &key, &value)) {
struct duplicate *d = value;
diff --git a/src/dict/dict-server.c b/src/dict/dict-server.c
index 1fa9609..6acf34b 100644
--- a/src/dict/dict-server.c
+++ b/src/dict/dict-server.c
@@ -446,9 +446,9 @@ dict_client_connection_init(struct dict_server *server, int fd)
conn = i_new(struct dict_client_connection, 1);
conn->server = server;
conn->fd = fd;
- conn->input = i_stream_create_file(fd, default_pool,
- DICT_CLIENT_MAX_LINE_LENGTH, FALSE);
- conn->output = o_stream_create_file(fd, default_pool, 128*1024, FALSE);
+ conn->input = i_stream_create_file(fd, DICT_CLIENT_MAX_LINE_LENGTH,
+ FALSE);
+ conn->output = o_stream_create_file(fd, 128*1024, FALSE);
conn->io = io_add(fd, IO_READ, dict_client_connection_input, conn);
return conn;
}
diff --git a/src/imap-login/client.c b/src/imap-login/client.c
index 6fa0e76..e984ce9 100644
--- a/src/imap-login/client.c
+++ b/src/imap-login/client.c
@@ -68,10 +68,8 @@ static void client_set_title(struct imap_client *client)
static void client_open_streams(struct imap_client *client, int fd)
{
- client->input = i_stream_create_file(fd, default_pool,
- MAX_INBUF_SIZE, FALSE);
- client->output = o_stream_create_file(fd, default_pool, MAX_OUTBUF_SIZE,
- FALSE);
+ client->input = i_stream_create_file(fd, MAX_INBUF_SIZE, FALSE);
+ client->output = o_stream_create_file(fd, MAX_OUTBUF_SIZE, FALSE);
client->parser = imap_parser_create(client->input, client->output,
MAX_IMAP_LINE);
}
diff --git a/src/imap/client.c b/src/imap/client.c
index 1036e9e..99df764 100644
--- a/src/imap/client.c
+++ b/src/imap/client.c
@@ -30,10 +30,9 @@ struct client *client_create(int fd_in, int fd_out,
client = i_new(struct client, 1);
client->fd_in = fd_in;
client->fd_out = fd_out;
- client->input = i_stream_create_file(fd_in, default_pool,
- imap_max_line_length, FALSE);
- client->output = o_stream_create_file(fd_out, default_pool,
- (size_t)-1, FALSE);
+ client->input =
+ i_stream_create_file(fd_in, imap_max_line_length, FALSE);
+ client->output = o_stream_create_file(fd_out, (size_t)-1, FALSE);
o_stream_set_flush_callback(client->output, _client_output, client);
diff --git a/src/imap/cmd-append.c b/src/imap/cmd-append.c
index ccbce56..2f1ec5f 100644
--- a/src/imap/cmd-append.c
+++ b/src/imap/cmd-append.c
@@ -186,7 +186,7 @@ static bool cmd_append_cancel(struct cmd_append_context *ctx, bool nonsync)
/* we have to read the nonsynced literal so we don't treat the message
data as commands. */
- ctx->input = i_stream_create_limit(default_pool, ctx->client->input,
+ ctx->input = i_stream_create_limit(ctx->client->input,
ctx->client->input->v_offset,
ctx->msg_size);
@@ -317,7 +317,7 @@ static bool cmd_append_continue_parsing(struct client_command_context *cmd)
}
/* save the mail */
- ctx->input = i_stream_create_limit(default_pool, client->input,
+ ctx->input = i_stream_create_limit(client->input,
client->input->v_offset,
ctx->msg_size);
ret = mailbox_save_init(ctx->t, flags, keywords,
diff --git a/src/imap/imap-fetch-body.c b/src/imap/imap-fetch-body.c
index 392b4a3..23712d0 100644
--- a/src/imap/imap-fetch-body.c
+++ b/src/imap/imap-fetch-body.c
@@ -280,7 +280,7 @@ static int fetch_stream(struct imap_fetch_context *ctx,
if (size->physical_size == size->virtual_size &&
ctx->cur_mail->has_no_nuls) {
/* no need to kludge with CRs, we can use sendfile() */
- input = i_stream_create_limit(default_pool, ctx->cur_input,
+ input = i_stream_create_limit(ctx->cur_input,
ctx->cur_input->v_offset,
ctx->cur_size);
i_stream_unref(&ctx->cur_input);
diff --git a/src/lib-auth/auth-server-connection.c b/src/lib-auth/auth-server-connection.c
index 3f5d5c0..3ba6111 100644
--- a/src/lib-auth/auth-server-connection.c
+++ b/src/lib-auth/auth-server-connection.c
@@ -226,10 +226,9 @@ auth_server_connection_new(struct auth_client *client, const char *path)
conn->path = p_strdup(pool, path);
conn->fd = fd;
conn->io = io_add(fd, IO_READ, auth_client_input, conn);
- conn->input = i_stream_create_file(fd, default_pool,
- AUTH_CLIENT_MAX_LINE_LENGTH, FALSE);
- conn->output = o_stream_create_file(fd, default_pool, (size_t)-1,
- FALSE);
+ conn->input = i_stream_create_file(fd, AUTH_CLIENT_MAX_LINE_LENGTH,
+ FALSE);
+ conn->output = o_stream_create_file(fd, (size_t)-1, FALSE);
conn->requests = hash_create(default_pool, pool, 100, NULL, NULL);
conn->auth_mechs_buf = buffer_create_dynamic(default_pool, 256);
diff --git a/src/lib-charset/charset-iconv.c b/src/lib-charset/charset-iconv.c
index 955cf5d..da6aa48 100644
--- a/src/lib-charset/charset-iconv.c
+++ b/src/lib-charset/charset-iconv.c
@@ -1,7 +1,8 @@
-/* Copyright (C) 2002 Timo Sirainen */
+/* Copyright (C) 2002-2007 Timo Sirainen */
#include "lib.h"
#include "buffer.h"
+#include "unichar.h"
#include "charset-utf8.h"
#ifdef HAVE_ICONV
@@ -11,31 +12,28 @@
struct charset_translation {
iconv_t cd;
+ enum charset_flags flags;
};
-struct charset_translation *charset_to_utf8_begin(const char *charset,
- bool *unknown_charset)
+int charset_to_utf8_begin(const char *charset, enum charset_flags flags,
+ struct charset_translation **t_r)
{
struct charset_translation *t;
iconv_t cd;
- if (unknown_charset != NULL)
- *unknown_charset = FALSE;
-
if (charset_is_utf8(charset))
cd = (iconv_t)-1;
else {
cd = iconv_open("UTF-8", charset);
- if (cd == (iconv_t)-1) {
- if (unknown_charset != NULL)
- *unknown_charset = TRUE;
- return NULL;
- }
+ if (cd == (iconv_t)-1)
+ return -1;
}
t = i_new(struct charset_translation, 1);
t->cd = cd;
- return t;
+ t->flags = flags;
+ *t_r = t;
+ return 0;
}
void charset_to_utf8_end(struct charset_translation **_t)
@@ -55,70 +53,90 @@ void charset_to_utf8_reset(struct charset_translation *t)
(void)iconv(t->cd, NULL, NULL, NULL, NULL);
}
-enum charset_result
-charset_to_ucase_utf8(struct charset_translation *t,
- const unsigned char *src, size_t *src_size,
- buffer_t *dest)
+static bool
+charset_to_utf8_try(struct charset_translation *t,
+ const unsigned char *src, size_t *src_size, buffer_t *dest,
+ enum charset_result *result)
{
ICONV_CONST char *ic_srcbuf;
- char *ic_destbuf;
- size_t srcleft, destpos, destleft, size;
- enum charset_result ret;
-
- destpos = buffer_get_used_size(dest);
- destleft = buffer_get_size(dest) - destpos;
+ char tmpbuf[8192], *ic_destbuf;
+ size_t srcleft, destleft;
+ bool dtcase = (t->flags & CHARSET_FLAG_DECOMP_TITLECASE) != 0;
+ bool ret = TRUE;
if (t->cd == (iconv_t)-1) {
/* no translation needed - just copy it to outbuf uppercased */
- if (*src_size > destleft)
- *src_size = destleft;
- _charset_utf8_ucase(src, *src_size, dest, destpos);
- return CHARSET_RET_OK;
+ *result = CHARSET_RET_OK;
+ if (!dtcase) {
+ buffer_append(dest, src, *src_size);
+ return TRUE;
+ }
+
+ if (uni_utf8_to_decomposed_titlecase(src, *src_size, dest) < 0)
+ *result = CHARSET_RET_INVALID_INPUT;
+ return TRUE;
+ }
+ if (!dtcase) {
+ destleft = buffer_get_size(dest) - dest->used;
+ if (destleft < *src_size) {
+ /* The buffer is most likely too small to hold the
+ output, so increase it at least to the input size. */
+ destleft = *src_size;
+ }
+ ic_destbuf = buffer_append_space_unsafe(dest, destleft);
+ } else {
+ destleft = sizeof(tmpbuf);
+ ic_destbuf = tmpbuf;
}
- size = destleft;
srcleft = *src_size;
ic_srcbuf = (ICONV_CONST char *) src;
- ic_destbuf = buffer_append_space_unsafe(dest, destleft);
if (iconv(t->cd, &ic_srcbuf, &srcleft,
&ic_destbuf, &destleft) != (size_t)-1)
- ret = CHARSET_RET_OK;
- else if (errno == E2BIG)
- ret = CHARSET_RET_OUTPUT_FULL;
- else if (errno == EINVAL)
- ret = CHARSET_RET_INCOMPLETE_INPUT;
+ *result = CHARSET_RET_OK;
+ else if (errno == E2BIG) {
+ /* set result just to avoid compiler warning */
+ *result = CHARSET_RET_INCOMPLETE_INPUT;
+ ret = FALSE;
+ } else if (errno == EINVAL)
+ *result = CHARSET_RET_INCOMPLETE_INPUT;
else {
/* should be EILSEQ */
- return CHARSET_RET_INVALID_INPUT;
+ *result = CHARSET_RET_INVALID_INPUT;
+ return TRUE;
}
- size -= destleft;
+ *src_size -= srcleft;
- /* give back the memory we didn't use */
- buffer_set_used_size(dest, buffer_get_used_size(dest) - destleft);
+ if (!dtcase) {
+ /* give back the memory we didn't use */
+ buffer_set_used_size(dest, dest->used - destleft);
+ } else {
+ size_t tmpsize = sizeof(tmpbuf) - destleft;
- *src_size -= srcleft;
- _charset_utf8_ucase((unsigned char *) ic_destbuf - size, size,
- dest, destpos);
+ /* we just converted data to UTF-8, it can't be invalid */
+ if (uni_utf8_to_decomposed_titlecase(tmpbuf, tmpsize, dest) < 0)
+ i_unreached();
+ }
return ret;
}
enum charset_result
-charset_to_ucase_utf8_full(struct charset_translation *t,
- const unsigned char *src, size_t *src_size,
- buffer_t *dest)
+charset_to_utf8(struct charset_translation *t,
+ const unsigned char *src, size_t *src_size, buffer_t *dest)
{
- enum charset_result ret;
+ enum charset_result result;
size_t pos, used, size;
+ bool ret;
for (pos = 0;;) {
size = *src_size - pos;
- ret = charset_to_ucase_utf8(t, src + pos, &size, dest);
+ ret = charset_to_utf8_try(t, src + pos, &size, dest, &result);
pos += size;
- if (ret != CHARSET_RET_OUTPUT_FULL) {
+ if (ret) {
*src_size = pos;
- return ret;
+ return result;
}
/* force buffer to grow */
@@ -129,89 +147,4 @@ charset_to_ucase_utf8_full(struct charset_translation *t,
}
}
-static const char *
-charset_to_utf8_string_int(const char *charset, bool *unknown_charset,
- const unsigned char *data, size_t size,
- size_t *utf8_size_r, bool ucase)
-{
- iconv_t cd;
- ICONV_CONST char *inbuf;
- char *outbuf, *outpos;
- size_t inleft, outleft, outsize, pos;
-
- if (charset == NULL || charset_is_utf8(charset)) {
- if (unknown_charset != NULL)
- *unknown_charset = FALSE;
-
- if (!ucase) {
- if (utf8_size_r != NULL)
- *utf8_size_r = size;
- return t_strndup(data, size);
- }
-
- return _charset_utf8_ucase_strdup(data, size, utf8_size_r);
- }
-
- cd = iconv_open("UTF-8", charset);
- if (cd == (iconv_t)-1) {
- if (unknown_charset != NULL)
- *unknown_charset = TRUE;
- return NULL;
- }
-
- if (unknown_charset != NULL)
- *unknown_charset = FALSE;
-
- inbuf = (ICONV_CONST char *) data;
- inleft = size;
-
- outsize = outleft = inleft * 2;
- outbuf = outpos = t_buffer_get(outsize + 1);
-
- while (iconv(cd, &inbuf, &inleft, &outpos, &outleft) == (size_t)-1) {
- if (errno != E2BIG) {
- /* invalid data */
- iconv_close(cd);
- return NULL;
- }
-
- /* output buffer too small, grow it */
- pos = outsize - outleft;
- outsize *= 2;
- outleft = outsize - pos;
-
- outbuf = t_buffer_reget(outbuf, outsize + 1);
- outpos = outbuf + pos;
- }
-
- if (utf8_size_r != NULL)
- *utf8_size_r = (size_t) (outpos - outbuf);
- *outpos++ = '\0';
- t_buffer_alloc((size_t) (outpos - outbuf));
-
- if (ucase)
- str_ucase(outbuf); /* FIXME: utf8 */
-
- iconv_close(cd);
- return outbuf;
-}
-
-const char *
-charset_to_utf8_string(const char *charset, bool *unknown_charset,
- const unsigned char *data, size_t size,
- size_t *utf8_size_r)
-{
- return charset_to_utf8_string_int(charset, unknown_charset,
- data, size, utf8_size_r, FALSE);
-}
-
-const char *
-charset_to_ucase_utf8_string(const char *charset, bool *unknown_charset,
- const unsigned char *data, size_t size,
- size_t *utf8_size_r)
-{
- return charset_to_utf8_string_int(charset, unknown_charset,
- data, size, utf8_size_r, TRUE);
-}
-
#endif
diff --git a/src/lib-charset/charset-utf8.c b/src/lib-charset/charset-utf8.c
index 3917ebb..71c6963 100644
--- a/src/lib-charset/charset-utf8.c
+++ b/src/lib-charset/charset-utf8.c
@@ -2,6 +2,7 @@
#include "lib.h"
#include "buffer.h"
+#include "unichar.h"
#include "charset-utf8.h"
#include <ctype.h>
@@ -14,59 +15,30 @@ bool charset_is_utf8(const char *charset)
strcasecmp(charset, "UTF8") == 0;
}
-void _charset_utf8_ucase(const unsigned char *src, size_t src_size,
- buffer_t *dest, size_t destpos)
-{
- char *destbuf;
- size_t i;
-
- destbuf = buffer_get_space_unsafe(dest, destpos, src_size);
- for (i = 0; i < src_size; i++)
- destbuf[i] = i_toupper(src[i]); /* FIXME: utf8 */
-}
-
-const char *_charset_utf8_ucase_strdup(const unsigned char *data, size_t size,
- size_t *utf8_size_r)
-{
- buffer_t *dest;
-
- dest = buffer_create_dynamic(pool_datastack_create(), size);
- _charset_utf8_ucase(data, size, dest, 0);
- if (utf8_size_r != NULL)
- *utf8_size_r = buffer_get_used_size(dest);
- buffer_append_c(dest, '\0');
- return buffer_free_without_data(dest);
-}
-
-
#ifndef HAVE_ICONV
-#include <ctype.h>
-
struct charset_translation {
- int dummy;
+ enum charset_flags flags;
};
-static struct charset_translation ascii_translation, utf8_translation;
+static struct charset_translation raw_translation = { 0 };
+static struct charset_translation tc_translation = {
+ CHARSET_FLAG_DECOMP_TITLECASE
+};
-struct charset_translation *charset_to_utf8_begin(const char *charset,
- bool *unknown_charset)
+int charset_to_utf8_begin(const char *charset, enum charset_flags flags,
+ struct charset_translation **t_r)
{
- if (unknown_charset != NULL)
- *unknown_charset = FALSE;
-
- if (strcasecmp(charset, "us-ascii") == 0 ||
- strcasecmp(charset, "ascii") == 0)
- return &ascii_translation;
-
- if (strcasecmp(charset, "UTF-8") == 0 ||
- strcasecmp(charset, "UTF8") == 0)
- return &utf8_translation;
+ if (charset_is_utf8(charset)) {
+ if ((flags & CHARSET_FLAG_DECOMP_TITLECASE) != 0)
+ *t_r = &tc_translation;
+ else
+ *t_r = &raw_translation;
+ return 0;
+ }
/* no support for charsets that need translation */
- if (unknown_charset != NULL)
- *unknown_charset = TRUE;
- return NULL;
+ return -1;
}
void charset_to_utf8_end(struct charset_translation **t __attr_unused__)
@@ -78,57 +50,16 @@ void charset_to_utf8_reset(struct charset_translation *t __attr_unused__)
}
enum charset_result
-charset_to_ucase_utf8(struct charset_translation *t __attr_unused__,
- const unsigned char *src, size_t *src_size,
- buffer_t *dest)
+charset_to_utf8(struct charset_translation *t,
+ const unsigned char *src, size_t *src_size, buffer_t *dest)
{
- size_t destpos, destleft;
-
- destpos = buffer_get_used_size(dest);
- destleft = buffer_get_size(dest) - destpos;
-
- /* no translation needed - just copy it to outbuf uppercased */
- if (*src_size > destleft)
- *src_size = destleft;
- _charset_utf8_ucase(src, *src_size, dest, destpos);
- return CHARSET_RET_OK;
-}
-
-const char *
-charset_to_utf8_string(const char *charset, bool *unknown_charset,
- const unsigned char *data, size_t size,
- size_t *utf8_size_r)
-{
- if (charset == NULL || strcasecmp(charset, "us-ascii") == 0 ||
- strcasecmp(charset, "ascii") == 0 ||
- strcasecmp(charset, "UTF-8") == 0 ||
- strcasecmp(charset, "UTF8") == 0) {
- if (unknown_charset != NULL)
- *unknown_charset = FALSE;
- if (utf8_size_r != NULL)
- *utf8_size_r = size;
- return t_strndup(data, size);
- } else {
- if (unknown_charset != NULL)
- *unknown_charset = TRUE;
- return NULL;
- }
-}
-
-const char *
-charset_to_ucase_utf8_string(const char *charset, bool *unknown_charset,
- const unsigned char *data, size_t size,
- size_t *utf8_size_r)
-{
- if (charset == NULL || charset_is_utf8(charset)) {
- if (unknown_charset != NULL)
- *unknown_charset = FALSE;
- return _charset_utf8_ucase_strdup(data, size, utf8_size_r);
- } else {
- if (unknown_charset != NULL)
- *unknown_charset = TRUE;
- return NULL;
+ if ((t->flags & CHARSET_FLAG_DECOMP_TITLECASE) == 0)
+ buffer_append(dest, src, *src_size);
+ else {
+ if (uni_utf8_to_decomposed_titlecase(src, *src_size, dest) < 0)
+ return CHARSET_RET_INVALID_INPUT;
}
+ return CHARSET_RET_OK;
}
#endif
diff --git a/src/lib-charset/charset-utf8.h b/src/lib-charset/charset-utf8.h
index 0476df9..c603edb 100644
--- a/src/lib-charset/charset-utf8.h
+++ b/src/lib-charset/charset-utf8.h
@@ -1,51 +1,32 @@
#ifndef __CHARSET_UTF8_H
#define __CHARSET_UTF8_H
+struct charset_translation;
+
+enum charset_flags {
+ /* Translate the output to decomposed titlecase */
+ CHARSET_FLAG_DECOMP_TITLECASE = 0x01
+};
+
enum charset_result {
CHARSET_RET_OK = 1,
- CHARSET_RET_OUTPUT_FULL = 0,
CHARSET_RET_INCOMPLETE_INPUT = -1,
CHARSET_RET_INVALID_INPUT = -2
};
-/* Begin translation to UTF-8. */
-struct charset_translation *charset_to_utf8_begin(const char *charset,
- bool *unknown_charset);
-
+/* Begin translation to UTF-8. Returns -1 if charset is unknown. */
+int charset_to_utf8_begin(const char *charset, enum charset_flags flags,
+ struct charset_translation **t_r);
void charset_to_utf8_end(struct charset_translation **t);
-
void charset_to_utf8_reset(struct charset_translation *t);
/* Returns TRUE if charset is UTF-8 or ASCII */
bool charset_is_utf8(const char *charset);
/* Translate src to UTF-8. src_size is updated to contain the number of
- characters actually translated from src. Note that dest buffer is used
- only up to its current size, for growing it automatically use
- charset_to_ucase_utf8_full(). */
-enum charset_result
-charset_to_ucase_utf8(struct charset_translation *t,
- const unsigned char *src, size_t *src_size,
- buffer_t *dest);
+ characters actually translated from src. */
enum charset_result
-charset_to_ucase_utf8_full(struct charset_translation *t,
- const unsigned char *src, size_t *src_size,
- buffer_t *dest);
-
-/* Simple wrappers for above functions. If utf8_size is non-NULL, it's set
- to same as strlen(returned data). */
-const char *
-charset_to_utf8_string(const char *charset, bool *unknown_charset,
- const unsigned char *data, size_t size,
- size_t *utf8_size_r);
-const char *
-charset_to_ucase_utf8_string(const char *charset, bool *unknown_charset,
- const unsigned char *data, size_t size,
- size_t *utf8_size_r);
-
-void _charset_utf8_ucase(const unsigned char *src, size_t src_size,
- buffer_t *dest, size_t destpos);
-const char *_charset_utf8_ucase_strdup(const unsigned char *data, size_t size,
- size_t *utf8_size_r);
+charset_to_utf8(struct charset_translation *t,
+ const unsigned char *src, size_t *src_size, buffer_t *dest);
#endif
diff --git a/src/lib-dict/dict-client.c b/src/lib-dict/dict-client.c
index 5064b6f..0fb8446 100644
--- a/src/lib-dict/dict-client.c
+++ b/src/lib-dict/dict-client.c
@@ -244,10 +244,8 @@ static int client_dict_connect(struct client_dict *dict)
/* Dictionary lookups are blocking */
net_set_nonblock(dict->fd, FALSE);
- dict->input = i_stream_create_file(dict->fd, default_pool,
- (size_t)-1, FALSE);
- dict->output = o_stream_create_file(dict->fd, default_pool,
- 4096, FALSE);
+ dict->input = i_stream_create_file(dict->fd, (size_t)-1, FALSE);
+ dict->output = o_stream_create_file(dict->fd, 4096, FALSE);
dict->transaction_id_counter = 0;
t_push();
diff --git a/src/lib-dict/dict-sql.c b/src/lib-dict/dict-sql.c
index 2386c13..c440026 100644
--- a/src/lib-dict/dict-sql.c
+++ b/src/lib-dict/dict-sql.c
@@ -48,7 +48,7 @@ static int sql_dict_read_config(struct sql_dict *dict, const char *path)
return -1;
}
- input = i_stream_create_file(fd, default_pool, (size_t)-1, FALSE);
+ input = i_stream_create_file(fd, (size_t)-1, FALSE);
while ((line = i_stream_read_next_line(input)) != NULL) {
while (*line == ' ') line++;
value = strchr(line, '=');
diff --git a/src/lib-imap/imap-base-subject.c b/src/lib-imap/imap-base-subject.c
index 1e41413..41806b2 100644
--- a/src/lib-imap/imap-base-subject.c
+++ b/src/lib-imap/imap-base-subject.c
@@ -9,39 +9,6 @@
#include "message-header-decode.h"
#include "imap-base-subject.h"
-static bool header_decode(const unsigned char *data, size_t size,
- const char *charset, void *context)
-{
- buffer_t *buf = context;
- struct charset_translation *t;
- unsigned char *buf_data;
- size_t pos, used_size;
-
- pos = buffer_get_used_size(buf);
- if (charset == NULL) {
- /* It's ASCII. */
- buffer_append(buf, data, size);
- } else {
- t = charset_to_utf8_begin(charset, NULL);
- if (t != NULL) {
- (void)charset_to_ucase_utf8(t, data, &size, buf);
- charset_to_utf8_end(&t);
- }
- }
-
- if (size > 0) {
- /* @UNSAFE: uppercase it. Current draft specifies that we
- should touch only ASCII. */
- buf_data = buffer_get_modifiable_data(buf, &used_size);
- for (; pos < used_size; pos++) {
- if (buf_data[pos] >= 'a' && buf_data[pos] <= 'z')
- buf_data[pos] = buf_data[pos] - 'a' + 'A';
- }
- }
-
- return TRUE;
-}
-
static void pack_whitespace(buffer_t *buf)
{
char *data, *dest;
@@ -246,8 +213,8 @@ const char *imap_get_base_subject_cased(pool_t pool, const char *subject,
/* (1) Convert any RFC 2047 encoded-words in the subject to
UTF-8. Convert all tabs and continuations to space.
Convert all multiple spaces to a single space. */
- message_header_decode((const unsigned char *)subject, subject_len,
- header_decode, buf);
+ message_header_decode_utf8((const unsigned char *)subject, subject_len,
+ buf, TRUE);
buffer_append_c(buf, '\0');
pack_whitespace(buf);
diff --git a/src/lib-imap/imap-bodystructure.c b/src/lib-imap/imap-bodystructure.c
index b346722..3eaed30 100644
--- a/src/lib-imap/imap-bodystructure.c
+++ b/src/lib-imap/imap-bodystructure.c
@@ -5,7 +5,6 @@
#include "istream.h"
#include "str.h"
#include "message-parser.h"
-#include "message-content-parser.h"
#include "rfc822-parser.h"
#include "imap-parser.h"
#include "imap-quote.h"
@@ -20,7 +19,6 @@
struct message_part_body_data {
pool_t pool;
- string_t *str; /* temporary */
const char *content_type, *content_subtype;
const char *content_type_params;
const char *content_transfer_encoding;
@@ -32,65 +30,111 @@ struct message_part_body_data {
const char *content_language;
struct message_part_envelope_data *envelope;
-
- unsigned int charset_found:1;
};
-static void parse_content_type(const unsigned char *value, size_t value_len,
- void *context)
+static void parse_content_type(struct message_part_body_data *data,
+ struct message_header_line *hdr)
{
- struct message_part_body_data *data = context;
- size_t i;
+ struct rfc822_parser_context parser;
+ const char *key, *value;
+ string_t *str;
+ unsigned int i;
+ bool charset_found = FALSE;
+
+ rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL);
+ (void)rfc822_skip_lwsp(&parser);
- for (i = 0; i < value_len; i++) {
- if (value[i] == '/')
+ str = t_str_new(256);
+ if (rfc822_parse_content_type(&parser, str) < 0)
+ return;
+
+ /* Save content type and subtype */
+ value = str_c(str);
+ for (i = 0; value[i] != '\0'; i++) {
+ if (value[i] == '/') {
+ data->content_subtype =
+ imap_quote(data->pool, str_data(str) + i + 1,
+ str_len(str) - (i + 1));
break;
+ }
}
+ data->content_type =
+ imap_quote(data->pool, str_data(str), i);
- if (i == value_len)
- data->content_type = imap_quote(data->pool, value, value_len);
- else {
- data->content_type = imap_quote(data->pool, value, i);
+ /* parse parameters and save them */
+ str_truncate(str, 0);
+ while (rfc822_parse_content_param(&parser, &key, &value) > 0) {
+ if (strcasecmp(key, "charset") == 0)
+ charset_found = TRUE;
- i++;
- data->content_subtype =
- imap_quote(data->pool, value+i, value_len-i);
+ str_append_c(str, ' ');
+ imap_quote_append_string(str, key, TRUE);
+ str_append_c(str, ' ');
+ imap_quote_append_string(str, value, TRUE);
+ }
+
+ if (!charset_found &&
+ strcasecmp(data->content_type, "\"text\"") == 0) {
+ /* set a default charset */
+ str_append_c(str, ' ');
+ str_append(str, DEFAULT_CHARSET);
+ }
+ if (str_len(str) > 0) {
+ data->content_type_params =
+ p_strdup(data->pool, str_c(str) + 1);
}
}
-static void parse_save_params_list(const unsigned char *name, size_t name_len,
- const unsigned char *value, size_t value_len,
- bool value_quoted __attr_unused__,
- void *context)
+static void parse_content_transfer_encoding(struct message_part_body_data *data,
+ struct message_header_line *hdr)
{
- struct message_part_body_data *data = context;
-
- if (str_len(data->str) != 0)
- str_append_c(data->str, ' ');
+ struct rfc822_parser_context parser;
+ string_t *str;
- if (name_len == 7 && memcasecmp(name, "charset", 7) == 0)
- data->charset_found = TRUE;
+ rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL);
+ (void)rfc822_skip_lwsp(&parser);
- imap_quote_append(data->str, name, name_len, TRUE);
- str_append_c(data->str, ' ');
- imap_quote_append(data->str, value, value_len, TRUE);
+ t_push();
+ str = t_str_new(256);
+ if (rfc822_parse_mime_token(&parser, str) >= 0) {
+ data->content_transfer_encoding =
+ imap_quote(data->pool, str_data(str), str_len(str));
+ }
+ t_pop();
}
-static void parse_content_transfer_encoding(const unsigned char *value,
- size_t value_len, void *context)
+static void parse_content_disposition(struct message_part_body_data *data,
+ struct message_header_line *hdr)
{
- struct message_part_body_data *data = context;
+ struct rfc822_parser_context parser;
+ const char *key, *value;
+ string_t *str;
- data->content_transfer_encoding =
- imap_quote(data->pool, value, value_len);
-}
+ rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL);
+ (void)rfc822_skip_lwsp(&parser);
-static void parse_content_disposition(const unsigned char *value,
- size_t value_len, void *context)
-{
- struct message_part_body_data *data = context;
+ t_push();
+ str = t_str_new(256);
+ if (rfc822_parse_mime_token(&parser, str) < 0) {
+ t_pop();
+ return;
+ }
+ data->content_disposition =
+ imap_quote(data->pool, str_data(str), str_len(str));
- data->content_disposition = imap_quote(data->pool, value, value_len);
+ /* parse parameters and save them */
+ str_truncate(str, 0);
+ while (rfc822_parse_content_param(&parser, &key, &value) > 0) {
+ str_append_c(str, ' ');
+ imap_quote_append_string(str, key, TRUE);
+ str_append_c(str, ' ');
+ imap_quote_append_string(str, value, TRUE);
+ }
+ if (str_len(str) > 0) {
+ data->content_disposition_params =
+ p_strdup(data->pool, str_c(str) + 1);
+ }
+ t_pop();
}
static void parse_content_language(const unsigned char *value, size_t value_len,
@@ -164,27 +208,13 @@ static void parse_content_header(struct message_part_body_data *d,
case 't':
case 'T':
if (strcasecmp(name, "Type") == 0 && d->content_type == NULL) {
- d->str = str_new(default_pool, 256);
- message_content_parse_header(value, value_len,
- parse_content_type,
- parse_save_params_list, d);
- if (!d->charset_found &&
- strncasecmp(d->content_type, "\"text\"", 6) == 0) {
- /* set a default charset */
- if (str_len(d->str) != 0)
- str_append_c(d->str, ' ');
- str_append(d->str, DEFAULT_CHARSET);
- }
- d->content_type_params =
- p_strdup_empty(pool, str_c(d->str));
- str_free(&d->str);
+ t_push();
+ parse_content_type(d, hdr);
+ t_pop();
}
if (strcasecmp(name, "Transfer-Encoding") == 0 &&
- d->content_transfer_encoding == NULL) {
- message_content_parse_header(value, value_len,
- parse_content_transfer_encoding,
- null_parse_content_param_callback, d);
- }
+ d->content_transfer_encoding == NULL)
+ parse_content_transfer_encoding(d, hdr);
break;
case 'l':
@@ -202,15 +232,8 @@ static void parse_content_header(struct message_part_body_data *d,
imap_quote(pool, value, value_len);
}
if (strcasecmp(name, "Disposition") == 0 &&
- d->content_disposition_params == NULL) {
- d->str = str_new(default_pool, 256);
- message_content_parse_header(value, value_len,
- parse_content_disposition,
- parse_save_params_list, d);
- d->content_disposition_params =
- p_strdup_empty(pool, str_c(d->str));
- str_free(&d->str);
- }
+ d->content_disposition_params == NULL)
+ parse_content_disposition(d, hdr);
break;
}
}
@@ -672,8 +695,7 @@ bool imap_body_parse_from_bodystructure(const char *bodystructure,
const struct imap_arg *args;
int ret;
- input = i_stream_create_from_data(pool_datastack_create(),
- bodystructure, strlen(bodystructure));
+ input = i_stream_create_from_data(bodystructure, strlen(bodystructure));
(void)i_stream_read(input);
parser = imap_parser_create(input, NULL, (size_t)-1);
diff --git a/src/lib-imap/imap-envelope.c b/src/lib-imap/imap-envelope.c
index f2c670b..892368d 100644
--- a/src/lib-imap/imap-envelope.c
+++ b/src/lib-imap/imap-envelope.c
@@ -380,8 +380,7 @@ bool imap_envelope_parse(const char *envelope, enum imap_envelope_field field,
i_assert(field < IMAP_ENVELOPE_FIELDS);
- input = i_stream_create_from_data(pool_datastack_create(), envelope,
- strlen(envelope));
+ input = i_stream_create_from_data(envelope, strlen(envelope));
parser = imap_parser_create(input, NULL, (size_t)-1);
(void)i_stream_read(input);
diff --git a/src/lib-index/mail-cache-compress.c b/src/lib-index/mail-cache-compress.c
index 7916142..fe15217 100644
--- a/src/lib-index/mail-cache-compress.c
+++ b/src/lib-index/mail-cache-compress.c
@@ -138,7 +138,7 @@ mail_cache_copy(struct mail_cache *cache, struct mail_index_transaction *trans,
}
cache_view = mail_cache_view_open(cache, view);
- output = o_stream_create_file(fd, default_pool, 0, FALSE);
+ output = o_stream_create_file(fd, 0, FALSE);
memset(&hdr, 0, sizeof(hdr));
hdr.version = MAIL_CACHE_VERSION;
diff --git a/src/lib-index/mailbox-list-index-sync.c b/src/lib-index/mailbox-list-index-sync.c
index e8a89f2..d586a42 100644
--- a/src/lib-index/mailbox-list-index-sync.c
+++ b/src/lib-index/mailbox-list-index-sync.c
@@ -850,8 +850,7 @@ mailbox_list_index_sync_write(struct mailbox_list_index_sync_ctx *ctx)
int ret = 0;
if (ctx->index->mmap_base == NULL) {
- ctx->output = o_stream_create_file(ctx->index->fd, default_pool,
- 0, FALSE);
+ ctx->output = o_stream_create_file(ctx->index->fd, 0, FALSE);
ctx->output_buf = buffer_create_dynamic(default_pool, 4096);
o_stream_seek(ctx->output, ctx->hdr.used_space);
}
diff --git a/src/lib-mail/Makefile.am b/src/lib-mail/Makefile.am
index 668dd5a..6cd4c87 100644
--- a/src/lib-mail/Makefile.am
+++ b/src/lib-mail/Makefile.am
@@ -7,7 +7,6 @@ AM_CPPFLAGS = \
libmail_a_SOURCES = \
istream-header-filter.c \
message-address.c \
- message-content-parser.c \
message-date.c \
message-decoder.c \
message-header-decode.c \
@@ -25,7 +24,6 @@ headers = \
istream-header-filter.h \
mail-types.h \
message-address.h \
- message-content-parser.h \
message-date.h \
message-decoder.h \
message-header-decode.h \
diff --git a/src/lib-mail/istream-header-filter.c b/src/lib-mail/istream-header-filter.c
index 402942b..9b14784 100644
--- a/src/lib-mail/istream-header-filter.c
+++ b/src/lib-mail/istream-header-filter.c
@@ -329,24 +329,22 @@ i_stream_create_header_filter(struct istream *input,
header_filter_callback *callback, void *context)
{
struct header_filter_istream *mstream;
- pool_t pool;
unsigned int i;
i_assert((flags & (HEADER_FILTER_INCLUDE|HEADER_FILTER_EXCLUDE)) != 0);
- pool = pool_alloconly_create("header filter stream", 4096);
- mstream = p_new(pool, struct header_filter_istream, 1);
- mstream->pool = pool;
+ mstream = i_new(struct header_filter_istream, 1);
+ mstream->pool = pool_alloconly_create("header filter stream", 4096);
mstream->input = input;
i_stream_ref(mstream->input);
mstream->headers = headers_count == 0 ? NULL :
- p_new(pool, const char *, headers_count);
+ p_new(mstream->pool, const char *, headers_count);
for (i = 0; i < headers_count; i++)
- mstream->headers[i] = p_strdup(pool, headers[i]);
+ mstream->headers[i] = p_strdup(mstream->pool, headers[i]);
mstream->headers_count = headers_count;
- mstream->hdr_buf = buffer_create_dynamic(pool, 1024);
+ mstream->hdr_buf = buffer_create_dynamic(mstream->pool, 1024);
mstream->callback = callback;
mstream->context = context;
@@ -366,5 +364,5 @@ i_stream_create_header_filter(struct istream *input,
mstream->istream.istream.blocking = input->blocking;
mstream->istream.istream.seekable = input->seekable;
- return _i_stream_create(&mstream->istream, pool, -1, 0);
+ return _i_stream_create(&mstream->istream, -1, 0);
}
diff --git a/src/lib-mail/message-content-parser.c b/src/lib-mail/message-content-parser.c
deleted file mode 100644
index 38cb876..0000000
--- a/src/lib-mail/message-content-parser.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/* Copyright (C) 2002-2005 Timo Sirainen */
-
-#include "lib.h"
-#include "str.h"
-#include "rfc822-parser.h"
-#include "message-content-parser.h"
-
-parse_content_callback_t *null_parse_content_callback = NULL;
-parse_content_param_callback_t *null_parse_content_param_callback = NULL;
-
-void message_content_parse_header(const unsigned char *data, size_t size,
- parse_content_callback_t *callback,
- parse_content_param_callback_t *param_cb,
- void *context)
-{
- struct rfc822_parser_context parser;
- string_t *str;
- size_t key_len;
- bool quoted_string;
-
- rfc822_parser_init(&parser, data, size, NULL);
-
- t_push();
- str = t_str_new(256);
-
- /* get content type */
- (void)rfc822_skip_lwsp(&parser);
- if (rfc822_parse_mime_token(&parser, str) > 0) {
- if (*parser.data == '/') {
- parser.data++;
- str_append_c(str, '/');
- (void)rfc822_parse_mime_token(&parser, str);
- }
- }
-
- if (callback != NULL)
- callback(str_data(str), str_len(str), context);
-
- if (param_cb == NULL) {
- /* we don't care about parameters */
- t_pop();
- return;
- }
-
- while (parser.data != parser.end && *parser.data == ';') {
- parser.data++;
- (void)rfc822_skip_lwsp(&parser);
-
- str_truncate(str, 0);
- if (rfc822_parse_mime_token(&parser, str) <= 0)
- break;
-
- /* <token> "=" <token> | <quoted-string> */
- if (str_len(str) == 0 || *parser.data != '=')
- break;
- parser.data++;
- if (rfc822_skip_lwsp(&parser) <= 0)
- break;
-
- quoted_string = parser.data != parser.end &&
- *parser.data == '"';
- key_len = str_len(str);
- if (quoted_string) {
- if (rfc822_parse_quoted_string(&parser, str) < 0)
- break;
- } else {
- if (rfc822_parse_mime_token(&parser, str) < 0)
- break;
- }
-
- param_cb(str_data(str), key_len,
- str_data(str) + key_len, str_len(str) - key_len,
- quoted_string, context);
-
- str_truncate(str, 0);
- }
- t_pop();
-}
diff --git a/src/lib-mail/message-content-parser.h b/src/lib-mail/message-content-parser.h
deleted file mode 100644
index 018bf1e..0000000
--- a/src/lib-mail/message-content-parser.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef __MESSAGE_CONTENT_PARSER_H
-#define __MESSAGE_CONTENT_PARSER_H
-
-/* NOTE: name and value aren't \0-terminated. */
-typedef void parse_content_callback_t(const unsigned char *value,
- size_t value_len, void *context);
-typedef void parse_content_param_callback_t(const unsigned char *name,
- size_t name_len,
- const unsigned char *value,
- size_t value_len,
- bool value_quoted, void *context);
-
-extern parse_content_callback_t *null_parse_content_callback;
-extern parse_content_param_callback_t *null_parse_content_param_callback;
-
-void message_content_parse_header(const unsigned char *data, size_t size,
- parse_content_callback_t *callback,
- parse_content_param_callback_t *param_cb,
- void *context);
-
-#endif
diff --git a/src/lib-mail/message-decoder.c b/src/lib-mail/message-decoder.c
index dbfae9c..5b23bb5 100644
--- a/src/lib-mail/message-decoder.c
+++ b/src/lib-mail/message-decoder.c
@@ -2,12 +2,13 @@
#include "lib.h"
#include "buffer.h"
-#include "strescape.h"
#include "base64.h"
+#include "str.h"
+#include "unichar.h"
#include "charset-utf8.h"
#include "quoted-printable.h"
+#include "rfc822-parser.h"
#include "message-parser.h"
-#include "message-content-parser.h"
#include "message-header-decode.h"
#include "message-decoder.h"
@@ -41,14 +42,16 @@ struct message_decoder_context {
char *content_charset;
enum content_type content_type;
+ unsigned int dtcase:1;
unsigned int charset_utf8:1;
};
-struct message_decoder_context *message_decoder_init_ucase(void)
+struct message_decoder_context *message_decoder_init(bool dtcase)
{
struct message_decoder_context *ctx;
ctx = i_new(struct message_decoder_context, 1);
+ ctx->dtcase = dtcase;
ctx->buf = buffer_create_dynamic(default_pool, 8192);
ctx->buf2 = buffer_create_dynamic(default_pool, 8192);
return ctx;
@@ -69,72 +72,68 @@ void message_decoder_deinit(struct message_decoder_context **_ctx)
i_free(ctx);
}
-static bool
-message_decode_header_callback(const unsigned char *data, size_t size,
- const char *charset, void *context)
+static void
+parse_content_transfer_encoding(struct message_decoder_context *ctx,
+ struct message_header_line *hdr)
{
- struct message_decoder_context *ctx = context;
- struct charset_translation *t;
- bool unknown_charset;
-
- if (charset == NULL || charset_is_utf8(charset)) {
- /* ASCII / UTF-8 */
- _charset_utf8_ucase(data, size, ctx->buf, ctx->buf->used);
- return TRUE;
- }
-
- t = charset_to_utf8_begin(charset, &unknown_charset);
- if (unknown_charset) {
- /* let's just ignore this part */
- return TRUE;
- }
-
- /* ignore any errors */
- (void)charset_to_ucase_utf8_full(t, data, &size, ctx->buf);
- charset_to_utf8_end(&t);
- return TRUE;
-}
+ struct rfc822_parser_context parser;
+ string_t *value;
-static void parse_content_encoding(const unsigned char *value, size_t value_len,
- void *context)
-{
- struct message_decoder_context *ctx = context;
+ t_push();
+ value = t_str_new(64);
+ rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL);
- ctx->content_type = CONTENT_TYPE_UNKNOWN;
+ (void)rfc822_skip_lwsp(&parser);
+ (void)rfc822_parse_mime_token(&parser, value);
- switch (value_len) {
+ switch (str_len(value)) {
case 4:
- if (memcasecmp(value, "7bit", 4) == 0 ||
- memcasecmp(value, "8bit", 4) == 0)
+ if (memcasecmp(str_data(value), "7bit", 4) == 0 ||
+ memcasecmp(str_data(value), "8bit", 4) == 0)
ctx->content_type = CONTENT_TYPE_BINARY;
break;
case 6:
- if (memcasecmp(value, "base64", 6) == 0)
+ if (memcasecmp(str_data(value), "base64", 6) == 0)
ctx->content_type = CONTENT_TYPE_BASE64;
- else if (memcasecmp(value, "binary", 6) == 0)
+ else if (memcasecmp(str_data(value), "binary", 6) == 0)
ctx->content_type = CONTENT_TYPE_BINARY;
break;
case 16:
- if (memcasecmp(value, "quoted-printable", 16) == 0)
+ if (memcasecmp(str_data(value), "quoted-printable", 16) == 0)
ctx->content_type = CONTENT_TYPE_QP;
break;
}
+ t_pop();
}
static void
-parse_content_type_param(const unsigned char *name, size_t name_len,
- const unsigned char *value, size_t value_len,
- bool value_quoted, void *context)
+parse_content_type(struct message_decoder_context *ctx,
+ struct message_header_line *hdr)
{
- struct message_decoder_context *ctx = context;
-
- if (name_len == 7 && memcasecmp(name, "charset", 7) == 0 &&
- ctx->content_charset == NULL) {
- ctx->content_charset = i_strndup(value, value_len);
- if (value_quoted) str_unescape(ctx->content_charset);
+ struct rfc822_parser_context parser;
+ const char *key, *value;
+ string_t *str;
+
+ if (ctx->content_charset != NULL)
+ return;
+
+ rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL);
+ (void)rfc822_skip_lwsp(&parser);
+ t_push();
+ str = t_str_new(64);
+ if (rfc822_parse_content_type(&parser, str) <= 0) {
+ t_pop();
+ return;
+ }
- ctx->charset_utf8 = charset_is_utf8(ctx->content_charset);
+ while (rfc822_parse_content_param(&parser, &key, &value) > 0) {
+ if (strcasecmp(key, "charset") == 0) {
+ ctx->content_charset = i_strdup(value);
+ ctx->charset_utf8 = charset_is_utf8(value);
+ break;
+ }
}
+ t_pop();
}
static bool message_decode_header(struct message_decoder_context *ctx,
@@ -149,37 +148,32 @@ static bool message_decode_header(struct message_decoder_context *ctx,
}
if (hdr->name_len == 12 &&
- strcasecmp(hdr->name, "Content-Type") == 0) {
- message_content_parse_header(hdr->full_value,
- hdr->full_value_len,
- null_parse_content_callback,
- parse_content_type_param, ctx);
- }
+ strcasecmp(hdr->name, "Content-Type") == 0)
+ parse_content_type(ctx, hdr);
if (hdr->name_len == 25 &&
- strcasecmp(hdr->name, "Content-Transfer-Encoding") == 0) {
- message_content_parse_header(hdr->full_value,
- hdr->full_value_len,
- parse_content_encoding,
- null_parse_content_param_callback,
- ctx);
- }
+ strcasecmp(hdr->name, "Content-Transfer-Encoding") == 0)
+ parse_content_transfer_encoding(ctx, hdr);
buffer_set_used_size(ctx->buf, 0);
- message_header_decode(hdr->full_value, hdr->full_value_len,
- message_decode_header_callback, ctx);
+ message_header_decode_utf8(hdr->full_value, hdr->full_value_len,
+ ctx->buf, ctx->dtcase);
value_len = ctx->buf->used;
- _charset_utf8_ucase((const unsigned char *)hdr->name, hdr->name_len,
- ctx->buf, ctx->buf->used);
- buffer_append_c(ctx->buf, '\0');
+ if (ctx->dtcase) {
+ (void)uni_utf8_to_decomposed_titlecase(hdr->name, hdr->name_len,
+ ctx->buf);
+ buffer_append_c(ctx->buf, '\0');
+ }
ctx->hdr = *hdr;
ctx->hdr.full_value = ctx->buf->data;
ctx->hdr.full_value_len = value_len;
ctx->hdr.value_len = 0;
- ctx->hdr.name = CONST_PTR_OFFSET(ctx->buf->data,
- ctx->hdr.full_value_len);
- ctx->hdr.name_len = ctx->buf->used - 1 - value_len;
+ if (ctx->dtcase) {
+ ctx->hdr.name = CONST_PTR_OFFSET(ctx->buf->data,
+ ctx->hdr.full_value_len);
+ ctx->hdr.name_len = ctx->buf->used - 1 - value_len;
+ }
output->hdr = &ctx->hdr;
return TRUE;
@@ -199,8 +193,7 @@ static void translation_buf_decode(struct message_decoder_context *ctx,
memcpy(trans_buf + ctx->translation_size, data, skip);
pos = *size;
- (void)charset_to_ucase_utf8_full(ctx->charset_trans,
- *data, &pos, ctx->buf2);
+ (void)charset_to_utf8(ctx->charset_trans, *data, &pos, ctx->buf2);
i_assert(pos > ctx->translation_size);
skip = (ctx->translation_size + skip) - pos;
@@ -219,14 +212,13 @@ static bool message_decode_body(struct message_decoder_context *ctx,
unsigned char new_buf[MAX_ENCODING_BUF_SIZE+1];
const unsigned char *data = NULL;
size_t pos, size = 0, skip = 0;
- bool unknown_charset;
int ret;
if (ctx->charset_trans == NULL && !ctx->charset_utf8) {
- ctx->charset_trans =
- charset_to_utf8_begin(ctx->content_charset != NULL ?
- ctx->content_charset : "UTF-8",
- &unknown_charset);
+ if (charset_to_utf8_begin(ctx->content_charset != NULL ?
+ ctx->content_charset : "UTF-8",
+ ctx->dtcase, &ctx->charset_trans) < 0)
+ ctx->charset_trans = NULL;
}
if (ctx->encoding_size != 0) {
@@ -304,10 +296,16 @@ static bool message_decode_body(struct message_decoder_context *ctx,
}
if (ctx->charset_utf8) {
- buffer_set_used_size(ctx->buf2, 0);
- _charset_utf8_ucase(data, size, ctx->buf2, ctx->buf2->used);
- output->data = ctx->buf2->data;
- output->size = ctx->buf2->used;
+ if (ctx->dtcase) {
+ buffer_set_used_size(ctx->buf2, 0);
+ (void)uni_utf8_to_decomposed_titlecase(data, size,
+ ctx->buf);
+ output->data = ctx->buf2->data;
+ output->size = ctx->buf2->used;
+ } else {
+ output->data = data;
+ output->size = size;
+ }
} else if (ctx->charset_trans == NULL) {
output->data = data;
output->size = size;
@@ -317,8 +315,8 @@ static bool message_decode_body(struct message_decoder_context *ctx,
translation_buf_decode(ctx, &data, &size);
pos = size;
- (void)charset_to_ucase_utf8_full(ctx->charset_trans,
- data, &pos, ctx->buf2);
+ (void)charset_to_utf8(ctx->charset_trans,
+ data, &pos, ctx->buf2);
if (pos != size) {
ctx->translation_size = size - pos;
i_assert(ctx->translation_size <=
diff --git a/src/lib-mail/message-decoder.h b/src/lib-mail/message-decoder.h
index 7fb6371..043cf3e 100644
--- a/src/lib-mail/message-decoder.h
+++ b/src/lib-mail/message-decoder.h
@@ -5,8 +5,9 @@ struct message_block;
/* Decode message's contents as UTF-8, both the headers and the MIME bodies.
The bodies are decoded from quoted-printable and base64 formats if needed.
- The data is returned uppercased. */
-struct message_decoder_context *message_decoder_init_ucase(void);
+ If dtcase=TRUE, the data is returned through
+ uni_utf8_to_decomposed_titlecase(). */
+struct message_decoder_context *message_decoder_init(bool dtcase);
void message_decoder_deinit(struct message_decoder_context **ctx);
/* Decode input and return decoded output. Headers are returned only in their
diff --git a/src/lib-mail/message-header-decode.c b/src/lib-mail/message-header-decode.c
index 19f5e2e..b8fb50a 100644
--- a/src/lib-mail/message-header-decode.c
+++ b/src/lib-mail/message-header-decode.c
@@ -3,6 +3,8 @@
#include "lib.h"
#include "base64.h"
#include "buffer.h"
+#include "unichar.h"
+#include "charset-utf8.h"
#include "quoted-printable.h"
#include "message-header-decode.h"
@@ -113,3 +115,58 @@ void message_header_decode(const unsigned char *data, size_t size,
}
t_pop();
}
+
+struct decode_utf8_context {
+ buffer_t *dest;
+ unsigned int changed:1;
+ unsigned int called:1;
+ unsigned int dtcase:1;
+};
+
+static bool
+decode_utf8_callback(const unsigned char *data, size_t size,
+ const char *charset, void *context)
+{
+ struct decode_utf8_context *ctx = context;
+ struct charset_translation *t;
+
+ /* one call with charset=NULL means nothing changed */
+ if (!ctx->called && charset == NULL)
+ ctx->called = TRUE;
+ else
+ ctx->changed = TRUE;
+
+ if (charset == NULL || charset_is_utf8(charset)) {
+ /* ASCII / UTF-8 */
+ if (ctx->dtcase) {
+ (void)uni_utf8_to_decomposed_titlecase(data, size,
+ ctx->dest);
+ } else {
+ buffer_append(ctx->dest, data, size);
+ }
+ return TRUE;
+ }
+
+ if (charset_to_utf8_begin(charset, ctx->dtcase, &t) < 0) {
+ /* let's just ignore this part */
+ return TRUE;
+ }
+
+ /* ignore any errors */
+ (void)charset_to_utf8(t, data, &size, ctx->dest);
+ charset_to_utf8_end(&t);
+ return TRUE;
+}
+
+bool message_header_decode_utf8(const unsigned char *data, size_t size,
+ buffer_t *dest, bool dtcase)
+{
+ struct decode_utf8_context ctx;
+ size_t used = dest->used;
+
+ memset(&ctx, 0, sizeof(ctx));
+ ctx.dest = dest;
+ ctx.dtcase = dtcase;
+ message_header_decode(data, size, decode_utf8_callback, &ctx);
+ return ctx.changed || (dest->used - used != size);
+}
diff --git a/src/lib-mail/message-header-decode.h b/src/lib-mail/message-header-decode.h
index 6a1e9f2..b765523 100644
--- a/src/lib-mail/message-header-decode.h
+++ b/src/lib-mail/message-header-decode.h
@@ -13,4 +13,10 @@ void message_header_decode(const unsigned char *data, size_t size,
message_header_decode_callback_t *callback,
void *context);
+/* Append decoded RFC2047 header as UTF-8 to given buffer. If dtcase=TRUE,
+ the header is appended through uni_utf8_to_decomposed_titlecase().
+ Returns TRUE if output changed in any way from input. */
+bool message_header_decode_utf8(const unsigned char *data, size_t size,
+ buffer_t *dest, bool dtcase);
+
#endif
diff --git a/src/lib-mail/message-parser.c b/src/lib-mail/message-parser.c
index 4443773..670be66 100644
--- a/src/lib-mail/message-parser.c
+++ b/src/lib-mail/message-parser.c
@@ -1,9 +1,9 @@
/* Copyright (C) 2002-2006 Timo Sirainen */
#include "lib.h"
+#include "str.h"
#include "istream.h"
-#include "strescape.h"
-#include "message-content-parser.h"
+#include "rfc822-parser.h"
#include "message-parser.h"
/* RFC-2046 requires boundaries are max. 70 chars + "--" prefix + "--" suffix.
@@ -388,49 +388,46 @@ static int parse_next_body_to_eof(struct message_parser_ctx *ctx,
return 1;
}
-static void
-parse_content_type(const unsigned char *value, size_t value_len, void *context)
+static void parse_content_type(struct message_parser_ctx *ctx,
+ struct message_header_line *hdr)
{
- struct message_parser_ctx *ctx = context;
- const char *str;
+ struct rfc822_parser_context parser;
+ const char *key, *value;
+ string_t *content_type;
- if (ctx->part_seen_content_type || value_len == 0)
+ if (ctx->part_seen_content_type)
return;
ctx->part_seen_content_type = TRUE;
- t_push();
- str = t_strndup(value, value_len);
- if (strcasecmp(str, "message/rfc822") == 0)
+ rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL);
+ (void)rfc822_skip_lwsp(&parser);
+
+ content_type = t_str_new(64);
+ if (rfc822_parse_content_type(&parser, content_type) < 0)
+ return;
+
+ if (strcasecmp(str_c(content_type), "message/rfc822") == 0)
ctx->part->flags |= MESSAGE_PART_FLAG_MESSAGE_RFC822;
- else if (strncasecmp(str, "text", 4) == 0 &&
- (str[4] == '/' || str[4] == '\0'))
+ else if (strncasecmp(str_c(content_type), "text", 4) == 0 &&
+ (str_len(content_type) == 4 ||
+ str_data(content_type)[4] == '/'))
ctx->part->flags |= MESSAGE_PART_FLAG_TEXT;
- else if (strncasecmp(str, "multipart/", 10) == 0) {
+ else if (strncasecmp(str_c(content_type), "multipart/", 10) == 0) {
ctx->part->flags |= MESSAGE_PART_FLAG_MULTIPART;
- if (strcasecmp(str+10, "digest") == 0)
+ if (strcasecmp(str_c(content_type)+10, "digest") == 0)
ctx->part->flags |= MESSAGE_PART_FLAG_MULTIPART_DIGEST;
}
- t_pop();
-}
-
-static void
-parse_content_type_param(const unsigned char *name, size_t name_len,
- const unsigned char *value, size_t value_len,
- bool value_quoted, void *context)
-{
- struct message_parser_ctx *ctx = context;
- char *boundary;
if ((ctx->part->flags & MESSAGE_PART_FLAG_MULTIPART) == 0 ||
- name_len != 8 || memcasecmp(name, "boundary", 8) != 0)
+ ctx->last_boundary != NULL)
return;
- if (ctx->last_boundary == NULL) {
- boundary = p_strndup(ctx->parser_pool, value, value_len);
- if (value_quoted)
- str_unescape(boundary);
- ctx->last_boundary = boundary;
+ while (rfc822_parse_content_param(&parser, &key, &value) > 0) {
+ if (strcasecmp(key, "boundary") == 0) {
+ ctx->last_boundary = p_strdup(ctx->parser_pool, value);
+ break;
+ }
}
}
@@ -463,10 +460,9 @@ static int parse_next_header(struct message_parser_ctx *ctx,
if (hdr->continues)
hdr->use_full_value = TRUE;
else {
- message_content_parse_header(hdr->full_value,
- hdr->full_value_len,
- parse_content_type,
- parse_content_type_param, ctx);
+ t_push();
+ parse_content_type(ctx, hdr);
+ t_pop();
}
}
diff --git a/src/lib-mail/message-search.c b/src/lib-mail/message-search.c
index db3b4da..c8be4f2 100644
--- a/src/lib-mail/message-search.c
+++ b/src/lib-mail/message-search.c
@@ -3,11 +3,12 @@
#include "lib.h"
#include "buffer.h"
#include "istream.h"
+#include "str.h"
#include "str-find.h"
#include "charset-utf8.h"
+#include "rfc822-parser.h"
#include "message-decoder.h"
#include "message-parser.h"
-#include "message-content-parser.h"
#include "message-search.h"
struct message_search_context {
@@ -25,45 +26,34 @@ struct message_search_context {
unsigned int content_type_text:1; /* text/any or message/any */
};
-static void parse_content_type(const unsigned char *value, size_t value_len,
- void *context)
-{
- struct message_search_context *ctx = context;
- const char *str;
-
- t_push();
- str = t_strndup(value, value_len);
- ctx->content_type_text =
- strncasecmp(str, "text/", 5) == 0 ||
- strncasecmp(str, "message/", 8) == 0;
- t_pop();
-}
-
int message_search_init(pool_t pool, const char *key, const char *charset,
enum message_search_flags flags,
struct message_search_context **ctx_r)
{
struct message_search_context *ctx;
- bool unknown_charset;
+ struct charset_translation *t;
+ string_t *key_utf8;
size_t key_len;
- /* get the key uppercased */
+ if (charset_to_utf8_begin(charset, TRUE, &t) < 0)
+ return 0;
+
t_push();
- key = charset_to_ucase_utf8_string(charset, &unknown_charset,
- (const unsigned char *)key,
- strlen(key), &key_len);
- if (key == NULL) {
+ key_utf8 = t_str_new(I_MAX(128, key_len*2));
+ key_len = strlen(key);
+ if (charset_to_utf8(t, (const unsigned char *)key, &key_len,
+ key_utf8) != CHARSET_RET_OK) {
t_pop();
- return unknown_charset ? 0 : -1;
+ return -1;
}
ctx = *ctx_r = p_new(pool, struct message_search_context, 1);
ctx->pool = pool;
- ctx->key = p_strdup(pool, key);
- ctx->key_len = key_len;
+ ctx->key = p_strdup(pool, str_c(key_utf8));
+ ctx->key_len = str_len(key_utf8);
ctx->key_charset = p_strdup(pool, charset);
ctx->flags = flags;
- ctx->decoder = message_decoder_init_ucase();
+ ctx->decoder = message_decoder_init(TRUE);
ctx->str_find_ctx = str_find_init(pool, ctx->key);
t_pop();
return 1;
@@ -81,6 +71,25 @@ void message_search_deinit(struct message_search_context **_ctx)
p_free(ctx->pool, ctx);
}
+static void parse_content_type(struct message_search_context *ctx,
+ struct message_header_line *hdr)
+{
+ struct rfc822_parser_context parser;
+ string_t *content_type;
+
+ t_push();
+ rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL);
+ (void)rfc822_skip_lwsp(&parser);
+
+ content_type = t_str_new(64);
+ if (rfc822_parse_content_type(&parser, content_type) >= 0) {
+ ctx->content_type_text =
+ strncasecmp(str_c(content_type), "text/", 5) == 0 ||
+ strncasecmp(str_c(content_type), "message/", 8) == 0;
+ }
+ t_pop();
+}
+
static void handle_header(struct message_search_context *ctx,
struct message_header_line *hdr)
{
@@ -90,9 +99,7 @@ static void handle_header(struct message_search_context *ctx,
hdr->use_full_value = TRUE;
return;
}
- message_content_parse_header(hdr->full_value,
- hdr->full_value_len,
- parse_content_type, NULL, ctx);
+ parse_content_type(ctx, hdr);
}
}
diff --git a/src/lib-mail/rfc822-parser.c b/src/lib-mail/rfc822-parser.c
index 2d2d4d6..94f075f 100644
--- a/src/lib-mail/rfc822-parser.c
+++ b/src/lib-mail/rfc822-parser.c
@@ -2,6 +2,7 @@
#include "lib.h"
#include "str.h"
+#include "strescape.h"
#include "rfc822-parser.h"
/*
@@ -308,7 +309,7 @@ rfc822_parse_domain_literal(struct rfc822_parser_context *ctx, string_t *str)
} else if (*ctx->data == ']') {
ctx->data++;
str_append_n(str, start, ctx->data - start);
- return ctx->data != ctx->end;
+ return rfc822_skip_lwsp(ctx);
}
}
@@ -329,13 +330,77 @@ int rfc822_parse_domain(struct rfc822_parser_context *ctx, string_t *str)
if (rfc822_skip_lwsp(ctx) <= 0)
return -1;
- if (*ctx->data == '[') {
- if (rfc822_parse_domain_literal(ctx, str) < 0)
- return -1;
+ if (*ctx->data == '[')
+ return rfc822_parse_domain_literal(ctx, str);
+ else
+ return rfc822_parse_dot_atom(ctx, str);
+}
+
+int rfc822_parse_content_type(struct rfc822_parser_context *ctx, string_t *str)
+{
+ if (rfc822_skip_lwsp(ctx) <= 0)
+ return -1;
+
+ /* get main type */
+ if (rfc822_parse_mime_token(ctx, str) <= 0)
+ return -1;
+
+ /* skip over "/" */
+ if (*ctx->data != '/')
+ return -1;
+ ctx->data++;
+ if (rfc822_skip_lwsp(ctx) <= 0)
+ return -1;
+ str_append_c(str, '/');
+
+ /* get subtype */
+ return rfc822_parse_mime_token(ctx, str);
+}
+
+int rfc822_parse_content_param(struct rfc822_parser_context *ctx,
+ const char **key_r, const char **value_r)
+{
+ string_t *tmp;
+ size_t value_pos;
+ int ret;
+
+ /* .. := *(";" parameter)
+ parameter := attribute "=" value
+ attribute := token
+ value := token / quoted-string
+ */
+ *key_r = NULL;
+ *value_r = NULL;
+
+ if (ctx->data == ctx->end)
+ return 0;
+ if (*ctx->data != ';')
+ return -1;
+ ctx->data++;
+
+ if (rfc822_skip_lwsp(ctx) <= 0)
+ return -1;
+
+ tmp = t_str_new(64);
+ if (rfc822_parse_mime_token(ctx, tmp) <= 0)
+ return -1;
+ str_append_c(tmp, '\0');
+ value_pos = str_len(tmp);
+
+ if (*ctx->data != '=')
+ return -1;
+ ctx->data++;
+
+ if ((ret = rfc822_skip_lwsp(ctx)) <= 0) {
+ /* broken / no value */
+ } else if (*ctx->data == '"') {
+ ret = rfc822_parse_quoted_string(ctx, tmp);
+ str_unescape(str_c_modifiable(tmp) + value_pos);
} else {
- if (rfc822_parse_dot_atom(ctx, str) < 0)
- return -1;
+ ret = rfc822_parse_mime_token(ctx, tmp);
}
- return ctx->data != ctx->end;
+ *key_r = str_c(tmp);
+ *value_r = *key_r + value_pos;
+ return ret < 0 ? -1 : 1;
}
diff --git a/src/lib-mail/rfc822-parser.h b/src/lib-mail/rfc822-parser.h
index ba5b148..0ec54f4 100644
--- a/src/lib-mail/rfc822-parser.h
+++ b/src/lib-mail/rfc822-parser.h
@@ -6,10 +6,17 @@ struct rfc822_parser_context {
string_t *last_comment;
};
+/* Parse given data using RFC 822 token parser. */
void rfc822_parser_init(struct rfc822_parser_context *ctx,
const unsigned char *data, size_t size,
string_t *last_comment);
+/* The functions below return 1 = more data available, 0 = no more data
+ available (but a value might have been returned now), -1 = invalid input.
+
+ LWSP is automatically skipped after value, but not before it. So typically
+ you begin with skipping LWSP and then start using the parse functions. */
+
/* Parse comment. Assumes parser's data points to '(' */
int rfc822_skip_comment(struct rfc822_parser_context *ctx);
/* Skip LWSP if there is any */
@@ -29,4 +36,12 @@ int rfc822_parse_phrase(struct rfc822_parser_context *ctx, string_t *str);
/* dot-atom / domain-literal */
int rfc822_parse_domain(struct rfc822_parser_context *ctx, string_t *str);
+/* Parse Content-Type header's type/subtype. */
+int rfc822_parse_content_type(struct rfc822_parser_context *ctx, string_t *str);
+/* For Content-Type style parameter parsing. Expect ";" key "=" value.
+ value is unescaped if needed. The returned strings are allocated from data
+ stack. Returns 1 = key/value set, 0 = no more data, -1 = invalid input. */
+int rfc822_parse_content_param(struct rfc822_parser_context *ctx,
+ const char **key_r, const char **value_r);
+
#endif
diff --git a/src/lib-settings/settings.c b/src/lib-settings/settings.c
index 9608c47..c9d45cb 100644
--- a/src/lib-settings/settings.c
+++ b/src/lib-settings/settings.c
@@ -1,6 +1,7 @@
-/* Copyright (C) 2002 Timo Sirainen */
+/* Copyright (C) 2002-2007 Timo Sirainen */
#include "lib.h"
+#include "str.h"
#include "istream.h"
#include "strescape.h"
#include "settings.h"
@@ -71,6 +72,7 @@ bool settings_read(const char *path, const char *section,
struct istream *input;
const char *errormsg, *next_section, *name;
char *line, *key, *p, quote;
+ string_t *full_line;
size_t len;
int fd, linenum, last_section_line = 0, skip, sections, root_section;
@@ -90,8 +92,9 @@ bool settings_read(const char *path, const char *section,
next_section = t_strcut(section, '/');
}
+ full_line = t_str_new(512);
linenum = 0; sections = 0; root_section = 0; errormsg = NULL;
- input = i_stream_create_file(fd, default_pool, 2048, TRUE);
+ input = i_stream_create_file(fd, 2048, TRUE);
for (;;) {
line = i_stream_read_next_line(input);
if (line == NULL) {
@@ -140,6 +143,17 @@ bool settings_read(const char *path, const char *section,
len--;
line[len] = '\0';
+ if (len > 0 && line[len-1] == '\\') {
+ /* continues in next line */
+ line[len-1] = '\0';
+ str_append(full_line, line);
+ continue;
+ }
+ if (str_len(full_line) > 0) {
+ str_append(full_line, line);
+ line = str_c_modifiable(full_line);
+ }
+
/* a) key = value
b) section_type [section_name] {
c) } */
@@ -246,6 +260,7 @@ bool settings_read(const char *path, const char *section,
path, linenum, errormsg);
break;
}
+ str_truncate(full_line, 0);
}
i_stream_destroy(&input);
diff --git a/src/lib-storage/index/cydir/cydir-mail.c b/src/lib-storage/index/cydir/cydir-mail.c
index db2eee7..d995615 100644
--- a/src/lib-storage/index/cydir/cydir-mail.c
+++ b/src/lib-storage/index/cydir/cydir-mail.c
@@ -84,7 +84,7 @@ static uoff_t cydir_mail_get_physical_size(struct mail *_mail)
return data->physical_size;
if (cydir_mail_stat(_mail, &st) < 0)
- return (time_t)-1;
+ return (uoff_t)-1;
data->physical_size = data->virtual_size = st.st_size;
index_mail_cache_add(mail, MAIL_CACHE_PHYSICAL_FULL_SIZE,
@@ -113,8 +113,7 @@ cydir_mail_get_stream(struct mail *_mail, struct message_size *hdr_size,
return NULL;
}
mail->data.stream =
- i_stream_create_file(fd, default_pool,
- MAIL_READ_BLOCK_SIZE, TRUE);
+ i_stream_create_file(fd, MAIL_READ_BLOCK_SIZE, TRUE);
}
return index_mail_init_stream(mail, hdr_size, body_size);
diff --git a/src/lib-storage/index/cydir/cydir-save.c b/src/lib-storage/index/cydir/cydir-save.c
index 53f9f7c..07b4321 100644
--- a/src/lib-storage/index/cydir/cydir-save.c
+++ b/src/lib-storage/index/cydir/cydir-save.c
@@ -85,8 +85,8 @@ int cydir_save_init(struct mailbox_transaction_context *_t,
path = cydir_get_save_path(ctx, ctx->mail_count);
ctx->fd = open(path, O_WRONLY | O_CREAT | O_EXCL, 0660);
if (ctx->fd != -1) {
- output = o_stream_create_file(ctx->fd, default_pool, 0, FALSE);
- ctx->output = o_stream_create_crlf(default_pool, output);
+ output = o_stream_create_file(ctx->fd, 0, FALSE);
+ ctx->output = o_stream_create_crlf(output);
o_stream_unref(&output);
if (received_date != (time_t)-1) {
diff --git a/src/lib-storage/index/cydir/cydir-storage.c b/src/lib-storage/index/cydir/cydir-storage.c
index 994dcc6..f5975b6 100644
--- a/src/lib-storage/index/cydir/cydir-storage.c
+++ b/src/lib-storage/index/cydir/cydir-storage.c
@@ -347,7 +347,8 @@ static void cydir_notify_changes(struct mailbox *box)
index_mailbox_check_add(&mbox->ibox, mbox->path);
}
-static int cydir_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
+static int cydir_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx
+ __attr_unused__,
const char *dir, const char *fname,
enum mailbox_list_file_type type,
enum mailbox_info_flags *flags)
@@ -359,9 +360,9 @@ static int cydir_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
/* try to avoid stat() with these checks */
if (type != MAILBOX_LIST_FILE_TYPE_DIR &&
type != MAILBOX_LIST_FILE_TYPE_SYMLINK &&
- type != MAILBOX_LIST_FILE_TYPE_UNKNOWN &&
- (ctx->flags & MAILBOX_LIST_ITER_RETURN_NO_FLAGS) != 0) {
+ type != MAILBOX_LIST_FILE_TYPE_UNKNOWN) {
/* it's a file */
+ *flags |= MAILBOX_NOSELECT | MAILBOX_NOINFERIORS;
return 0;
}
@@ -376,7 +377,8 @@ static int cydir_list_iter_is_mailbox(struct mailbox_list_iterate_context *ctx,
ret = 0;
}
} else {
- /* non-selectable, but may contain subdirs */
+ /* non-selectable. probably either access denied, or symlink
+ destination not found. don't bother logging errors. */
*flags |= MAILBOX_NOSELECT;
}
t_pop();
diff --git a/src/lib-storage/index/dbox/dbox-file.c b/src/lib-storage/index/dbox/dbox-file.c
index 7eba324..6d4ca35 100644
--- a/src/lib-storage/index/dbox/dbox-file.c
+++ b/src/lib-storage/index/dbox/dbox-file.c
@@ -132,8 +132,7 @@ int dbox_file_seek(struct dbox_mailbox *mbox, uint32_t file_seq, uoff_t offset,
}
mbox->file->input =
- i_stream_create_file(mbox->file->fd, default_pool,
- 65536, FALSE);
+ i_stream_create_file(mbox->file->fd, 65536, FALSE);
if (dbox_file_read_header(mbox, mbox->file) < 0)
return -1;
diff --git a/src/lib-storage/index/dbox/dbox-mail.c b/src/lib-storage/index/dbox/dbox-mail.c
index d59dd27..659b001 100644
--- a/src/lib-storage/index/dbox/dbox-mail.c
+++ b/src/lib-storage/index/dbox/dbox-mail.c
@@ -229,8 +229,7 @@ dbox_mail_get_stream(struct mail *_mail,
offset += mbox->file->mail_header_size;
mail->data.stream =
- i_stream_create_limit(default_pool, mbox->file->input,
- offset,
+ i_stream_create_limit(mbox->file->input, offset,
mbox->file->seeked_mail_size);
}
diff --git a/src/lib-storage/index/dbox/dbox-sync-expunge.c b/src/lib-storage/index/dbox/dbox-sync-expunge.c
index 2cf3ed5..b7eb66c 100644
--- a/src/lib-storage/index/dbox/dbox-sync-expunge.c
+++ b/src/lib-storage/index/dbox/dbox-sync-expunge.c
@@ -145,7 +145,7 @@ static int dbox_sync_expunge_copy(struct dbox_sync_context *ctx,
/* try again with another file name */
}
- output = o_stream_create_file(fd, default_pool, 0, FALSE);
+ output = o_stream_create_file(fd, 0, FALSE);
lock_path = file_dotlock_get_lock_path(dotlock);
memset(&dest_entry, 0, sizeof(dest_entry));
@@ -190,7 +190,7 @@ static int dbox_sync_expunge_copy(struct dbox_sync_context *ctx,
/* copy the mail */
full_size = mbox->file->mail_header_size +
mbox->file->seeked_mail_size;
- input = i_stream_create_limit(default_pool, mbox->file->input,
+ input = i_stream_create_limit(mbox->file->input,
mbox->file->seeked_offset,
full_size);
bytes = o_stream_send_istream(output, input);
diff --git a/src/lib-storage/index/dbox/dbox-uidlist.c b/src/lib-storage/index/dbox/dbox-uidlist.c
index 3d7e1ad..c9fd1d4 100644
--- a/src/lib-storage/index/dbox/dbox-uidlist.c
+++ b/src/lib-storage/index/dbox/dbox-uidlist.c
@@ -353,7 +353,7 @@ static int dbox_uidlist_read(struct dbox_uidlist *uidlist)
uidlist->ino = st.st_ino;
uidlist->mtime = st.st_mtime;
- input = i_stream_create_file(uidlist->fd, default_pool, 65536, FALSE);
+ input = i_stream_create_file(uidlist->fd, 65536, FALSE);
/* read header: <version> <uidvalidity> <next-uid>.
Note that <next-uid> may be updated by UID lines, so it can't be
@@ -559,7 +559,7 @@ static int dbox_uidlist_full_rewrite(struct dbox_uidlist *uidlist)
return 0;
}
- output = o_stream_create_file(uidlist->lock_fd, default_pool, 0, FALSE);
+ output = o_stream_create_file(uidlist->lock_fd, 0, FALSE);
t_push();
str = t_str_new(256);
@@ -739,7 +739,7 @@ static int dbox_uidlist_append_changes(struct dbox_uidlist_append_ctx *ctx)
"lseek(%s) failed: %m", ctx->uidlist->path);
return -1;
}
- output = o_stream_create_file(ctx->uidlist->fd, default_pool, 0, FALSE);
+ output = o_stream_create_file(ctx->uidlist->fd, 0, FALSE);
uid_start = ctx->uidlist->last_uid + 1;
@@ -967,9 +967,8 @@ dbox_file_append(struct dbox_uidlist_append_ctx *ctx,
file->path = i_strdup(path);
file->fd = fd;
- file->input = i_stream_create_file(file->fd, default_pool,
- 65536, FALSE);
- file->output = o_stream_create_file(file->fd, default_pool, 0, FALSE);
+ file->input = i_stream_create_file(file->fd, 65536, FALSE);
+ file->output = o_stream_create_file(file->fd, 0, FALSE);
if ((uoff_t)st->st_size < sizeof(struct dbox_file_header)) {
if (dbox_file_write_header(mbox, file) < 0) {
dbox_file_close(file);
@@ -1152,7 +1151,7 @@ int dbox_uidlist_append_locked(struct dbox_uidlist_append_ctx *ctx,
/* we'll always use CRLF linefeeds for mails (but not the header,
so don't do this before dbox_file_write_header()) */
- output = o_stream_create_crlf(default_pool, file->output);
+ output = o_stream_create_crlf(file->output);
o_stream_unref(&file->output);
file->output = output;
diff --git a/src/lib-storage/index/index-mail-headers.c b/src/lib-storage/index/index-mail-headers.c
index 81879c1..bcf69f1 100644
--- a/src/lib-storage/index/index-mail-headers.c
+++ b/src/lib-storage/index/index-mail-headers.c
@@ -7,6 +7,7 @@
#include "str.h"
#include "message-date.h"
#include "message-parser.h"
+#include "message-header-decode.h"
#include "istream-tee.h"
#include "istream-header-filter.h"
#include "imap-envelope.h"
@@ -349,9 +350,9 @@ struct istream *index_mail_cache_parse_init(struct mail *_mail,
i_assert(mail->data.parser_ctx == NULL);
- tee = tee_i_stream_create(input, default_pool);
- input = tee_i_stream_create_child(tee, default_pool);
- input2 = tee_i_stream_create_child(tee, default_pool);
+ tee = tee_i_stream_create(input);
+ input = tee_i_stream_create_child(tee);
+ input2 = tee_i_stream_create_child(tee);
index_mail_parse_header_init(mail, NULL);
mail->data.parser_ctx =
@@ -547,9 +548,9 @@ index_mail_get_parsed_header(struct index_mail *mail, unsigned int field_idx)
return array_idx(&header_values, 0);
}
-const char *const *index_mail_get_headers(struct mail *_mail, const char *field)
+static const char *const *
+index_mail_get_raw_headers(struct index_mail *mail, const char *field)
{
- struct index_mail *mail = (struct index_mail *)_mail;
const char *headers[2], *value;
struct mailbox_header_lookup_ctx *headers_ctx;
unsigned char *data;
@@ -620,11 +621,62 @@ const char *const *index_mail_get_headers(struct mail *_mail, const char *field)
return array_idx(&header_values, 0);
}
-const char *index_mail_get_first_header(struct mail *mail, const char *field)
+static const char *const *
+index_mail_headers_decode(struct index_mail *mail, const char *const *list,
+ unsigned int max_count)
+{
+ const char **decoded_list;
+ unsigned int i, count;
+ buffer_t *buf;
+
+ count = strarray_length(list);
+ if (count > max_count)
+ count = max_count;
+ decoded_list = p_new(mail->data_pool, const char *, count + 1);
+
+ t_push();
+ buf = buffer_create_dynamic(pool_datastack_create(), 512);
+
+ for (i = 0; i < count; i++) {
+ buffer_set_used_size(buf, 0);
+ if (!message_header_decode_utf8((const unsigned char *)list[i],
+ strlen(list[i]), buf, FALSE))
+ decoded_list[i] = list[i];
+ else {
+ decoded_list[i] = p_strndup(mail->data_pool,
+ buf->data, buf->used);
+ }
+ }
+ t_pop();
+ return decoded_list;
+}
+
+const char *const *index_mail_get_headers(struct mail *_mail, const char *field,
+ bool decode_to_utf8)
{
- const char *const *list = index_mail_get_headers(mail, field);
+ struct index_mail *mail = (struct index_mail *)_mail;
+ const char *const *list;
+
+ list = index_mail_get_raw_headers(mail, field);
+ if (!decode_to_utf8 || list == NULL || *list == NULL)
+ return list;
+
+ return index_mail_headers_decode(mail, list, (unsigned int)-1);
+}
+
+const char *index_mail_get_first_header(struct mail *_mail, const char *field,
+ bool decode_to_utf8)
+{
+ struct index_mail *mail = (struct index_mail *)_mail;
+ const char *const *list;
+
+ list = index_mail_get_raw_headers(mail, field);
+ if (list == NULL || *list == NULL)
+ return NULL;
- return list == NULL ? NULL : list[0];
+ if (decode_to_utf8)
+ list = index_mail_headers_decode(mail, list, 1);
+ return list[0];
}
static void header_cache_callback(struct message_header_line *hdr,
@@ -658,8 +710,7 @@ index_mail_get_header_stream(struct mail *_mail,
if (mail->data.filter_stream != NULL)
i_stream_destroy(&mail->data.filter_stream);
mail->data.filter_stream =
- i_stream_create_from_data(default_pool,
- str_data(dest),
+ i_stream_create_from_data(str_data(dest),
str_len(dest));
return mail->data.filter_stream;
}
diff --git a/src/lib-storage/index/index-mail.h b/src/lib-storage/index/index-mail.h
index acfdbfc..18eed3a 100644
--- a/src/lib-storage/index/index-mail.h
+++ b/src/lib-storage/index/index-mail.h
@@ -146,9 +146,11 @@ int index_mail_parse_headers(struct index_mail *mail,
struct mailbox_header_lookup_ctx *headers);
void index_mail_headers_get_envelope(struct index_mail *mail);
-const char *index_mail_get_first_header(struct mail *_mail, const char *field);
+const char *index_mail_get_first_header(struct mail *_mail, const char *field,
+ bool decode_to_utf8);
const char *const *
-index_mail_get_headers(struct mail *_mail, const char *field);
+index_mail_get_headers(struct mail *_mail, const char *field,
+ bool decode_to_utf8);
struct istream *
index_mail_get_header_stream(struct mail *_mail,
struct mailbox_header_lookup_ctx *headers);
diff --git a/src/lib-storage/index/index-sort.c b/src/lib-storage/index/index-sort.c
index 36eb2b3..19b286c 100644
--- a/src/lib-storage/index/index-sort.c
+++ b/src/lib-storage/index/index-sort.c
@@ -31,6 +31,7 @@
#include "array.h"
#include "bsearch-insert-pos.h"
#include "str.h"
+#include "unichar.h"
#include "message-address.h"
#include "imap-base-subject.h"
#include "index-storage.h"
@@ -157,7 +158,7 @@ static const char *get_first_mailbox(struct mail *mail, const char *header)
struct message_address *addr;
const char *str;
- str = mail_get_first_header(mail, header);
+ str = mail_get_first_header_utf8(mail, header);
if (str == NULL)
return "";
@@ -171,6 +172,7 @@ static const char *
sort_header_get(enum mail_sort_type sort_type, struct mail *mail, uint32_t seq)
{
const char *str;
+ string_t *buf;
mail_set_seq(mail, seq);
switch (sort_type & MAIL_SORT_MASK) {
@@ -180,14 +182,21 @@ sort_header_get(enum mail_sort_type sort_type, struct mail *mail, uint32_t seq)
imap_get_base_subject_cased(pool_datastack_create(),
str, NULL);
case MAIL_SORT_CC:
- return get_first_mailbox(mail, "Cc");
+ str = get_first_mailbox(mail, "Cc");
+ break;
case MAIL_SORT_FROM:
- return get_first_mailbox(mail, "From");
+ str = get_first_mailbox(mail, "From");
+ break;
case MAIL_SORT_TO:
- return get_first_mailbox(mail, "To");
+ str = get_first_mailbox(mail, "To");
+ break;
default:
i_unreached();
}
+
+ buf = t_str_new(128);
+ (void)uni_utf8_to_decomposed_titlecase(str, (size_t)-1, buf);
+ return str_c(buf);
}
static int sort_node_cmp_type(struct sort_cmp_context *ctx,
@@ -213,7 +222,7 @@ static int sort_node_cmp_type(struct sort_cmp_context *ctx,
sort_header_get(sort_type, ctx->mail, n1->seq);
str2 = sort_header_get(sort_type, ctx->mail, n2->seq);
- ret = strcasecmp(str1, str2);
+ ret = strcmp(str1, str2);
t_pop();
break;
case MAIL_SORT_ARRIVAL:
@@ -358,9 +367,9 @@ index_sort_add_ids_range(struct mail_search_sort_program *program,
str = sort_header_get(program->sort_program[0], mail,
nodes[i].seq);
- if (i == idx2 && strcasecmp(str, last_str) == 0)
+ if (i == idx2 && strcmp(str, last_str) == 0)
nodes[i].sort_id = last_id;
- else if (strcasecmp(str, str_c(prev_str)) == 0 && prev_id != 0)
+ else if (strcmp(str, str_c(prev_str)) == 0 && prev_id != 0)
nodes[i].sort_id = prev_id;
else {
/* divide the available space so that each message gets
diff --git a/src/lib-storage/index/maildir/maildir-keywords.c b/src/lib-storage/index/maildir/maildir-keywords.c
index 8349741..e7194e1 100644
--- a/src/lib-storage/index/maildir/maildir-keywords.c
+++ b/src/lib-storage/index/maildir/maildir-keywords.c
@@ -133,7 +133,7 @@ static int maildir_keywords_sync(struct maildir_keywords *mk)
}
maildir_keywords_clear(mk);
- input = i_stream_create_file(fd, default_pool, 1024, FALSE);
+ input = i_stream_create_file(fd, 1024, FALSE);
while ((line = i_stream_read_next_line(input)) != NULL) {
p = strchr(line, ' ');
if (p == NULL) {
diff --git a/src/lib-storage/index/maildir/maildir-mail.c b/src/lib-storage/index/maildir/maildir-mail.c
index fd89bbd..2e397cf 100644
--- a/src/lib-storage/index/maildir/maildir-mail.c
+++ b/src/lib-storage/index/maildir/maildir-mail.c
@@ -62,8 +62,7 @@ maildir_open_mail(struct maildir_mailbox *mbox, struct mail *mail,
return NULL;
}
- return i_stream_create_file(fd, default_pool,
- MAIL_READ_BLOCK_SIZE, TRUE);
+ return i_stream_create_file(fd, MAIL_READ_BLOCK_SIZE, TRUE);
}
static int maildir_mail_stat(struct mail *mail, struct stat *st)
diff --git a/src/lib-storage/index/maildir/maildir-save.c b/src/lib-storage/index/maildir/maildir-save.c
index 3a36f82..4d03143 100644
--- a/src/lib-storage/index/maildir/maildir-save.c
+++ b/src/lib-storage/index/maildir/maildir-save.c
@@ -377,11 +377,10 @@ int maildir_save_init(struct mailbox_transaction_context *_t,
ctx->received_date = received_date;
ctx->input = input;
- output = o_stream_create_file(ctx->fd, system_pool, 0, FALSE);
+ output = o_stream_create_file(ctx->fd, 0, FALSE);
ctx->output = (ctx->mbox->storage->storage.flags &
MAIL_STORAGE_FLAG_SAVE_CRLF) != 0 ?
- o_stream_create_crlf(default_pool, output) :
- o_stream_create_lf(default_pool, output);
+ o_stream_create_crlf(output) : o_stream_create_lf(output);
o_stream_unref(&output);
flags &= ~MAIL_RECENT;
diff --git a/src/lib-storage/index/maildir/maildir-uidlist.c b/src/lib-storage/index/maildir/maildir-uidlist.c
index db87689..9bd8bf5 100644
--- a/src/lib-storage/index/maildir/maildir-uidlist.c
+++ b/src/lib-storage/index/maildir/maildir-uidlist.c
@@ -523,7 +523,7 @@ maildir_uidlist_update_read(struct maildir_uidlist *uidlist,
st.st_size/8));
}
- input = i_stream_create_file(fd, default_pool, 4096, FALSE);
+ input = i_stream_create_file(fd, 4096, FALSE);
i_stream_seek(input, uidlist->last_read_offset);
orig_next_uid = uidlist->next_uid;
@@ -804,7 +804,7 @@ static int maildir_uidlist_write_fd(struct maildir_uidlist *uidlist, int fd,
i_assert(fd != -1);
- output = o_stream_create_file(fd, default_pool, 0, FALSE);
+ output = o_stream_create_file(fd, 0, FALSE);
str = t_str_new(512);
if (output->offset == 0) {
diff --git a/src/lib-storage/index/mbox/istream-raw-mbox.c b/src/lib-storage/index/mbox/istream-raw-mbox.c
index 6cd8afd..5b57839 100644
--- a/src/lib-storage/index/mbox/istream-raw-mbox.c
+++ b/src/lib-storage/index/mbox/istream-raw-mbox.c
@@ -343,14 +343,14 @@ static const struct stat *_stat(struct _istream *stream, bool exact)
return &stream->statbuf;
}
-struct istream *i_stream_create_raw_mbox(pool_t pool, struct istream *input,
+struct istream *i_stream_create_raw_mbox(struct istream *input,
bool kludge_one_mail_only)
{
struct raw_mbox_istream *rstream;
i_stream_ref(input);
- rstream = p_new(pool, struct raw_mbox_istream, 1);
+ rstream = i_new(struct raw_mbox_istream, 1);
rstream->one_mail_only = kludge_one_mail_only;
rstream->input = input;
@@ -370,7 +370,7 @@ struct istream *i_stream_create_raw_mbox(pool_t pool, struct istream *input,
rstream->istream.istream.blocking = input->blocking;
rstream->istream.istream.seekable = input->seekable;
- return _i_stream_create(&rstream->istream, pool, -1,
+ return _i_stream_create(&rstream->istream, -1,
input->real_stream->abs_start_offset);
}
diff --git a/src/lib-storage/index/mbox/istream-raw-mbox.h b/src/lib-storage/index/mbox/istream-raw-mbox.h
index b6a74fa..582f812 100644
--- a/src/lib-storage/index/mbox/istream-raw-mbox.h
+++ b/src/lib-storage/index/mbox/istream-raw-mbox.h
@@ -3,7 +3,7 @@
/* Create a mbox stream for parsing mbox. Reading stops before From-line,
you'll have to call istream_raw_mbox_next() to get to next message. */
-struct istream *i_stream_create_raw_mbox(pool_t pool, struct istream *input,
+struct istream *i_stream_create_raw_mbox(struct istream *input,
bool kludge_one_mail_only);
/* Return offset to beginning of the "\nFrom"-line. */
diff --git a/src/lib-storage/index/mbox/mbox-file.c b/src/lib-storage/index/mbox/mbox-file.c
index cfbe626..f7166a9 100644
--- a/src/lib-storage/index/mbox/mbox-file.c
+++ b/src/lib-storage/index/mbox/mbox-file.c
@@ -73,8 +73,7 @@ int mbox_file_open_stream(struct mbox_mailbox *mbox)
i_assert(mbox->mbox_fd == -1 && mbox->mbox_readonly);
mbox->mbox_stream =
- i_stream_create_raw_mbox(default_pool,
- mbox->mbox_file_stream,
+ i_stream_create_raw_mbox(mbox->mbox_file_stream,
one_mail_only);
return 0;
}
@@ -84,18 +83,16 @@ int mbox_file_open_stream(struct mbox_mailbox *mbox)
return -1;
}
- if (mbox->mbox_writeonly) {
+ if (mbox->mbox_writeonly)
+ mbox->mbox_file_stream = i_stream_create_from_data(NULL, 0);
+ else {
mbox->mbox_file_stream =
- i_stream_create_from_data(default_pool, NULL, 0);
- } else {
- mbox->mbox_file_stream =
- i_stream_create_file(mbox->mbox_fd, default_pool,
+ i_stream_create_file(mbox->mbox_fd,
MAIL_READ_BLOCK_SIZE, FALSE);
}
mbox->mbox_stream =
- i_stream_create_raw_mbox(default_pool, mbox->mbox_file_stream,
- one_mail_only);
+ i_stream_create_raw_mbox(mbox->mbox_file_stream, one_mail_only);
return 0;
}
diff --git a/src/lib-storage/index/mbox/mbox-mail.c b/src/lib-storage/index/mbox/mbox-mail.c
index 79190d9..5fef2e9 100644
--- a/src/lib-storage/index/mbox/mbox-mail.c
+++ b/src/lib-storage/index/mbox/mbox-mail.c
@@ -209,7 +209,7 @@ static struct istream *mbox_mail_get_stream(struct mail *_mail,
raw_stream = mbox->mbox_stream;
offset = istream_raw_mbox_get_header_offset(raw_stream);
- raw_stream = i_stream_create_limit(default_pool, raw_stream,
+ raw_stream = i_stream_create_limit(raw_stream,
offset, (uoff_t)-1);
data->stream =
i_stream_create_header_filter(raw_stream,
diff --git a/src/lib-storage/index/mbox/mbox-save.c b/src/lib-storage/index/mbox/mbox-save.c
index 2ffd3b0..fa69025 100644
--- a/src/lib-storage/index/mbox/mbox-save.c
+++ b/src/lib-storage/index/mbox/mbox-save.c
@@ -321,8 +321,7 @@ mbox_save_init_file(struct mbox_save_context *ctx,
if (mbox_seek_to_end(ctx, &ctx->append_offset) < 0)
return -1;
- ctx->output = o_stream_create_file(mbox->mbox_fd, default_pool,
- 0, FALSE);
+ ctx->output = o_stream_create_file(mbox->mbox_fd, 0, FALSE);
}
return 0;
}
@@ -477,8 +476,8 @@ int mbox_save_init(struct mailbox_transaction_context *_t,
ctx->body_output =
(mbox->storage->storage.flags &
MAIL_STORAGE_FLAG_SAVE_CRLF) != 0 ?
- o_stream_create_crlf(default_pool, ctx->output) :
- o_stream_create_lf(default_pool, ctx->output);
+ o_stream_create_crlf(ctx->output) :
+ o_stream_create_lf(ctx->output);
if (ctx->mail != NULL) {
input = index_mail_cache_parse_init(ctx->mail,
ctx->input);
diff --git a/src/lib-storage/index/mbox/mbox-sync-rewrite.c b/src/lib-storage/index/mbox/mbox-sync-rewrite.c
index fa62858..3338bb7 100644
--- a/src/lib-storage/index/mbox/mbox-sync-rewrite.c
+++ b/src/lib-storage/index/mbox/mbox-sync-rewrite.c
@@ -26,8 +26,7 @@ int mbox_move(struct mbox_sync_context *sync_ctx,
i_stream_sync(sync_ctx->input);
- output = o_stream_create_file(sync_ctx->write_fd, default_pool,
- 4096, FALSE);
+ output = o_stream_create_file(sync_ctx->write_fd, 4096, FALSE);
i_stream_seek(sync_ctx->file_input, source);
if (o_stream_seek(output, dest) < 0) {
mbox_set_syscall_error(sync_ctx->mbox,
@@ -36,8 +35,7 @@ int mbox_move(struct mbox_sync_context *sync_ctx,
return -1;
}
- input = i_stream_create_limit(default_pool, sync_ctx->file_input,
- source, size);
+ input = i_stream_create_limit(sync_ctx->file_input, source, size);
ret = o_stream_send_istream(output, input);
i_stream_unref(&input);
diff --git a/src/lib-storage/list/subscription-file.c b/src/lib-storage/list/subscription-file.c
index 5aa1ddf..cc24560 100644
--- a/src/lib-storage/list/subscription-file.c
+++ b/src/lib-storage/list/subscription-file.c
@@ -16,11 +16,9 @@
#define SUBSCRIPTION_FILE_CHANGE_TIMEOUT 30
struct subsfile_list_context {
- pool_t pool;
-
struct mailbox_list *list;
struct istream *input;
- const char *path;
+ char *path;
bool failed;
};
@@ -115,10 +113,10 @@ int subsfile_set_subscribed(struct mailbox_list *list, const char *path,
}
input = fd_in == -1 ? NULL :
- i_stream_create_file(fd_in, default_pool,
- list->mailbox_name_max_length+1, TRUE);
- output = o_stream_create_file(fd_out, default_pool,
- list->mailbox_name_max_length+1, FALSE);
+ i_stream_create_file(fd_in, list->mailbox_name_max_length+1,
+ TRUE);
+ output = o_stream_create_file(fd_out, list->mailbox_name_max_length+1,
+ FALSE);
found = FALSE;
while ((line = next_line(list, path, input,
&failed, FALSE)) != NULL) {
@@ -176,14 +174,9 @@ struct subsfile_list_context *
subsfile_list_init(struct mailbox_list *list, const char *path)
{
struct subsfile_list_context *ctx;
- pool_t pool;
int fd;
- pool = pool_alloconly_create("subsfile_list",
- list->mailbox_name_max_length + 1024);
-
- ctx = p_new(pool, struct subsfile_list_context, 1);
- ctx->pool = pool;
+ ctx = i_new(struct subsfile_list_context, 1);
ctx->list = list;
fd = nfs_safe_open(path, O_RDONLY);
@@ -193,12 +186,10 @@ subsfile_list_init(struct mailbox_list *list, const char *path)
ctx->failed = TRUE;
}
} else {
- ctx->input =
- i_stream_create_file(fd, pool,
- list->mailbox_name_max_length+1,
- TRUE);
+ ctx->input = i_stream_create_file(fd,
+ list->mailbox_name_max_length+1, TRUE);
}
- ctx->path = p_strdup(pool, path);
+ ctx->path = i_strdup(path);
return ctx;
}
@@ -208,7 +199,8 @@ int subsfile_list_deinit(struct subsfile_list_context *ctx)
if (ctx->input != NULL)
i_stream_destroy(&ctx->input);
- pool_unref(ctx->pool);
+ i_free(ctx->path);
+ i_free(ctx);
return ret;
}
@@ -247,7 +239,7 @@ const char *subsfile_list_next(struct subsfile_list_context *ctx)
return NULL;
}
- ctx->input = i_stream_create_file(fd, ctx->pool,
+ ctx->input = i_stream_create_file(fd,
ctx->list->mailbox_name_max_length+1,
TRUE);
}
diff --git a/src/lib-storage/mail-storage-private.h b/src/lib-storage/mail-storage-private.h
index 9e81307..ec8ae3e 100644
--- a/src/lib-storage/mail-storage-private.h
+++ b/src/lib-storage/mail-storage-private.h
@@ -208,8 +208,10 @@ struct mail_vfuncs {
uoff_t (*get_virtual_size)(struct mail *mail);
uoff_t (*get_physical_size)(struct mail *mail);
- const char *(*get_first_header)(struct mail *mail, const char *field);
- const char *const *(*get_headers)(struct mail *mail, const char *field);
+ const char *(*get_first_header)(struct mail *mail, const char *field,
+ bool decode_to_utf8);
+ const char *const *(*get_headers)(struct mail *mail, const char *field,
+ bool decode_to_utf8);
struct istream *
(*get_header_stream)(struct mail *mail,
struct mailbox_header_lookup_ctx *headers);
diff --git a/src/lib-storage/mail-storage.h b/src/lib-storage/mail-storage.h
index 27918ad..2192203 100644
--- a/src/lib-storage/mail-storage.h
+++ b/src/lib-storage/mail-storage.h
@@ -424,8 +424,12 @@ uoff_t mail_get_physical_size(struct mail *mail);
/* Get value for single header field */
const char *mail_get_first_header(struct mail *mail, const char *field);
+/* Like mail_get_first_header(), but decode MIME encoded words to UTF-8 */
+const char *mail_get_first_header_utf8(struct mail *mail, const char *field);
/* Return a NULL-terminated list of values for each found field. */
const char *const *mail_get_headers(struct mail *mail, const char *field);
+/* Like mail_get_headers(), but decode MIME encoded words to UTF-8 */
+const char *const *mail_get_headers_utf8(struct mail *mail, const char *field);
/* Returns stream containing specified headers. */
struct istream *
mail_get_header_stream(struct mail *mail,
diff --git a/src/lib-storage/mail.c b/src/lib-storage/mail.c
index 61846a0..37566d7 100644
--- a/src/lib-storage/mail.c
+++ b/src/lib-storage/mail.c
@@ -93,14 +93,28 @@ const char *mail_get_first_header(struct mail *mail, const char *field)
{
struct mail_private *p = (struct mail_private *)mail;
- return p->v.get_first_header(mail, field);
+ return p->v.get_first_header(mail, field, FALSE);
+}
+
+const char *mail_get_first_header_utf8(struct mail *mail, const char *field)
+{
+ struct mail_private *p = (struct mail_private *)mail;
+
+ return p->v.get_first_header(mail, field, TRUE);
}
const char *const *mail_get_headers(struct mail *mail, const char *field)
{
struct mail_private *p = (struct mail_private *)mail;
- return p->v.get_headers(mail, field);
+ return p->v.get_headers(mail, field, FALSE);
+}
+
+const char *const *mail_get_headers_utf8(struct mail *mail, const char *field)
+{
+ struct mail_private *p = (struct mail_private *)mail;
+
+ return p->v.get_headers(mail, field, TRUE);
}
struct istream *
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index 059fa0a..385d065 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -1,5 +1,13 @@
noinst_LIBRARIES = liblib.a
+BUILT_SOURCES = unicodemap.c
+
+EXTRA_DIST = unicodemap.c unicodemap.pl
+
+unicodemap.c:
+ test -f UnicodeData.txt || wget http://www.unicode.org/Public/UNIDATA/UnicodeData.txt
+ perl unicodemap.pl < UnicodeData.txt > $@
+
liblib_a_SOURCES = \
backtrace-string.c \
base64.c \
diff --git a/src/lib/bsearch-insert-pos.h b/src/lib/bsearch-insert-pos.h
index 4558ba9..daaa101 100644
--- a/src/lib/bsearch-insert-pos.h
+++ b/src/lib/bsearch-insert-pos.h
@@ -1,6 +1,25 @@
#ifndef __BSEARCH_INSERT_POS
#define __BSEARCH_INSERT_POS
+/* Binary search template */
+#define BINARY_NUMBER_SEARCH(data, count, value, idx_r) \
+ unsigned int idx, left_idx, right_idx; \
+ \
+ idx = 0; left_idx = 0; right_idx = (count); \
+ while (left_idx < right_idx) { \
+ idx = (left_idx + right_idx) / 2; \
+ \
+ if ((data)[idx] < (value)) \
+ left_idx = idx+1; \
+ else if ((data)[idx] > (value)) \
+ right_idx = idx; \
+ else { \
+ *(idx_r) = idx; \
+ return TRUE; \
+ } \
+ } \
+ return FALSE
+
/* If key is found, returns TRUE and sets idx_r to the position where the key
was found. If key isn't found, returns FALSE and sets idx_r to the position
where the key should be inserted. */
diff --git a/src/lib/file-copy.c b/src/lib/file-copy.c
index 1c0ba00..b7b0256 100644
--- a/src/lib/file-copy.c
+++ b/src/lib/file-copy.c
@@ -68,8 +68,8 @@ static int file_copy_to_tmp(const char *srcpath, const char *tmppath,
/* try to change the group, don't really care if it fails */
(void)fchown(fd_out, (uid_t)-1, st.st_gid);
- input = i_stream_create_file(fd_in, default_pool, 0, FALSE);
- output = o_stream_create_file(fd_out, default_pool, 0, FALSE);
+ input = i_stream_create_file(fd_in, 0, FALSE);
+ output = o_stream_create_file(fd_out, 0, FALSE);
while ((ret = o_stream_send_istream(output, input)) > 0) ;
diff --git a/src/lib/iostream-internal.h b/src/lib/iostream-internal.h
index 16572f1..d8f7743 100644
--- a/src/lib/iostream-internal.h
+++ b/src/lib/iostream-internal.h
@@ -4,7 +4,6 @@
/* This file is private to input stream and output stream implementations */
struct _iostream {
- pool_t pool;
int refcount;
void (*close)(struct _iostream *stream);
@@ -12,7 +11,7 @@ struct _iostream {
void (*set_max_buffer_size)(struct _iostream *stream, size_t max_size);
};
-void _io_stream_init(pool_t pool, struct _iostream *stream);
+void _io_stream_init(struct _iostream *stream);
void _io_stream_ref(struct _iostream *stream);
void _io_stream_unref(struct _iostream *stream);
void _io_stream_close(struct _iostream *stream);
diff --git a/src/lib/iostream.c b/src/lib/iostream.c
index aafbed5..78aab85 100644
--- a/src/lib/iostream.c
+++ b/src/lib/iostream.c
@@ -3,10 +3,8 @@
#include "lib.h"
#include "iostream-internal.h"
-void _io_stream_init(pool_t pool, struct _iostream *stream)
+void _io_stream_init(struct _iostream *stream)
{
- pool_ref(pool);
- stream->pool = pool;
stream->refcount = 1;
}
@@ -17,8 +15,6 @@ void _io_stream_ref(struct _iostream *stream)
void _io_stream_unref(struct _iostream *stream)
{
- pool_t pool;
-
i_assert(stream->refcount > 0);
if (--stream->refcount != 0)
return;
@@ -26,9 +22,7 @@ void _io_stream_unref(struct _iostream *stream)
stream->close(stream);
stream->destroy(stream);
- pool = stream->pool;
- p_free(pool, stream);
- pool_unref(pool);
+ i_free(stream);
}
void _io_stream_close(struct _iostream *stream)
diff --git a/src/lib/istream-data.c b/src/lib/istream-data.c
index becbee3..7e98bb9 100644
--- a/src/lib/istream-data.c
+++ b/src/lib/istream-data.c
@@ -24,12 +24,11 @@ static void _seek(struct _istream *stream, uoff_t v_offset,
stream->istream.v_offset = v_offset;
}
-struct istream *i_stream_create_from_data(pool_t pool, const void *data,
- size_t size)
+struct istream *i_stream_create_from_data(const void *data, size_t size)
{
struct _istream *stream;
- stream = p_new(pool, struct _istream, 1);
+ stream = i_new(struct _istream, 1);
stream->buffer = data;
stream->pos = size;
@@ -41,7 +40,7 @@ struct istream *i_stream_create_from_data(pool_t pool, const void *data,
stream->istream.blocking = TRUE;
stream->istream.seekable = TRUE;
- (void)_i_stream_create(stream, pool, -1, 0);
+ (void)_i_stream_create(stream, -1, 0);
stream->statbuf.st_size = size;
return &stream->istream;
}
diff --git a/src/lib/istream-file.c b/src/lib/istream-file.c
index 49b5eaf..2d270d6 100644
--- a/src/lib/istream-file.c
+++ b/src/lib/istream-file.c
@@ -36,7 +36,7 @@ static void _destroy(struct _iostream *stream)
{
struct _istream *_stream = (struct _istream *) stream;
- p_free(_stream->iostream.pool, _stream->w_buffer);
+ i_free(_stream->w_buffer);
}
static ssize_t _read(struct _istream *stream)
@@ -159,13 +159,13 @@ _stat(struct _istream *stream, bool exact __attr_unused__)
return &stream->statbuf;
}
-struct istream *i_stream_create_file(int fd, pool_t pool,
- size_t max_buffer_size, bool autoclose_fd)
+struct istream *i_stream_create_file(int fd, size_t max_buffer_size,
+ bool autoclose_fd)
{
struct file_istream *fstream;
struct stat st;
- fstream = p_new(pool, struct file_istream, 1);
+ fstream = i_new(struct file_istream, 1);
fstream->autoclose_fd = autoclose_fd;
fstream->istream.iostream.close = _close;
@@ -184,5 +184,5 @@ struct istream *i_stream_create_file(int fd, pool_t pool,
fstream->istream.istream.seekable = TRUE;
}
- return _i_stream_create(&fstream->istream, pool, fd, 0);
+ return _i_stream_create(&fstream->istream, fd, 0);
}
diff --git a/src/lib/istream-internal.h b/src/lib/istream-internal.h
index 23ee63f..780cd5d 100644
--- a/src/lib/istream-internal.h
+++ b/src/lib/istream-internal.h
@@ -32,8 +32,8 @@ struct _istream {
string_t *line_str; /* for i_stream_next_line() if w_buffer == NULL */
};
-struct istream *_i_stream_create(struct _istream *_buf, pool_t pool, int fd,
- uoff_t abs_start_offset);
+struct istream *
+_i_stream_create(struct _istream *_buf, int fd, uoff_t abs_start_offset);
void _i_stream_compress(struct _istream *stream);
void _i_stream_grow_buffer(struct _istream *stream, size_t bytes);
diff --git a/src/lib/istream-limit.c b/src/lib/istream-limit.c
index 7e77751..e1fec24 100644
--- a/src/lib/istream-limit.c
+++ b/src/lib/istream-limit.c
@@ -108,14 +108,14 @@ static const struct stat *_stat(struct _istream *stream, bool exact)
return &stream->statbuf;
}
-struct istream *i_stream_create_limit(pool_t pool, struct istream *input,
+struct istream *i_stream_create_limit(struct istream *input,
uoff_t v_start_offset, uoff_t v_size)
{
struct limit_istream *lstream;
i_stream_ref(input);
- lstream = p_new(pool, struct limit_istream, 1);
+ lstream = i_new(struct limit_istream, 1);
lstream->input = input;
lstream->v_start_offset = v_start_offset;
lstream->v_size = v_size;
@@ -135,7 +135,7 @@ struct istream *i_stream_create_limit(pool_t pool, struct istream *input,
lstream->istream.istream.blocking = input->blocking;
lstream->istream.istream.seekable = input->seekable;
- return _i_stream_create(&lstream->istream, pool, i_stream_get_fd(input),
+ return _i_stream_create(&lstream->istream, i_stream_get_fd(input),
input->real_stream->abs_start_offset +
v_start_offset);
}
diff --git a/src/lib/istream-mmap.c b/src/lib/istream-mmap.c
index 53d47b4..55a378f 100644
--- a/src/lib/istream-mmap.c
+++ b/src/lib/istream-mmap.c
@@ -185,7 +185,7 @@ _stat(struct _istream *stream, bool exact __attr_unused__)
return &stream->statbuf;
}
-struct istream *i_stream_create_mmap(int fd, pool_t pool, size_t block_size,
+struct istream *i_stream_create_mmap(int fd, size_t block_size,
uoff_t start_offset, uoff_t v_size,
bool autoclose_fd)
{
@@ -207,7 +207,7 @@ struct istream *i_stream_create_mmap(int fd, pool_t pool, size_t block_size,
}
}
- mstream = p_new(pool, struct mmap_istream, 1);
+ mstream = i_new(struct mmap_istream, 1);
mstream->autoclose_fd = autoclose_fd;
mstream->v_size = v_size;
@@ -220,7 +220,7 @@ struct istream *i_stream_create_mmap(int fd, pool_t pool, size_t block_size,
mstream->istream.sync = _sync;
mstream->istream.stat = _stat;
- istream = _i_stream_create(&mstream->istream, pool, fd, start_offset);
+ istream = _i_stream_create(&mstream->istream, fd, start_offset);
istream->mmaped = TRUE;
istream->blocking = TRUE;
istream->seekable = TRUE;
diff --git a/src/lib/istream-seekable.c b/src/lib/istream-seekable.c
index b0a95a3..8c60bd1 100644
--- a/src/lib/istream-seekable.c
+++ b/src/lib/istream-seekable.c
@@ -17,7 +17,6 @@
struct seekable_istream {
struct _istream istream;
- pool_t pool;
size_t max_buffer_size;
char *temp_prefix;
@@ -54,8 +53,7 @@ static void _destroy(struct _iostream *stream)
for (i = 0; sstream->input[i] != NULL; i++)
i_stream_unref(&sstream->input[i]);
- p_free(sstream->pool, sstream->temp_prefix);
- pool_unref(sstream->pool);
+ i_free(sstream->temp_prefix);
}
static void _set_max_buffer_size(struct _iostream *stream, size_t max_size)
@@ -124,8 +122,7 @@ static int copy_to_temp_file(struct seekable_istream *sstream)
sstream->fd = fd;
sstream->fd_input =
- i_stream_create_file(fd, sstream->pool,
- sstream->max_buffer_size, TRUE);
+ i_stream_create_file(fd, sstream->max_buffer_size, TRUE);
return 0;
}
@@ -296,7 +293,7 @@ static const struct stat *_stat(struct _istream *stream, bool exact)
}
struct istream *
-i_stream_create_seekable(struct istream *input[], pool_t pool,
+i_stream_create_seekable(struct istream *input[],
size_t max_buffer_size, const char *temp_prefix)
{
struct seekable_istream *sstream;
@@ -308,14 +305,12 @@ i_stream_create_seekable(struct istream *input[], pool_t pool,
i_stream_ref(input[count]);
i_assert(count != 0);
- pool_ref(pool);
- sstream = p_new(pool, struct seekable_istream, 1);
- sstream->pool = pool;
- sstream->temp_prefix = p_strdup(pool, temp_prefix);
- sstream->buffer = buffer_create_dynamic(pool, BUF_INITIAL_SIZE);
+ sstream = i_new(struct seekable_istream, 1);
+ sstream->temp_prefix = i_strdup(temp_prefix);
+ sstream->buffer = buffer_create_dynamic(default_pool, BUF_INITIAL_SIZE);
sstream->max_buffer_size = max_buffer_size;
- sstream->input = p_new(pool, struct istream *, count + 1);
+ sstream->input = i_new(struct istream *, count + 1);
memcpy(sstream->input, input, sizeof(*input) * count);
sstream->cur_input = sstream->input[0];
@@ -332,5 +327,5 @@ i_stream_create_seekable(struct istream *input[], pool_t pool,
sstream->istream.seek = _seek;
sstream->istream.stat = _stat;
- return _i_stream_create(&sstream->istream, pool, -1, 0);
+ return _i_stream_create(&sstream->istream, -1, 0);
}
diff --git a/src/lib/istream-seekable.h b/src/lib/istream-seekable.h
index 2775a07..c9f2a52 100644
--- a/src/lib/istream-seekable.h
+++ b/src/lib/istream-seekable.h
@@ -7,7 +7,7 @@
temp_prefix is used as path and filename prefix for creating the file.
It will be appended by PID, timestamp and 128 bits of weak randomness. */
struct istream *
-i_stream_create_seekable(struct istream *input[], pool_t pool,
+i_stream_create_seekable(struct istream *input[],
size_t max_buffer_size, const char *temp_prefix);
#endif
diff --git a/src/lib/istream-tee.c b/src/lib/istream-tee.c
index 02cf133..af2f525 100644
--- a/src/lib/istream-tee.c
+++ b/src/lib/istream-tee.c
@@ -5,7 +5,6 @@
#include "istream-tee.h"
struct tee_istream {
- pool_t pool;
struct istream *input;
struct tee_child_istream *children;
@@ -88,7 +87,7 @@ static void _destroy(struct _iostream *stream)
tee->max_read_offset - tee->input->v_offset);
i_stream_unref(&tee->input);
- p_free(tee->pool, tee);
+ i_free(tee);
} else {
tee_streams_skip(tstream->tee);
}
@@ -170,24 +169,22 @@ static void _sync(struct _istream *stream)
return i_stream_sync(tstream->tee->input);
}
-struct tee_istream *tee_i_stream_create(struct istream *input, pool_t pool)
+struct tee_istream *tee_i_stream_create(struct istream *input)
{
struct tee_istream *tee;
- tee = p_new(pool, struct tee_istream, 1);
- tee->pool = pool;
+ tee = i_new(struct tee_istream, 1);
tee->input = input;
i_stream_ref(input);
return tee;
}
-struct istream *
-tee_i_stream_create_child(struct tee_istream *tee, pool_t pool)
+struct istream *tee_i_stream_create_child(struct tee_istream *tee)
{
struct tee_child_istream *tstream;
- tstream = p_new(pool, struct tee_child_istream, 1);
+ tstream = i_new(struct tee_child_istream, 1);
tstream->tee = tee;
tstream->istream.iostream.close = _close;
@@ -202,6 +199,6 @@ tee_i_stream_create_child(struct tee_istream *tee, pool_t pool)
tstream->next = tee->children;
tee->children = tstream;
- return _i_stream_create(&tstream->istream, pool,
+ return _i_stream_create(&tstream->istream,
i_stream_get_fd(tee->input), 0);
}
diff --git a/src/lib/istream-tee.h b/src/lib/istream-tee.h
index 0e814cf..0ceeb6c 100644
--- a/src/lib/istream-tee.h
+++ b/src/lib/istream-tee.h
@@ -7,9 +7,8 @@
If the stream's buffer gets full because some child isn't consuming the
data, other streams get returned 0 by i_stream_read(). */
-struct tee_istream *tee_i_stream_create(struct istream *input, pool_t pool);
+struct tee_istream *tee_i_stream_create(struct istream *input);
-struct istream *
-tee_i_stream_create_child(struct tee_istream *tee, pool_t pool);
+struct istream *tee_i_stream_create_child(struct tee_istream *tee);
#endif
diff --git a/src/lib/istream.c b/src/lib/istream.c
index 7b194c1..987a5fc 100644
--- a/src/lib/istream.c
+++ b/src/lib/istream.c
@@ -279,19 +279,15 @@ void _i_stream_grow_buffer(struct _istream *stream, size_t bytes)
stream->buffer_size = stream->pos + bytes;
if (stream->buffer_size <= I_STREAM_MIN_SIZE)
stream->buffer_size = I_STREAM_MIN_SIZE;
- else {
- stream->buffer_size =
- pool_get_exp_grown_size(stream->iostream.pool,
- old_size, stream->buffer_size);
- }
+ else
+ stream->buffer_size = nearest_power(stream->buffer_size);
if (stream->max_buffer_size > 0 &&
stream->buffer_size > stream->max_buffer_size)
stream->buffer_size = stream->max_buffer_size;
stream->buffer = stream->w_buffer =
- p_realloc(stream->iostream.pool, stream->w_buffer,
- old_size, stream->buffer_size);
+ i_realloc(stream->w_buffer, old_size, stream->buffer_size);
}
static void _set_max_buffer_size(struct _iostream *stream, size_t max_size)
@@ -307,8 +303,8 @@ _stat(struct _istream *stream, bool exact __attr_unused__)
return &stream->statbuf;
}
-struct istream *_i_stream_create(struct _istream *_stream, pool_t pool, int fd,
- uoff_t abs_start_offset)
+struct istream *
+_i_stream_create(struct _istream *_stream, int fd, uoff_t abs_start_offset)
{
_stream->fd = fd;
_stream->abs_start_offset = abs_start_offset;
@@ -325,7 +321,7 @@ struct istream *_i_stream_create(struct _istream *_stream, pool_t pool, int fd,
_stream->statbuf.st_mtime =
_stream->statbuf.st_ctime = ioloop_time;
- _io_stream_init(pool, &_stream->iostream);
+ _io_stream_init(&_stream->iostream);
return &_stream->istream;
}
@@ -371,7 +367,7 @@ int main(void)
write(fd1, buf, sizeof(buf));
/* test reading */
- input = i_stream_create_file(fd1, default_pool, 512, FALSE);
+ input = i_stream_create_file(fd1, 512, FALSE);
i_assert(i_stream_get_size(input) == sizeof(buf));
i_assert(i_stream_read_data(input, &data, &size, 0) > 0);
@@ -394,8 +390,8 @@ int main(void)
check_buffer(data, size, 900);
/* test moving data */
- output1 = o_stream_create_file(fd1, default_pool, 512, FALSE);
- output2 = o_stream_create_file(fd2, default_pool, 512, FALSE);
+ output1 = o_stream_create_file(fd1, 512, FALSE);
+ output2 = o_stream_create_file(fd2, 512, FALSE);
i_stream_seek(input, 1); size = sizeof(buf)-1;
i_assert(o_stream_send_istream(output2, input) == size);
@@ -410,8 +406,7 @@ int main(void)
i_assert(o_stream_send_istream(output1, input) == sizeof(buf));
/* test moving with limits */
- l_input = i_stream_create_limit(default_pool, input,
- sizeof(buf)/2, 512);
+ l_input = i_stream_create_limit(input, sizeof(buf)/2, 512);
i_stream_seek(l_input, 0);
o_stream_seek(output1, 10);
i_assert(o_stream_send_istream(output1, l_input) == 512);
diff --git a/src/lib/istream.h b/src/lib/istream.h
index a08af7d..bdc1d12 100644
--- a/src/lib/istream.h
+++ b/src/lib/istream.h
@@ -18,14 +18,13 @@ struct istream {
struct _istream *real_stream;
};
-struct istream *i_stream_create_file(int fd, pool_t pool,
- size_t max_buffer_size, bool autoclose_fd);
-struct istream *i_stream_create_mmap(int fd, pool_t pool, size_t block_size,
+struct istream *i_stream_create_file(int fd, size_t max_buffer_size,
+ bool autoclose_fd);
+struct istream *i_stream_create_mmap(int fd, size_t block_size,
uoff_t start_offset, uoff_t v_size,
bool autoclose_fd);
-struct istream *i_stream_create_from_data(pool_t pool, const void *data,
- size_t size);
-struct istream *i_stream_create_limit(pool_t pool, struct istream *input,
+struct istream *i_stream_create_from_data(const void *data, size_t size);
+struct istream *i_stream_create_limit(struct istream *input,
uoff_t v_start_offset, uoff_t v_size);
/* i_stream_close() + i_stream_unref() */
diff --git a/src/lib/macros.h b/src/lib/macros.h
index 1f0705a..42152ec 100644
--- a/src/lib/macros.h
+++ b/src/lib/macros.h
@@ -15,6 +15,9 @@
# define TRUE (!FALSE)
#endif
+#define N_ELEMENTS(arr) \
+ (sizeof(arr) / sizeof((arr)[0]))
+
#define BITS_IN_UINT (CHAR_BIT * sizeof(unsigned int))
#define BITS_IN_SIZE_T (CHAR_BIT * sizeof(size_t))
diff --git a/src/lib/ostream-crlf.c b/src/lib/ostream-crlf.c
index 9a11f94..1150a97 100644
--- a/src/lib/ostream-crlf.c
+++ b/src/lib/ostream-crlf.c
@@ -347,12 +347,11 @@ _send_istream(struct _ostream *outstream, struct istream *instream)
return sent == 0 && instream->stream_errno != 0 ? -1 : (ssize_t)sent;
}
-static struct crlf_ostream *
-o_stream_create_common(pool_t pool, struct ostream *output)
+static struct crlf_ostream *o_stream_create_common(struct ostream *output)
{
struct crlf_ostream *cstream;
- cstream = p_new(pool, struct crlf_ostream, 1);
+ cstream = i_new(struct crlf_ostream, 1);
cstream->output = output;
o_stream_ref(output);
@@ -369,20 +368,20 @@ o_stream_create_common(pool_t pool, struct ostream *output)
return cstream;
}
-struct ostream *o_stream_create_crlf(pool_t pool, struct ostream *output)
+struct ostream *o_stream_create_crlf(struct ostream *output)
{
struct crlf_ostream *cstream;
- cstream = o_stream_create_common(pool, output);
+ cstream = o_stream_create_common(output);
cstream->ostream.sendv = _sendv_crlf;
- return _o_stream_create(&cstream->ostream, pool);
+ return _o_stream_create(&cstream->ostream);
}
-struct ostream *o_stream_create_lf(pool_t pool, struct ostream *output)
+struct ostream *o_stream_create_lf(struct ostream *output)
{
struct crlf_ostream *cstream;
- cstream = o_stream_create_common(pool, output);
+ cstream = o_stream_create_common(output);
cstream->ostream.sendv = _sendv_lf;
- return _o_stream_create(&cstream->ostream, pool);
+ return _o_stream_create(&cstream->ostream);
}
diff --git a/src/lib/ostream-crlf.h b/src/lib/ostream-crlf.h
index b6171a1..7fa38d7 100644
--- a/src/lib/ostream-crlf.h
+++ b/src/lib/ostream-crlf.h
@@ -2,8 +2,8 @@
#define __OSTREAM_CRLF_H
/* Replace all plain LFs with CRLF. */
-struct ostream *o_stream_create_crlf(pool_t pool, struct ostream *output);
+struct ostream *o_stream_create_crlf(struct ostream *output);
/* Replace all CRLF pairs with plain LFs. */
-struct ostream *o_stream_create_lf(pool_t pool, struct ostream *output);
+struct ostream *o_stream_create_lf(struct ostream *output);
#endif
diff --git a/src/lib/ostream-file.c b/src/lib/ostream-file.c
index 47c8887..31a2c59 100644
--- a/src/lib/ostream-file.c
+++ b/src/lib/ostream-file.c
@@ -78,7 +78,7 @@ static void _destroy(struct _iostream *stream)
{
struct file_ostream *fstream = (struct file_ostream *)stream;
- p_free(fstream->ostream.iostream.pool, fstream->buffer);
+ i_free(fstream->buffer);
}
static void _set_max_buffer_size(struct _iostream *stream, size_t max_size)
@@ -322,9 +322,7 @@ static void o_stream_grow_buffer(struct file_ostream *fstream, size_t bytes)
{
size_t size, new_size, end_size;
- size = pool_get_exp_grown_size(fstream->ostream.iostream.pool,
- fstream->buffer_size,
- fstream->buffer_size + bytes);
+ size = nearest_power(fstream->buffer_size + bytes);
if (size > fstream->max_buffer_size) {
/* limit the size */
size = fstream->max_buffer_size;
@@ -339,8 +337,7 @@ static void o_stream_grow_buffer(struct file_ostream *fstream, size_t bytes)
if (size <= fstream->buffer_size)
return;
- fstream->buffer = p_realloc(fstream->ostream.iostream.pool,
- fstream->buffer,
+ fstream->buffer = i_realloc(fstream->buffer,
fstream->buffer_size, size);
if (fstream->tail <= fstream->head && !IS_STREAM_EMPTY(fstream)) {
@@ -737,15 +734,14 @@ static off_t _send_istream(struct _ostream *outstream, struct istream *instream)
}
struct ostream *
-o_stream_create_file(int fd, pool_t pool, size_t max_buffer_size,
- bool autoclose_fd)
+o_stream_create_file(int fd, size_t max_buffer_size, bool autoclose_fd)
{
struct file_ostream *fstream;
struct ostream *ostream;
struct stat st;
off_t offset;
- fstream = p_new(pool, struct file_ostream, 1);
+ fstream = i_new(struct file_ostream, 1);
fstream->fd = fd;
fstream->max_buffer_size = max_buffer_size;
fstream->autoclose_fd = autoclose_fd;
@@ -763,7 +759,7 @@ o_stream_create_file(int fd, pool_t pool, size_t max_buffer_size,
fstream->ostream.sendv = _sendv;
fstream->ostream.send_istream = _send_istream;
- ostream = _o_stream_create(&fstream->ostream, pool);
+ ostream = _o_stream_create(&fstream->ostream);
offset = lseek(fd, 0, SEEK_CUR);
if (offset >= 0) {
diff --git a/src/lib/ostream-internal.h b/src/lib/ostream-internal.h
index 30a6e8b..2c3ee09 100644
--- a/src/lib/ostream-internal.h
+++ b/src/lib/ostream-internal.h
@@ -26,6 +26,6 @@ struct _ostream {
void *context;
};
-struct ostream *_o_stream_create(struct _ostream *_stream, pool_t pool);
+struct ostream *_o_stream_create(struct _ostream *_stream);
#endif
diff --git a/src/lib/ostream.c b/src/lib/ostream.c
index c7a3750..8d686b4 100644
--- a/src/lib/ostream.c
+++ b/src/lib/ostream.c
@@ -157,10 +157,10 @@ off_t o_stream_send_istream(struct ostream *outstream,
return ret;
}
-struct ostream *_o_stream_create(struct _ostream *_stream, pool_t pool)
+struct ostream *_o_stream_create(struct _ostream *_stream)
{
_stream->ostream.real_stream = _stream;
- _io_stream_init(pool, &_stream->iostream);
+ _io_stream_init(&_stream->iostream);
return &_stream->ostream;
}
diff --git a/src/lib/ostream.h b/src/lib/ostream.h
index b81dca9..4917d90 100644
--- a/src/lib/ostream.h
+++ b/src/lib/ostream.h
@@ -24,8 +24,7 @@ typedef int stream_flush_callback_t(void *context);
/* Create new output stream from given file descriptor.
If max_buffer_size is 0, an "optimal" buffer size is used (max 128kB). */
struct ostream *
-o_stream_create_file(int fd, pool_t pool, size_t max_buffer_size,
- bool autoclose_fd);
+o_stream_create_file(int fd, size_t max_buffer_size, bool autoclose_fd);
/* o_stream_close() + o_stream_unref() */
void o_stream_destroy(struct ostream **stream);
diff --git a/src/lib/unichar.c b/src/lib/unichar.c
index fe54970..ea7ce80 100644
--- a/src/lib/unichar.c
+++ b/src/lib/unichar.c
@@ -2,8 +2,14 @@
#include "lib.h"
#include "buffer.h"
+#include "bsearch-insert-pos.h"
#include "unichar.h"
+#include "unicodemap.c"
+
+#define HANGUL_FIRST 0xac00
+#define HANGUL_LAST 0xd7a3
+
static const uint8_t utf8_non1_bytes[256 - 192 - 2] = {
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1
@@ -164,3 +170,118 @@ unsigned int uni_utf8_strlen_n(const void *_input, size_t size)
}
return len;
}
+
+static bool uint16_find(const uint16_t *data, unsigned int count,
+ uint16_t value, unsigned int *idx_r)
+{
+ BINARY_NUMBER_SEARCH(data, count, value, idx_r);
+}
+
+static bool uint32_find(const uint32_t *data, unsigned int count,
+ uint32_t value, unsigned int *idx_r)
+{
+ BINARY_NUMBER_SEARCH(data, count, value, idx_r);
+}
+
+unichar_t uni_ucs4_to_titlecase(unichar_t chr)
+{
+ unsigned int idx;
+
+ if (chr <= 0xffff) {
+ if (!uint16_find(titlecase16_keys, N_ELEMENTS(titlecase16_keys),
+ chr, &idx))
+ return chr;
+ else
+ return titlecase16_values[idx];
+ } else {
+ if (!uint32_find(titlecase32_keys, N_ELEMENTS(titlecase32_keys),
+ chr, &idx))
+ return chr;
+ else
+ return titlecase32_values[idx];
+ }
+}
+
+static bool uni_ucs4_decompose_uni(unichar_t *chr)
+{
+ unsigned int idx;
+
+ if (*chr <= 0xffff) {
+ if (!uint16_find(uni16_decomp_keys,
+ N_ELEMENTS(uni16_decomp_keys),
+ *chr, &idx))
+ return FALSE;
+ *chr = uni16_decomp_values[idx];
+ } else {
+ if (!uint32_find(uni32_decomp_keys,
+ N_ELEMENTS(uni32_decomp_keys),
+ *chr, &idx))
+ return FALSE;
+ *chr = uni32_decomp_values[idx];
+ }
+ return TRUE;
+}
+
+static void uni_ucs4_decompose_hangul_utf8(unichar_t chr, buffer_t *output)
+{
+#define SBase HANGUL_FIRST
+#define LBase 0x1100
+#define VBase 0x1161
+#define TBase 0x11A7
+#define LCount 19
+#define VCount 21
+#define TCount 28
+#define NCount (VCount * TCount)
+ unsigned int SIndex = chr - SBase;
+ unichar_t L = LBase + SIndex / NCount;
+ unichar_t V = VBase + (SIndex % NCount) / TCount;
+ unichar_t T = TBase + SIndex % TCount;
+
+ uni_ucs4_to_utf8_c(L, output);
+ uni_ucs4_to_utf8_c(V, output);
+ if (T != TBase) uni_ucs4_to_utf8_c(T, output);
+}
+
+static bool uni_ucs4_decompose_multi_utf8(unichar_t chr, buffer_t *output)
+{
+ const uint16_t *value;
+ unsigned int idx;
+
+ if (chr > 0xffff)
+ return FALSE;
+
+ if (!uint16_find(multidecomp_keys, N_ELEMENTS(multidecomp_keys),
+ chr, &idx))
+ return FALSE;
+
+ value = &multidecomp_values[multidecomp_offsets[idx]];
+ for (; *value != 0; value++)
+ uni_ucs4_to_utf8_c(*value, output);
+ return TRUE;
+}
+
+int uni_utf8_to_decomposed_titlecase(const void *_input, size_t max_len,
+ buffer_t *output)
+{
+ const unsigned char *input = _input;
+ unsigned int bytes;
+ unichar_t chr;
+
+ while (max_len > 0 && *input != '\0') {
+ if (uni_utf8_get_char_n(input, max_len, &chr) <= 0) {
+ /* invalid input */
+ return -1;
+ }
+ bytes = uni_utf8_char_bytes(*input);
+ input += bytes;
+ max_len -= bytes;
+
+ chr = uni_ucs4_to_titlecase(chr);
+ if (chr >= HANGUL_FIRST && chr <= HANGUL_LAST)
+ uni_ucs4_decompose_hangul_utf8(chr, output);
+ else if (uni_ucs4_decompose_uni(&chr) ||
+ !uni_ucs4_decompose_multi_utf8(chr, output))
+ uni_ucs4_to_utf8_c(chr, output);
+ }
+ return 0;
+}
diff --git a/src/lib/unichar.h b/src/lib/unichar.h
index 78b8af5..412f061 100644
--- a/src/lib/unichar.h
+++ b/src/lib/unichar.h
@@ -31,4 +31,13 @@ static inline unsigned int uni_utf8_char_bytes(char chr)
return uni_utf8_non1_bytes[(uint8_t)chr - (192 + 2)];
}
+/* Return given character in titlecase. */
+unichar_t uni_ucs4_to_titlecase(unichar_t chr);
+
+/* Convert UTF-8 input to titlecase and decompose the titlecase characters to
+ output buffer. Returns 0 if ok, -1 if input was invalid. This generates
+ output that's compatible with i;unicode-casemap comparator. */
+int uni_utf8_to_decomposed_titlecase(const void *input, size_t max_len,
+ buffer_t *output);
+
#endif
diff --git a/src/lib/unicodemap.pl b/src/lib/unicodemap.pl
new file mode 100755
index 0000000..93bdfb3
--- /dev/null
+++ b/src/lib/unicodemap.pl
@@ -0,0 +1,134 @@
+#!/usr/bin/env perl
+use strict;
+
+my (@titlecase16_keys, @titlecase16_values);
+my (@titlecase32_keys, @titlecase32_values);
+my (@uni16_decomp_keys, @uni16_decomp_values);
+my (@uni32_decomp_keys, @uni32_decomp_values);
+my (@multidecomp_keys, @multidecomp_offsets, @multidecomp_values);
+while (<>) {
+ chomp $_;
+ my @arr = split(";");
+ my $code = eval("0x".$arr[0]);
+ my $decomp = $arr[5];
+ my $titlecode = $arr[14];
+
+ if ($titlecode ne "") {
+ # titlecase mapping
+ my $value = eval("0x$titlecode");
+ if ($value == $code) {
+ # the same character, ignore
+ } elsif ($code <= 0xffff && $value <= 0xffff) {
+ push @titlecase16_keys, $code;
+ push @titlecase16_values, $value;
+ } else {
+ push @titlecase32_keys, $code;
+ push @titlecase32_values, $value;
+ }
+ } elsif ($decomp =~ /\<[^>]*> (.+)/) {
+ # decompositions
+ my $decomp_codes = $1;
+ if ($decomp_codes =~ /^([0-9A-Z]*)$/i) {
+ # unicharacter decomposition. use separate lists for this
+ my $value = eval("0x$1");
+ if ($value > 0xffff) {
+ print STDERR "We've assumed decomposition codes are max. 16bit\n";
+ exit;
+ }
+ if ($code <= 0xffff) {
+ push @uni16_decomp_keys, $code;
+ push @uni16_decomp_values, $value;
+ } else {
+ push @uni32_decomp_keys, $code;
+ push @uni32_decomp_values, $value;
+ }
+ } else {
+ # multicharacter decomposition.
+ if ($code > 0xffff) {
+ print STDERR "We've assumed multi-decomposition key codes are max. 16bit\n";
+ exit;
+ }
+
+ push @multidecomp_keys, $code;
+ push @multidecomp_offsets, scalar(@multidecomp_values);
+
+ foreach my $dcode (split(" ", $decomp_codes)) {
+ my $value = eval("0x$dcode");
+ if ($value > 0xffff) {
+ print STDERR "We've assumed decomposition codes are max. 16bit\n";
+ exit;
+ }
+ push @multidecomp_values, $value;
+ }
+ push @multidecomp_values, 0;
+ }
+ }
+}
+
+sub print_list {
+ my @list = @{$_[0]};
+
+ my $last = $#list;
+ my $n = 0;
+ foreach my $key (@list) {
+ printf("0x%04x", $key);
+ last if ($n == $last);
+ print ",";
+
+ $n++;
+ if (($n % 8) == 0) {
+ print "\n\t";
+ } else {
+ print " ";
+ }
+ }
+}
+
+print "/* This file is automatically generated by unicodemap.pl from UnicodeData.txt
+
+ NOTE: decompositions for characters having titlecase characters
+ are not included, because we first translate everything to titlecase */\n";
+
+print "static uint16_t titlecase16_keys[] = {\n\t";
+print_list(\@titlecase16_keys);
+print "\n};\n";
+
+print "static uint16_t titlecase16_values[] = {\n\t";
+print_list(\@titlecase16_values);
+print "\n};\n";
+
+print "static uint32_t titlecase32_keys[] = {\n\t";
+print_list(\@titlecase32_keys);
+print "\n};\n";
+
+print "static uint32_t titlecase32_values[] = {\n\t";
+print_list(\@titlecase32_values);
+print "\n};\n";
+
+print "static uint16_t uni16_decomp_keys[] = {\n\t";
+print_list(\@uni16_decomp_keys);
+print "\n};\n";
+
+print "static uint16_t uni16_decomp_values[] = {\n\t";
+print_list(\@uni16_decomp_values);
+print "\n};\n";
+
+print "static uint32_t uni32_decomp_keys[] = {\n\t";
+print_list(\@uni32_decomp_keys);
+print "\n};\n";
+
+print "static uint16_t uni32_decomp_values[] = {\n\t";
+print_list(\@uni32_decomp_values);
+print "\n};\n";
+
+print "static uint16_t multidecomp_keys[] = {\n\t";
+print_list(\@multidecomp_keys);
+print "\n};\n";
+
+print "static uint16_t multidecomp_offsets[] = {\n\t";
+print_list(\@multidecomp_offsets);
+print "\n};\n";
+
+print "static uint16_t multidecomp_values[] = {\n\t";
+print_list(\@multidecomp_values);
+print "\n};\n";
diff --git a/src/login-common/login-proxy.c b/src/login-common/login-proxy.c
index b7e3420..22d3fdb 100644
--- a/src/login-common/login-proxy.c
+++ b/src/login-common/login-proxy.c
@@ -121,11 +121,10 @@ static void proxy_wait_connect(struct login_proxy *proxy)
/* connect successful */
proxy->server_input =
- i_stream_create_file(proxy->server_fd, default_pool,
- MAX_PROXY_INPUT_SIZE, FALSE);
+ i_stream_create_file(proxy->server_fd, MAX_PROXY_INPUT_SIZE,
+ FALSE);
proxy->server_output =
- o_stream_create_file(proxy->server_fd, default_pool,
- (size_t)-1, FALSE);
+ o_stream_create_file(proxy->server_fd, (size_t)-1, FALSE);
io_remove(&proxy->server_io);
proxy->server_io =
diff --git a/src/login-common/master.c b/src/login-common/master.c
index 9a0af95..f2ae8dd 100644
--- a/src/login-common/master.c
+++ b/src/login-common/master.c
@@ -165,7 +165,7 @@ static void master_read_env(int fd)
env_clean();
/* read environment variable lines until empty line comes */
- input = i_stream_create_file(fd, default_pool, 8192, FALSE);
+ input = i_stream_create_file(fd, 8192, FALSE);
do {
switch (i_stream_read(input)) {
case -1:
diff --git a/src/master/auth-process.c b/src/master/auth-process.c
index adeba9a..faa35b5 100644
--- a/src/master/auth-process.c
+++ b/src/master/auth-process.c
@@ -297,10 +297,8 @@ auth_process_new(pid_t pid, int fd, struct auth_process_group *group)
p->pid = pid;
p->fd = fd;
p->io = io_add(fd, IO_READ, auth_process_input, p);
- p->input = i_stream_create_file(fd, default_pool,
- MAX_INBUF_SIZE, FALSE);
- p->output = o_stream_create_file(fd, default_pool, MAX_OUTBUF_SIZE,
- FALSE);
+ p->input = i_stream_create_file(fd, MAX_INBUF_SIZE, FALSE);
+ p->output = o_stream_create_file(fd, MAX_OUTBUF_SIZE, FALSE);
p->requests = hash_create(default_pool, default_pool, 0, NULL, NULL);
group->process_count++;
diff --git a/src/master/log.c b/src/master/log.c
index a43b72c..9ecfb8f 100644
--- a/src/master/log.c
+++ b/src/master/log.c
@@ -179,7 +179,7 @@ int log_create_pipe(struct log_io **log_r, unsigned int max_lines_per_sec)
log_io = i_new(struct log_io, 1);
log_io->refcount = 1;
- log_io->stream = i_stream_create_file(fd[0], default_pool, 1024, TRUE);
+ log_io->stream = i_stream_create_file(fd[0], 1024, TRUE);
log_io->max_lines_per_sec =
max_lines_per_sec != 0 ? max_lines_per_sec : (unsigned int)-1;
diff --git a/src/master/login-process.c b/src/master/login-process.c
index 2b33625..46e0d5f 100644
--- a/src/master/login-process.c
+++ b/src/master/login-process.c
@@ -449,7 +449,7 @@ login_process_new(struct login_group *group, pid_t pid, int fd)
p->pid = pid;
p->fd = fd;
p->io = io_add(fd, IO_READ, login_process_input, p);
- p->output = o_stream_create_file(fd, default_pool,
+ p->output = o_stream_create_file(fd,
sizeof(struct master_login_reply)*10,
FALSE);
child_process_add(pid, &p->process);
diff --git a/src/master/mail-process.c b/src/master/mail-process.c
index e770314..3a695ce 100644
--- a/src/master/mail-process.c
+++ b/src/master/mail-process.c
@@ -124,6 +124,7 @@ static bool validate_uid_gid(struct settings *set, uid_t uid, gid_t gid,
i_error("Logins with login process UID %s (user %s) "
"not permitted (see login_user in config file).",
dec2str(uid), user);
+ return FALSE;
}
if (uid < (uid_t)set->first_valid_uid ||
diff --git a/src/plugins/acl/acl-backend-vfile-acllist.c b/src/plugins/acl/acl-backend-vfile-acllist.c
index 1b7f64b..41b0110 100644
--- a/src/plugins/acl/acl-backend-vfile-acllist.c
+++ b/src/plugins/acl/acl-backend-vfile-acllist.c
@@ -83,7 +83,7 @@ static int acl_backend_vfile_acllist_read(struct acl_backend_vfile *backend)
backend->acllist_mtime = st.st_mtime;
acllist_clear(backend, st.st_size);
- input = i_stream_create_file(fd, default_pool, (size_t)-1, FALSE);
+ input = i_stream_create_file(fd, (size_t)-1, FALSE);
while ((line = i_stream_read_next_line(input)) != NULL) {
acllist.mtime = 0;
for (p = line; *p >= '0' && *p <= '9'; p++)
@@ -208,7 +208,7 @@ int acl_backend_vfile_acllist_rebuild(struct acl_backend_vfile *backend)
fd = safe_mkstemp(path, mode, uid, gid);
if (fd == -1)
return -1;
- output = o_stream_create_file(fd, default_pool, 0, FALSE);
+ output = o_stream_create_file(fd, 0, FALSE);
ret = 0;
acllist_clear(backend, 0);
diff --git a/src/plugins/acl/acl-backend-vfile.c b/src/plugins/acl/acl-backend-vfile.c
index c1be2e3..2c784a7 100644
--- a/src/plugins/acl/acl-backend-vfile.c
+++ b/src/plugins/acl/acl-backend-vfile.c
@@ -345,7 +345,7 @@ acl_backend_vfile_read(struct acl_object_vfile *aclobj, const char *path,
if (aclobj->aclobj.backend->debug)
i_info("acl vfile: reading file %s", path);
- input = i_stream_create_file(fd, default_pool, 4096, FALSE);
+ input = i_stream_create_file(fd, 4096, FALSE);
if (!array_is_created(&aclobj->rights)) {
aclobj->rights_pool =
diff --git a/src/plugins/expire/auth-client.c b/src/plugins/expire/auth-client.c
index 9011564..9511888 100644
--- a/src/plugins/expire/auth-client.c
+++ b/src/plugins/expire/auth-client.c
@@ -46,10 +46,8 @@ static int auth_connection_connect(struct auth_connection *conn)
}
conn->fd = fd;
- conn->input =
- i_stream_create_file(fd, default_pool, MAX_INBUF_SIZE, FALSE);
- conn->output =
- o_stream_create_file(fd, default_pool, MAX_OUTBUF_SIZE, FALSE);
+ conn->input = i_stream_create_file(fd, MAX_INBUF_SIZE, FALSE);
+ conn->output = o_stream_create_file(fd, MAX_OUTBUF_SIZE, FALSE);
conn->io = io_add(fd, IO_READ, auth_input, conn);
o_stream_send_str(conn->output, "VERSION\t1\t0\n");
diff --git a/src/plugins/fts-squat/squat-test.c b/src/plugins/fts-squat/squat-test.c
index 61bed52..f520945 100644
--- a/src/plugins/fts-squat/squat-test.c
+++ b/src/plugins/fts-squat/squat-test.c
@@ -59,7 +59,7 @@ int main(int argc __attr_unused__, char *argv[])
return 1;
build_ctx = squat_trie_build_init(trie, &last_uid);
- input = i_stream_create_file(fd, default_pool, 0, FALSE);
+ input = i_stream_create_file(fd, 0, FALSE);
while ((line = i_stream_read_next_line(input)) != NULL) {
if (last != input->v_offset/(1024*100)) {
fprintf(stderr, "\r%ukB", (unsigned)(input->v_offset/1024));
diff --git a/src/plugins/fts-squat/squat-trie.c b/src/plugins/fts-squat/squat-trie.c
index 7c49497..0a4f466 100644
--- a/src/plugins/fts-squat/squat-trie.c
+++ b/src/plugins/fts-squat/squat-trie.c
@@ -1474,7 +1474,7 @@ trie_nodes_write(struct squat_trie_build_context *ctx, uint32_t *uidvalidity_r)
return -1;
}
- ctx->output = o_stream_create_file(trie->fd, default_pool, 0, FALSE);
+ ctx->output = o_stream_create_file(trie->fd, 0, FALSE);
o_stream_cork(ctx->output);
if (hdr.used_file_size == 0) {
o_stream_send(ctx->output, &hdr, sizeof(hdr));
@@ -1799,7 +1799,7 @@ static int squat_trie_compress_init(struct squat_trie_compress_context *ctx,
}
ctx->trie = trie;
- ctx->output = o_stream_create_file(ctx->fd, default_pool, 0, FALSE);
+ ctx->output = o_stream_create_file(ctx->fd, 0, FALSE);
ctx->node_count = trie->hdr->node_count;
/* write a dummy header first */
diff --git a/src/plugins/fts-squat/squat-uidlist.c b/src/plugins/fts-squat/squat-uidlist.c
index 6d4d56a..50e9fb1 100644
--- a/src/plugins/fts-squat/squat-uidlist.c
+++ b/src/plugins/fts-squat/squat-uidlist.c
@@ -580,8 +580,7 @@ static int squat_uidlist_write_init(struct squat_uidlist *uidlist)
return -1;
}
- uidlist->output = o_stream_create_file(uidlist->fd, default_pool,
- 0, FALSE);
+ uidlist->output = o_stream_create_file(uidlist->fd, 0, FALSE);
o_stream_cork(uidlist->output);
if (uidlist->hdr.used_file_size < sizeof(uidlist->hdr)) {
/* creating a new file, write a dummy header */
@@ -761,7 +760,7 @@ squat_uidlist_compress_begin(struct squat_uidlist *uidlist,
ctx->failed = TRUE;
i_error("open(%s) failed: %m", ctx->tmp_path);
} else {
- ctx->output = o_stream_create_file(fd, default_pool, 0, TRUE);
+ ctx->output = o_stream_create_file(fd, 0, TRUE);
o_stream_send(ctx->output, &ctx->hdr, sizeof(ctx->hdr));
}
diff --git a/src/plugins/fts/fts-storage.c b/src/plugins/fts/fts-storage.c
index 3cd1fab..a0f62e1 100644
--- a/src/plugins/fts/fts-storage.c
+++ b/src/plugins/fts/fts-storage.c
@@ -176,7 +176,7 @@ static int fts_build_mail(struct fts_storage_build_context *ctx)
parser = message_parser_init(pool_datastack_create(), input,
MESSAGE_HEADER_PARSER_FLAG_CLEAN_ONELINE,
0);
- decoder = message_decoder_init_ucase();
+ decoder = message_decoder_init(TRUE);
for (;;) {
ret = message_parser_parse_next_block(parser, &raw_block);
i_assert(ret != 0);
diff --git a/src/plugins/trash/trash-plugin.c b/src/plugins/trash/trash-plugin.c
index a5dcd02..e1c15ba 100644
--- a/src/plugins/trash/trash-plugin.c
+++ b/src/plugins/trash/trash-plugin.c
@@ -262,7 +262,7 @@ static int read_configuration(const char *path)
p_clear(config_pool);
p_array_init(&trash_boxes, config_pool, INIT_TRASH_MAILBOX_COUNT);
- input = i_stream_create_file(fd, default_pool, (size_t)-1, FALSE);
+ input = i_stream_create_file(fd, (size_t)-1, FALSE);
while ((line = i_stream_read_next_line(input)) != NULL) {
/* <priority> <mailbox name> */
name = strchr(line, ' ');
diff --git a/src/plugins/zlib/istream-zlib.c b/src/plugins/zlib/istream-zlib.c
index 06b7b75..c93bca7 100644
--- a/src/plugins/zlib/istream-zlib.c
+++ b/src/plugins/zlib/istream-zlib.c
@@ -35,7 +35,7 @@ static void _destroy(struct _iostream *stream __attr_unused__)
{
struct _istream *_stream = (struct _istream *) stream;
- p_free(_stream->iostream.pool, _stream->w_buffer);
+ i_free(_stream->w_buffer);
}
static ssize_t _read(struct _istream *stream)
@@ -193,12 +193,12 @@ static void _sync(struct _istream *stream)
zstream->cached_size = (uoff_t)-1;
}
-struct istream *i_stream_create_zlib(int fd, pool_t pool)
+struct istream *i_stream_create_zlib(int fd)
{
struct zlib_istream *zstream;
struct stat st;
- zstream = p_new(pool, struct zlib_istream, 1);
+ zstream = i_new(struct zlib_istream, 1);
zstream->fd = fd;
zstream->file = gzdopen(fd, "r");
zstream->cached_size = (uoff_t)-1;
@@ -218,5 +218,5 @@ struct istream *i_stream_create_zlib(int fd, pool_t pool)
zstream->istream.istream.seekable = TRUE;
}
- return _i_stream_create(&zstream->istream, pool, fd, 0);
+ return _i_stream_create(&zstream->istream, fd, 0);
}
diff --git a/src/plugins/zlib/istream-zlib.h b/src/plugins/zlib/istream-zlib.h
index 88b3735..697c2ce 100644
--- a/src/plugins/zlib/istream-zlib.h
+++ b/src/plugins/zlib/istream-zlib.h
@@ -1,6 +1,6 @@
#ifndef __ISTREAM_ZLIB_H
#define __ISTREAM_ZLIB_H
-struct istream *i_stream_create_zlib(int fd, pool_t pool);
+struct istream *i_stream_create_zlib(int fd);
#endif
diff --git a/src/plugins/zlib/zlib-plugin.c b/src/plugins/zlib/zlib-plugin.c
index 97cab54..549dfc4 100644
--- a/src/plugins/zlib/zlib-plugin.c
+++ b/src/plugins/zlib/zlib-plugin.c
@@ -41,10 +41,8 @@ zlib_mailbox_open(struct mail_storage *storage, const char *name,
int fd;
fd = open(path, O_RDONLY);
- if (fd != -1) {
- input = zlib_input =
- i_stream_create_zlib(fd, default_pool);
- }
+ if (fd != -1)
+ input = zlib_input = i_stream_create_zlib(fd);
}
}
diff --git a/src/pop3-login/client.c b/src/pop3-login/client.c
index 040b6b9..3f5dc1c 100644
--- a/src/pop3-login/client.c
+++ b/src/pop3-login/client.c
@@ -65,10 +65,8 @@ static void client_set_title(struct pop3_client *client)
static void client_open_streams(struct pop3_client *client, int fd)
{
- client->input = i_stream_create_file(fd, default_pool,
- MAX_INBUF_SIZE, FALSE);
- client->output = o_stream_create_file(fd, default_pool,
- MAX_OUTBUF_SIZE, FALSE);
+ client->input = i_stream_create_file(fd, MAX_INBUF_SIZE, FALSE);
+ client->output = o_stream_create_file(fd, MAX_OUTBUF_SIZE, FALSE);
}
static void client_start_tls(struct pop3_client *client)
diff --git a/src/pop3/client.c b/src/pop3/client.c
index 10e96cb..3efc9e9 100644
--- a/src/pop3/client.c
+++ b/src/pop3/client.c
@@ -140,10 +140,8 @@ struct client *client_create(int fd_in, int fd_out,
client = i_new(struct client, 1);
client->fd_in = fd_in;
client->fd_out = fd_out;
- client->input = i_stream_create_file(fd_in, default_pool,
- MAX_INBUF_SIZE, FALSE);
- client->output = o_stream_create_file(fd_out, default_pool,
- (size_t)-1, FALSE);
+ client->input = i_stream_create_file(fd_in, MAX_INBUF_SIZE, FALSE);
+ client->output = o_stream_create_file(fd_out, (size_t)-1, FALSE);
o_stream_set_flush_callback(client->output, client_output, client);
client->io = io_add(fd_in, IO_READ, client_input, client);
diff --git a/src/util/rawlog.c b/src/util/rawlog.c
index ae89533..097f3f4 100644
--- a/src/util/rawlog.c
+++ b/src/util/rawlog.c
@@ -240,19 +240,16 @@ rawlog_proxy_create(int client_in_fd, int client_out_fd, int server_fd,
proxy = i_new(struct rawlog_proxy, 1);
proxy->server_fd = server_fd;
proxy->server_input =
- i_stream_create_file(server_fd, default_pool,
- MAX_PROXY_INPUT_SIZE, FALSE);
+ i_stream_create_file(server_fd, MAX_PROXY_INPUT_SIZE, FALSE);
proxy->server_output =
- o_stream_create_file(server_fd, default_pool,
- (size_t)-1, FALSE);
+ o_stream_create_file(server_fd, (size_t)-1, FALSE);
proxy->server_io = io_add(server_fd, IO_READ, server_input, proxy);
o_stream_set_flush_callback(proxy->server_output, server_output, proxy);
proxy->client_in_fd = client_in_fd;
proxy->client_out_fd = client_out_fd;
proxy->client_output =
- o_stream_create_file(client_out_fd, default_pool,
- (size_t)-1, FALSE);
+ o_stream_create_file(client_out_fd, (size_t)-1, FALSE);
proxy->client_io = io_add(proxy->client_in_fd, IO_READ,
client_input, proxy);
o_stream_set_flush_callback(proxy->client_output, client_output, proxy);
Reference in New Issue View Git Blame Copy Permalink