debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-21 18:38:08 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

lib: run uncrustify

Browse source 
This is the result of running

     $ uncrustify --replace --config ../devel/uncrustify.cfg *.c *.h *.cc

in the lib directory
This commit is contained in:
uncrustify 2021-03-13 08:45:34 -04:00 committed by David Bremner
parent 97fadd0645
commit 8aeba1228a
17 changed files with 130 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

72
lib/config.cc
View file

@ -38,7 +38,7 @@ struct _notmuch_config_values {
void *children; /* talloc_context */ void *children; /* talloc_context */
}; };
static const char * _notmuch_config_key_to_string (notmuch_config_key_t key); static const char *_notmuch_config_key_to_string (notmuch_config_key_t key);
static int static int
_notmuch_config_list_destroy (notmuch_config_list_t *list) _notmuch_config_list_destroy (notmuch_config_list_t *list)
@ -104,7 +104,7 @@ notmuch_database_get_config (notmuch_database_t *notmuch,
const char *key, const char *key,
char **value) char **value)
{ {
const char* stored_val; const char *stored_val;
notmuch_status_t status; notmuch_status_t status;
if (! notmuch->config) { if (! notmuch->config) {
@ -119,7 +119,7 @@ notmuch_database_get_config (notmuch_database_t *notmuch,
if (! stored_val) { if (! stored_val) {
/* XXX in principle this API should be fixed so empty string /* XXX in principle this API should be fixed so empty string
* is distinguished from not found */ * is distinguished from not found */
*value = strdup(""); *value = strdup ("");
} else { } else {
*value = strdup (stored_val); *value = strdup (stored_val);
} }
@ -152,7 +152,8 @@ notmuch_database_get_config_list (notmuch_database_t *notmuch,
talloc_set_destructor (list, _notmuch_config_list_destroy); talloc_set_destructor (list, _notmuch_config_list_destroy);
} catch (const Xapian::Error &error) { } catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred getting metadata iterator: %s.\n", _notmuch_database_log (notmuch,
"A Xapian exception occurred getting metadata iterator: %s.\n",
error.get_msg ().c_str ()); error.get_msg ().c_str ());
notmuch->exception_reported = true; notmuch->exception_reported = true;
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION; status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
@ -167,7 +168,7 @@ notmuch_database_get_config_list (notmuch_database_t *notmuch,
if (status != NOTMUCH_STATUS_XAPIAN_EXCEPTION) if (status != NOTMUCH_STATUS_XAPIAN_EXCEPTION)
_notmuch_config_list_destroy (list); _notmuch_config_list_destroy (list);
} }
} else { } else {
talloc_set_destructor (list, _notmuch_config_list_destroy); talloc_set_destructor (list, _notmuch_config_list_destroy);
} }
@ -183,7 +184,9 @@ notmuch_config_list_valid (notmuch_config_list_t *metadata)
return true; return true;
} }
static inline char * _key_from_iterator (notmuch_config_list_t *list) { static inline char *
_key_from_iterator (notmuch_config_list_t *list)
{
return talloc_strdup (list, (*list->iterator).c_str () + CONFIG_PREFIX.length ()); return talloc_strdup (list, (*list->iterator).c_str () + CONFIG_PREFIX.length ());
} }
@ -239,7 +242,7 @@ _notmuch_config_load_from_database (notmuch_database_t *notmuch)
if (notmuch->config == NULL) if (notmuch->config == NULL)
notmuch->config = _notmuch_string_map_create (notmuch); notmuch->config = _notmuch_string_map_create (notmuch);
if (unlikely(notmuch->config == NULL)) if (unlikely (notmuch->config == NULL))
return NOTMUCH_STATUS_OUT_OF_MEMORY; return NOTMUCH_STATUS_OUT_OF_MEMORY;
status = notmuch_database_get_config_list (notmuch, "", &list); status = notmuch_database_get_config_list (notmuch, "", &list);
@ -267,7 +270,7 @@ notmuch_config_get_values (notmuch_database_t *notmuch, notmuch_config_key_t key
goto DONE; goto DONE;
values = talloc (notmuch, notmuch_config_values_t); values = talloc (notmuch, notmuch_config_values_t);
if (unlikely(! values)) if (unlikely (! values))
goto DONE; goto DONE;
values->children = talloc_new (values); values->children = talloc_new (values);
@ -279,17 +282,18 @@ notmuch_config_get_values (notmuch_database_t *notmuch, notmuch_config_key_t key
values->iterator = strsplit_len (values->string, ';', &(values->tok_len)); values->iterator = strsplit_len (values->string, ';', &(values->tok_len));
ok = true; ok = true;
DONE: DONE:
if (!ok) { if (! ok) {
if (values) if (values)
talloc_free(values); talloc_free (values);
return NULL; return NULL;
} }
return values; return values;
} }
notmuch_bool_t notmuch_bool_t
notmuch_config_values_valid (notmuch_config_values_t *values) { notmuch_config_values_valid (notmuch_config_values_t *values)
{
if (! values) if (! values)
return false; return false;
@ -297,12 +301,14 @@ notmuch_config_values_valid (notmuch_config_values_t *values) {
} }
const char * const char *
notmuch_config_values_get (notmuch_config_values_t *values) { notmuch_config_values_get (notmuch_config_values_t *values)
{
return talloc_strndup (values, values->iterator, values->tok_len); return talloc_strndup (values, values->iterator, values->tok_len);
} }
void void
notmuch_config_values_start (notmuch_config_values_t *values) { notmuch_config_values_start (notmuch_config_values_t *values)
{
if (values == NULL) if (values == NULL)
return; return;
if (values->children) { if (values->children) {
@ -315,13 +321,15 @@ notmuch_config_values_start (notmuch_config_values_t *values) {
} }
void void
notmuch_config_values_move_to_next (notmuch_config_values_t *values) { notmuch_config_values_move_to_next (notmuch_config_values_t *values)
{
values->iterator += values->tok_len; values->iterator += values->tok_len;
values->iterator = strsplit_len (values->iterator, ';', &(values->tok_len)); values->iterator = strsplit_len (values->iterator, ';', &(values->tok_len));
} }
void void
notmuch_config_values_destroy (notmuch_config_values_t *values) { notmuch_config_values_destroy (notmuch_config_values_t *values)
{
talloc_free (values); talloc_free (values);
} }
@ -335,14 +343,14 @@ _notmuch_config_load_from_file (notmuch_database_t *notmuch,
if (notmuch->config == NULL) if (notmuch->config == NULL)
notmuch->config = _notmuch_string_map_create (notmuch); notmuch->config = _notmuch_string_map_create (notmuch);
if (unlikely(notmuch->config == NULL)) { if (unlikely (notmuch->config == NULL)) {
status = NOTMUCH_STATUS_OUT_OF_MEMORY; status = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE; goto DONE;
} }
for (groups = g_key_file_get_groups (file, NULL); *groups; groups++) { for (groups = g_key_file_get_groups (file, NULL); *groups; groups++) {
for (keys = g_key_file_get_keys (file, *groups, NULL, NULL); *keys; keys++) { for (keys = g_key_file_get_keys (file, *groups, NULL, NULL); *keys; keys++) {
char *absolute_key = talloc_asprintf(notmuch, "%s.%s", *groups, *keys); char *absolute_key = talloc_asprintf (notmuch, "%s.%s", *groups, *keys);
val = g_key_file_get_value (file, *groups, *keys, NULL); val = g_key_file_get_value (file, *groups, *keys, NULL);
if (! val) { if (! val) {
status = NOTMUCH_STATUS_FILE_ERROR; status = NOTMUCH_STATUS_FILE_ERROR;
@ -355,7 +363,7 @@ _notmuch_config_load_from_file (notmuch_database_t *notmuch,
} }
} }
DONE: DONE:
return status; return status;
} }
@ -386,7 +394,8 @@ notmuch_config_get_bool (notmuch_database_t *notmuch, notmuch_config_key_t key,
} }
static const char * static const char *
_notmuch_config_key_to_string (notmuch_config_key_t key) { _notmuch_config_key_to_string (notmuch_config_key_t key)
{
switch (key) { switch (key) {
case NOTMUCH_CONFIG_DATABASE_PATH: case NOTMUCH_CONFIG_DATABASE_PATH:
return "database.path"; return "database.path";
@ -412,7 +421,8 @@ _notmuch_config_key_to_string (notmuch_config_key_t key) {
} }
static const char * static const char *
_notmuch_config_default (void *ctx, notmuch_config_key_t key) { _notmuch_config_default (void *ctx, notmuch_config_key_t key)
{
char *path; char *path;
switch (key) { switch (key) {
@ -439,39 +449,45 @@ _notmuch_config_default (void *ctx, notmuch_config_key_t key) {
default: default:
case NOTMUCH_CONFIG_LAST: case NOTMUCH_CONFIG_LAST:
INTERNAL_ERROR ("illegal key enum %d", key); INTERNAL_ERROR ("illegal key enum %d", key);
} }
} }
notmuch_status_t notmuch_status_t
_notmuch_config_load_defaults (notmuch_database_t *notmuch) { _notmuch_config_load_defaults (notmuch_database_t *notmuch)
{
notmuch_config_key_t key; notmuch_config_key_t key;
for (key = NOTMUCH_CONFIG_FIRST; for (key = NOTMUCH_CONFIG_FIRST;
key < NOTMUCH_CONFIG_LAST; key < NOTMUCH_CONFIG_LAST;
key = notmuch_config_key_t(key + 1)) { key = notmuch_config_key_t (key + 1)) {
const char *val = notmuch_config_get (notmuch, key); const char *val = notmuch_config_get (notmuch, key);
const char *key_string = _notmuch_config_key_to_string (key); const char *key_string = _notmuch_config_key_to_string (key);
val = _notmuch_string_map_get (notmuch->config, key_string); val = _notmuch_string_map_get (notmuch->config, key_string);
if (! val) { if (! val) {
_notmuch_string_map_set (notmuch->config, key_string, _notmuch_config_default (notmuch, key)); _notmuch_string_map_set (notmuch->config, key_string, _notmuch_config_default (notmuch,
key));
} }
} }
return NOTMUCH_STATUS_SUCCESS; return NOTMUCH_STATUS_SUCCESS;
} }
const char * const char *
notmuch_config_get (notmuch_database_t *notmuch, notmuch_config_key_t key) { notmuch_config_get (notmuch_database_t *notmuch, notmuch_config_key_t key)
{
return _notmuch_string_map_get (notmuch->config, _notmuch_config_key_to_string (key)); return _notmuch_string_map_get (notmuch->config, _notmuch_config_key_to_string (key));
} }
notmuch_status_t notmuch_status_t
notmuch_config_set (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val) { notmuch_config_set (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val)
{
return notmuch_database_set_config (notmuch, _notmuch_config_key_to_string (key), val); return notmuch_database_set_config (notmuch, _notmuch_config_key_to_string (key), val);
} }
void void
_notmuch_config_cache (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val) { _notmuch_config_cache (notmuch_database_t *notmuch, notmuch_config_key_t key, const char *val)
{
_notmuch_string_map_set (notmuch->config, _notmuch_config_key_to_string (key), val); _notmuch_string_map_set (notmuch->config, _notmuch_config_key_to_string (key), val);
} }

24
lib/database.cc
View file

@ -49,7 +49,8 @@ typedef struct {
#define LOG_XAPIAN_EXCEPTION(message, error) _log_xapian_exception (__location__, message, error) #define LOG_XAPIAN_EXCEPTION(message, error) _log_xapian_exception (__location__, message, error)
static void static void
_log_xapian_exception (const char *where, notmuch_database_t *notmuch, const Xapian::Error error) { _log_xapian_exception (const char *where, notmuch_database_t *notmuch, const Xapian::Error error)
{
_notmuch_database_log (notmuch, _notmuch_database_log (notmuch,
"A Xapian exception occurred at %s: %s\n", "A Xapian exception occurred at %s: %s\n",
where, where,
@ -506,7 +507,8 @@ notmuch_database_close (notmuch_database_t *notmuch)
} catch (const Xapian::Error &error) { } catch (const Xapian::Error &error) {
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION; status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
if (! notmuch->exception_reported) { if (! notmuch->exception_reported) {
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred closing database: %s\n", _notmuch_database_log (notmuch,
"Error: A Xapian exception occurred closing database: %s\n",
error.get_msg ().c_str ()); error.get_msg ().c_str ());
} }
} }
@ -627,10 +629,11 @@ notmuch_status_t
notmuch_database_compact_db (notmuch_database_t *notmuch, notmuch_database_compact_db (notmuch_database_t *notmuch,
const char *backup_path, const char *backup_path,
notmuch_compact_status_cb_t status_cb, notmuch_compact_status_cb_t status_cb,
void *closure) { void *closure)
{
void *local; void *local;
char *notmuch_path, *xapian_path, *compact_xapian_path; char *notmuch_path, *xapian_path, *compact_xapian_path;
const char* path; const char *path;
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
struct stat statbuf; struct stat statbuf;
bool keep_backup; bool keep_backup;
@ -692,7 +695,8 @@ notmuch_database_compact_db (notmuch_database_t *notmuch,
try { try {
NotmuchCompactor compactor (status_cb, closure); NotmuchCompactor compactor (status_cb, closure);
notmuch->xapian_db->compact (compact_xapian_path, Xapian::DBCOMPACT_NO_RENUMBER, 0, compactor); notmuch->xapian_db->compact (compact_xapian_path, Xapian::DBCOMPACT_NO_RENUMBER, 0,
compactor);
} catch (const Xapian::Error &error) { } catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "Error while compacting: %s\n", error.get_msg ().c_str ()); _notmuch_database_log (notmuch, "Error while compacting: %s\n", error.get_msg ().c_str ());
ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION; ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
@ -840,8 +844,8 @@ handle_sigalrm (unused (int signal))
*/ */
notmuch_status_t notmuch_status_t
notmuch_database_upgrade (notmuch_database_t *notmuch, notmuch_database_upgrade (notmuch_database_t *notmuch,
void (*progress_notify) (void *closure, void (*progress_notify)(void *closure,
double progress), double progress),
void *closure) void *closure)
{ {
void *local = talloc_new (NULL); void *local = talloc_new (NULL);
@ -1065,7 +1069,8 @@ notmuch_database_upgrade (notmuch_database_t *notmuch,
if (private_status) { if (private_status) {
_notmuch_database_log (notmuch, _notmuch_database_log (notmuch,
"Upgrade failed while creating ghost messages.\n"); "Upgrade failed while creating ghost messages.\n");
status = COERCE_STATUS (private_status, "Unexpected status from _notmuch_message_initialize_ghost"); status = COERCE_STATUS (private_status,
"Unexpected status from _notmuch_message_initialize_ghost");
goto DONE; goto DONE;
} }
@ -1498,7 +1503,8 @@ notmuch_database_find_message_by_filename (notmuch_database_t *notmuch,
status = NOTMUCH_STATUS_OUT_OF_MEMORY; status = NOTMUCH_STATUS_OUT_OF_MEMORY;
} }
} catch (const Xapian::Error &error) { } catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred finding message by filename: %s\n", _notmuch_database_log (notmuch,
"Error: A Xapian exception occurred finding message by filename: %s\n",
error.get_msg ().c_str ()); error.get_msg ().c_str ());
notmuch->exception_reported = true; notmuch->exception_reported = true;
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION; status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;

4
lib/directory.cc
View file

@ -52,8 +52,10 @@ struct _notmuch_directory {
#define LOG_XAPIAN_EXCEPTION(directory, error) _log_xapian_exception (__location__, directory, error) #define LOG_XAPIAN_EXCEPTION(directory, error) _log_xapian_exception (__location__, directory, error)
static void static void
_log_xapian_exception (const char *where, notmuch_directory_t *dir, const Xapian::Error error) { _log_xapian_exception (const char *where, notmuch_directory_t *dir, const Xapian::Error error)
{
notmuch_database_t *notmuch = dir->notmuch; notmuch_database_t *notmuch = dir->notmuch;
_notmuch_database_log (notmuch, _notmuch_database_log (notmuch,
"A Xapian exception occurred at %s: %s\n", "A Xapian exception occurred at %s: %s\n",
where, where,

2
lib/features.cc
View file

@ -64,7 +64,7 @@ _notmuch_database_print_features (const void *ctx, unsigned int features)
*/ */
_notmuch_features _notmuch_features
_notmuch_database_parse_features (const void *ctx, const char *features, unsigned int version, _notmuch_database_parse_features (const void *ctx, const char *features, unsigned int version,
char mode, char **incompat_out) char mode, char **incompat_out)
{ {
_notmuch_features res = static_cast<_notmuch_features>(0); _notmuch_features res = static_cast<_notmuch_features>(0);
unsigned int namelen, i; unsigned int namelen, i;

28
lib/index.cc
View file

@ -260,7 +260,8 @@ notmuch_filter_discard_non_term_new (GMimeContentType *content_type)
.value_table = NULL, .value_table = NULL,
}; };
type = g_type_register_static (GMIME_TYPE_FILTER, "NotmuchFilterDiscardNonTerm", &info, (GTypeFlags) 0); type = g_type_register_static (GMIME_TYPE_FILTER, "NotmuchFilterDiscardNonTerm", &info,
(GTypeFlags) 0);
} }
filter = (NotmuchFilterDiscardNonTerm *) g_object_new (type, NULL); filter = (NotmuchFilterDiscardNonTerm *) g_object_new (type, NULL);
@ -455,7 +456,8 @@ _index_mime_part (notmuch_message_t *message,
msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL) { msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL) {
toindex = _notmuch_repair_crypto_payload_skip_legacy_display (child); toindex = _notmuch_repair_crypto_payload_skip_legacy_display (child);
if (toindex != child) if (toindex != child)
notmuch_message_add_property (message, "index.repaired", "skip-protected-headers-legacy-display"); notmuch_message_add_property (message, "index.repaired",
"skip-protected-headers-legacy-display");
} }
_index_mime_part (message, indexopts, toindex, msg_crypto); _index_mime_part (message, indexopts, toindex, msg_crypto);
} }
@ -467,7 +469,8 @@ _index_mime_part (notmuch_message_t *message,
mime_message = g_mime_message_part_get_message (GMIME_MESSAGE_PART (part)); mime_message = g_mime_message_part_get_message (GMIME_MESSAGE_PART (part));
_index_mime_part (message, indexopts, g_mime_message_get_mime_part (mime_message), msg_crypto); _index_mime_part (message, indexopts, g_mime_message_get_mime_part (mime_message),
msg_crypto);
goto DONE; goto DONE;
} }
@ -567,6 +570,7 @@ _index_encrypted_mime_part (notmuch_message_t *message,
bool attempted = false; bool attempted = false;
GMimeDecryptResult *decrypt_result = NULL; GMimeDecryptResult *decrypt_result = NULL;
bool get_sk = (notmuch_indexopts_get_decrypt_policy (indexopts) == NOTMUCH_DECRYPT_TRUE); bool get_sk = (notmuch_indexopts_get_decrypt_policy (indexopts) == NOTMUCH_DECRYPT_TRUE);
clear = _notmuch_crypto_decrypt (&attempted, notmuch_indexopts_get_decrypt_policy (indexopts), clear = _notmuch_crypto_decrypt (&attempted, notmuch_indexopts_get_decrypt_policy (indexopts),
message, encrypted_data, get_sk ? &decrypt_result : NULL, &err); message, encrypted_data, get_sk ? &decrypt_result : NULL, &err);
if (! attempted) if (! attempted)
@ -595,7 +599,8 @@ _index_encrypted_mime_part (notmuch_message_t *message,
notmuch_status_to_string (status)); notmuch_status_to_string (status));
if (get_sk) { if (get_sk) {
status = notmuch_message_add_property (message, "session-key", status = notmuch_message_add_property (message, "session-key",
g_mime_decrypt_result_get_session_key (decrypt_result)); g_mime_decrypt_result_get_session_key (
decrypt_result));
if (status) if (status)
_notmuch_database_log (notmuch, "failed to add session-key " _notmuch_database_log (notmuch, "failed to add session-key "
"property (%d)\n", status); "property (%d)\n", status);
@ -603,11 +608,14 @@ _index_encrypted_mime_part (notmuch_message_t *message,
g_object_unref (decrypt_result); g_object_unref (decrypt_result);
} }
GMimeObject *toindex = clear; GMimeObject *toindex = clear;
if (_notmuch_message_crypto_potential_payload (msg_crypto, clear, encrypted_data, GMIME_MULTIPART_ENCRYPTED_CONTENT) &&
if (_notmuch_message_crypto_potential_payload (msg_crypto, clear, encrypted_data,
GMIME_MULTIPART_ENCRYPTED_CONTENT) &&
msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL) { msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL) {
toindex = _notmuch_repair_crypto_payload_skip_legacy_display (clear); toindex = _notmuch_repair_crypto_payload_skip_legacy_display (clear);
if (toindex != clear) if (toindex != clear)
notmuch_message_add_property (message, "index.repaired", "skip-protected-headers-legacy-display"); notmuch_message_add_property (message, "index.repaired",
"skip-protected-headers-legacy-display");
} }
_index_mime_part (message, indexopts, toindex, msg_crypto); _index_mime_part (message, indexopts, toindex, msg_crypto);
g_object_unref (clear); g_object_unref (clear);
@ -640,7 +648,8 @@ _index_pkcs7_part (notmuch_message_t *message,
if (p7type == GMIME_SECURE_MIME_TYPE_SIGNED_DATA) { if (p7type == GMIME_SECURE_MIME_TYPE_SIGNED_DATA) {
sigs = g_mime_application_pkcs7_mime_verify (pkcs7, GMIME_VERIFY_NONE, &mimeobj, &err); sigs = g_mime_application_pkcs7_mime_verify (pkcs7, GMIME_VERIFY_NONE, &mimeobj, &err);
if (sigs == NULL) { if (sigs == NULL) {
_notmuch_database_log (notmuch, "Failed to verify PKCS#7 SignedData during indexing. (%d:%d) [%s]\n", _notmuch_database_log (notmuch,
"Failed to verify PKCS#7 SignedData during indexing. (%d:%d) [%s]\n",
err->domain, err->code, err->message); err->domain, err->code, err->message);
g_error_free (err); g_error_free (err);
goto DONE; goto DONE;
@ -651,7 +660,8 @@ _index_pkcs7_part (notmuch_message_t *message,
msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL) { msg_crypto->decryption_status == NOTMUCH_MESSAGE_DECRYPTED_FULL) {
toindex = _notmuch_repair_crypto_payload_skip_legacy_display (mimeobj); toindex = _notmuch_repair_crypto_payload_skip_legacy_display (mimeobj);
if (toindex != mimeobj) if (toindex != mimeobj)
notmuch_message_add_property (message, "index.repaired", "skip-protected-headers-legacy-display"); notmuch_message_add_property (message, "index.repaired",
"skip-protected-headers-legacy-display");
} }
_index_mime_part (message, indexopts, toindex, msg_crypto); _index_mime_part (message, indexopts, toindex, msg_crypto);
} else if (p7type == GMIME_SECURE_MIME_TYPE_ENVELOPED_DATA) { } else if (p7type == GMIME_SECURE_MIME_TYPE_ENVELOPED_DATA) {
@ -663,7 +673,7 @@ _index_pkcs7_part (notmuch_message_t *message,
_notmuch_database_log (notmuch, "Cannot currently handle PKCS#7 smime-type '%s'\n", _notmuch_database_log (notmuch, "Cannot currently handle PKCS#7 smime-type '%s'\n",
g_mime_object_get_content_type_parameter (part, "smime-type")); g_mime_object_get_content_type_parameter (part, "smime-type"));
} }
DONE: DONE:
if (mimeobj) if (mimeobj)
g_object_unref (mimeobj); g_object_unref (mimeobj);
if (sigs) if (sigs)

1
lib/indexopts.c
View file

@ -31,6 +31,7 @@ notmuch_database_get_default_indexopts (notmuch_database_t *db)
char *decrypt_policy; char *decrypt_policy;
notmuch_status_t err = notmuch_database_get_config (db, "index.decrypt", &decrypt_policy); notmuch_status_t err = notmuch_database_get_config (db, "index.decrypt", &decrypt_policy);
if (err) if (err)
return NULL; return NULL;

5
lib/message-file.c
View file

@ -65,11 +65,12 @@ _notmuch_message_file_open_ctx (notmuch_database_t *notmuch,
return NULL; return NULL;
const char *prefix = notmuch_database_get_path (notmuch); const char *prefix = notmuch_database_get_path (notmuch);
if (prefix == NULL) if (prefix == NULL)
goto FAIL; goto FAIL;
if (*filename == '/') { if (*filename == '/') {
if (strncmp (filename, prefix, strlen(prefix)) != 0) { if (strncmp (filename, prefix, strlen (prefix)) != 0) {
_notmuch_database_log (notmuch, "Error opening %s: path outside mail root\n", _notmuch_database_log (notmuch, "Error opening %s: path outside mail root\n",
filename); filename);
errno = 0; errno = 0;
@ -77,7 +78,7 @@ _notmuch_message_file_open_ctx (notmuch_database_t *notmuch,
} }
message->filename = talloc_strdup (message, filename); message->filename = talloc_strdup (message, filename);
} else { } else {
message->filename = talloc_asprintf(message, "%s/%s", prefix, filename); message->filename = talloc_asprintf (message, "%s/%s", prefix, filename);
} }
if (message->filename == NULL) if (message->filename == NULL)

2
lib/message-property.cc
View file

@ -43,11 +43,13 @@ notmuch_message_count_properties (notmuch_message_t *message, const char *key, u
return NOTMUCH_STATUS_NULL_POINTER; return NOTMUCH_STATUS_NULL_POINTER;
notmuch_string_map_t *map; notmuch_string_map_t *map;
map = _notmuch_message_property_map (message); map = _notmuch_message_property_map (message);
if (! map) if (! map)
return NOTMUCH_STATUS_NULL_POINTER; return NOTMUCH_STATUS_NULL_POINTER;
notmuch_string_map_iterator_t *matcher = _notmuch_string_map_iterator_create (map, key, true); notmuch_string_map_iterator_t *matcher = _notmuch_string_map_iterator_create (map, key, true);
if (! matcher) if (! matcher)
return NOTMUCH_STATUS_OUT_OF_MEMORY; return NOTMUCH_STATUS_OUT_OF_MEMORY;

17
lib/message.cc
View file

@ -93,8 +93,10 @@ _notmuch_message_destructor (notmuch_message_t *message)
#define LOG_XAPIAN_EXCEPTION(message, error) _log_xapian_exception (__location__, message, error) #define LOG_XAPIAN_EXCEPTION(message, error) _log_xapian_exception (__location__, message, error)
static void static void
_log_xapian_exception (const char *where, notmuch_message_t *message, const Xapian::Error error) { _log_xapian_exception (const char *where, notmuch_message_t *message, const Xapian::Error error)
{
notmuch_database_t *notmuch = notmuch_message_get_database (message); notmuch_database_t *notmuch = notmuch_message_get_database (message);
_notmuch_database_log (notmuch, _notmuch_database_log (notmuch,
"A Xapian exception occurred at %s: %s\n", "A Xapian exception occurred at %s: %s\n",
where, where,
@ -286,7 +288,8 @@ _notmuch_message_create_for_message_id (notmuch_database_t *notmuch,
doc_id = _notmuch_database_generate_doc_id (notmuch); doc_id = _notmuch_database_generate_doc_id (notmuch);
} catch (const Xapian::Error &error) { } catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch_message_get_database (message), "A Xapian exception occurred creating message: %s\n", _notmuch_database_log (notmuch_message_get_database (message),
"A Xapian exception occurred creating message: %s\n",
error.get_msg ().c_str ()); error.get_msg ().c_str ());
notmuch->exception_reported = true; notmuch->exception_reported = true;
*status_ret = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION; *status_ret = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION;
@ -318,6 +321,7 @@ _notmuch_message_get_term (notmuch_message_t *message,
return NULL; return NULL;
const std::string &term = *i; const std::string &term = *i;
if (strncmp (term.c_str (), prefix, prefix_len)) if (strncmp (term.c_str (), prefix, prefix_len))
return NULL; return NULL;
@ -1765,6 +1769,7 @@ notmuch_message_has_maildir_flag (notmuch_message_t *message, char flag)
{ {
notmuch_status_t status; notmuch_status_t status;
notmuch_bool_t ret; notmuch_bool_t ret;
status = notmuch_message_has_maildir_flag_st (message, flag, &ret); status = notmuch_message_has_maildir_flag_st (message, flag, &ret);
if (status) if (status)
return FALSE; return FALSE;
@ -2079,8 +2084,8 @@ notmuch_message_remove_all_tags (notmuch_message_t *message)
private_status = _notmuch_message_remove_term (message, "tag", tag); private_status = _notmuch_message_remove_term (message, "tag", tag);
if (private_status) { if (private_status) {
return COERCE_STATUS (private_status, return COERCE_STATUS (private_status,
"_notmuch_message_remove_term return unexpected value: %d\n", "_notmuch_message_remove_term return unexpected value: %d\n",
private_status); private_status);
} }
} }
@ -2202,8 +2207,8 @@ notmuch_message_reindex (notmuch_message_t *message,
orig_thread_id = notmuch_message_get_thread_id (message); orig_thread_id = notmuch_message_get_thread_id (message);
if (! orig_thread_id) { if (! orig_thread_id) {
/* the following is correct as long as there is only one reason /* the following is correct as long as there is only one reason
n_m_get_thread_id returns NULL * n_m_get_thread_id returns NULL
*/ */
return NOTMUCH_STATUS_XAPIAN_EXCEPTION; return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
} }

8
lib/notmuch-private.h
View file

@ -716,16 +716,16 @@ struct _notmuch_indexopts {
/* config.cc */ /* config.cc */
notmuch_status_t notmuch_status_t
_notmuch_config_load_from_database (notmuch_database_t * db); _notmuch_config_load_from_database (notmuch_database_t *db);
notmuch_status_t notmuch_status_t
_notmuch_config_load_from_file (notmuch_database_t * db, GKeyFile *file); _notmuch_config_load_from_file (notmuch_database_t *db, GKeyFile *file);
notmuch_status_t notmuch_status_t
_notmuch_config_load_defaults (notmuch_database_t * db); _notmuch_config_load_defaults (notmuch_database_t *db);
void void
_notmuch_config_cache (notmuch_database_t *db, notmuch_config_key_t key, const char* val); _notmuch_config_cache (notmuch_database_t *db, notmuch_config_key_t key, const char *val);
NOTMUCH_END_DECLS NOTMUCH_END_DECLS

7
lib/notmuch.h
View file

@ -1631,7 +1631,7 @@ typedef enum _notmuch_message_flag {
* @deprecated Deprecated as of libnotmuch 5.3 (notmuch 0.31). Please * @deprecated Deprecated as of libnotmuch 5.3 (notmuch 0.31). Please
* use notmuch_message_get_flag_st instead. * use notmuch_message_get_flag_st instead.
*/ */
NOTMUCH_DEPRECATED(5,3) NOTMUCH_DEPRECATED (5, 3)
notmuch_bool_t notmuch_bool_t
notmuch_message_get_flag (notmuch_message_t *message, notmuch_message_get_flag (notmuch_message_t *message,
notmuch_message_flag_t flag); notmuch_message_flag_t flag);
@ -1826,7 +1826,7 @@ notmuch_message_maildir_flags_to_tags (notmuch_message_t *message);
* @returns FALSE in case of error * @returns FALSE in case of error
* @deprecated libnotmuch 5.3 (notmuch 0.31) * @deprecated libnotmuch 5.3 (notmuch 0.31)
*/ */
NOTMUCH_DEPRECATED(5, 3) NOTMUCH_DEPRECATED (5, 3)
notmuch_bool_t notmuch_bool_t
notmuch_message_has_maildir_flag (notmuch_message_t *message, char flag); notmuch_message_has_maildir_flag (notmuch_message_t *message, char flag);
@ -2403,7 +2403,8 @@ notmuch_database_get_config (notmuch_database_t *db, const char *key, char **val
* @since libnotmuch 4.4 (notmuch 0.23) * @since libnotmuch 4.4 (notmuch 0.23)
*/ */
notmuch_status_t notmuch_status_t
notmuch_database_get_config_list (notmuch_database_t *db, const char *prefix, notmuch_config_list_t **out); notmuch_database_get_config_list (notmuch_database_t *db, const char *prefix,
notmuch_config_list_t **out);
/** /**
* Is 'config_list' iterator valid (i.e. _key, _value, _move_to_next can be called). * Is 'config_list' iterator valid (i.e. _key, _value, _move_to_next can be called).

14
lib/open.cc
View file

@ -85,7 +85,7 @@ _choose_hook_dir (notmuch_database_t *notmuch,
config = _xdg_dir (notmuch, "XDG_CONFIG_HOME", ".config", profile); config = _xdg_dir (notmuch, "XDG_CONFIG_HOME", ".config", profile);
if (! config) if (! config)
return NOTMUCH_STATUS_PATH_ERROR; return NOTMUCH_STATUS_PATH_ERROR;
hook_dir = talloc_asprintf (notmuch, "%s/hooks", config); hook_dir = talloc_asprintf (notmuch, "%s/hooks", config);
@ -125,7 +125,7 @@ _load_key_file (const char *path,
if (dir) { if (dir) {
path = talloc_asprintf (local, "%s/config", dir); path = talloc_asprintf (local, "%s/config", dir);
if (access (path, R_OK) !=0) if (access (path, R_OK) != 0)
path = NULL; path = NULL;
} }
} }
@ -147,7 +147,7 @@ _load_key_file (const char *path,
status = NOTMUCH_STATUS_NO_CONFIG; status = NOTMUCH_STATUS_NO_CONFIG;
} }
DONE: DONE:
talloc_free (local); talloc_free (local);
return status; return status;
} }
@ -161,7 +161,7 @@ _choose_database_path (const char *config_path,
{ {
notmuch_status_t status; notmuch_status_t status;
status =_load_key_file (config_path, profile, key_file); status = _load_key_file (config_path, profile, key_file);
if (status) { if (status) {
*message = strdup ("Error: cannot load config file.\n"); *message = strdup ("Error: cannot load config file.\n");
return status; return status;
@ -319,8 +319,10 @@ notmuch_database_open_with_config (const char *database_path,
notmuch->term_gen = new Xapian::TermGenerator; notmuch->term_gen = new Xapian::TermGenerator;
notmuch->term_gen->set_stemmer (Xapian::Stem ("english")); notmuch->term_gen->set_stemmer (Xapian::Stem ("english"));
notmuch->value_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_TIMESTAMP); notmuch->value_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_TIMESTAMP);
notmuch->date_range_processor = new ParseTimeRangeProcessor (NOTMUCH_VALUE_TIMESTAMP, "date:"); notmuch->date_range_processor = new ParseTimeRangeProcessor (NOTMUCH_VALUE_TIMESTAMP,
notmuch->last_mod_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_LAST_MOD, "lastmod:"); "date:");
notmuch->last_mod_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_LAST_MOD,
"lastmod:");
notmuch->query_parser->set_default_op (Xapian::Query::OP_AND); notmuch->query_parser->set_default_op (Xapian::Query::OP_AND);
notmuch->query_parser->set_database (*notmuch->xapian_db); notmuch->query_parser->set_database (*notmuch->xapian_db);
notmuch->query_parser->set_stemmer (Xapian::Stem ("english")); notmuch->query_parser->set_stemmer (Xapian::Stem ("english"));

4
lib/parse-time-vrp.cc
View file

@ -35,14 +35,14 @@ ParseTimeRangeProcessor::operator() (const std::string &begin, const std::string
if (time (&now) == (time_t) -1) if (time (&now) == (time_t) -1)
throw Xapian::QueryParserError ("unable to get current time"); throw Xapian::QueryParserError ("unable to get current time");
if (!begin.empty ()) { if (! begin.empty ()) {
if (parse_time_string (begin.c_str (), &parsed_time, &now, PARSE_TIME_ROUND_DOWN)) if (parse_time_string (begin.c_str (), &parsed_time, &now, PARSE_TIME_ROUND_DOWN))
throw Xapian::QueryParserError ("Didn't understand date specification '" + begin + "'"); throw Xapian::QueryParserError ("Didn't understand date specification '" + begin + "'");
else else
from = (double) parsed_time; from = (double) parsed_time;
} }
if (!end.empty ()) { if (! end.empty ()) {
if (end == "!" && ! begin.empty ()) if (end == "!" && ! begin.empty ())
str = begin; str = begin;
else else

4
lib/prefix.cc
View file

@ -133,8 +133,8 @@ _setup_query_field (const prefix_t *prefix, notmuch_database_t *notmuch)
Xapian::FieldProcessor *fp; Xapian::FieldProcessor *fp;
if (STRNCMP_LITERAL (prefix->name, "date") == 0) if (STRNCMP_LITERAL (prefix->name, "date") == 0)
fp = (new DateFieldProcessor(NOTMUCH_VALUE_TIMESTAMP))->release (); fp = (new DateFieldProcessor (NOTMUCH_VALUE_TIMESTAMP))->release ();
else if (STRNCMP_LITERAL(prefix->name, "query") == 0) else if (STRNCMP_LITERAL (prefix->name, "query") == 0)
fp = (new QueryFieldProcessor (*notmuch->query_parser, notmuch))->release (); fp = (new QueryFieldProcessor (*notmuch->query_parser, notmuch))->release ();
else if (STRNCMP_LITERAL (prefix->name, "thread") == 0) else if (STRNCMP_LITERAL (prefix->name, "thread") == 0)
fp = (new ThreadFieldProcessor (*notmuch->query_parser, notmuch))->release (); fp = (new ThreadFieldProcessor (*notmuch->query_parser, notmuch))->release ();

6
lib/string-map.c
View file

@ -154,10 +154,10 @@ _notmuch_string_map_set (notmuch_string_map_t *map,
_notmuch_string_map_sort (map); _notmuch_string_map_sort (map);
pair = bsearch_first (map->pairs, map->length, key, true); pair = bsearch_first (map->pairs, map->length, key, true);
if (! pair) if (! pair)
_notmuch_string_map_append (map, key, val); _notmuch_string_map_append (map, key, val);
else { else {
talloc_free (pair->value); talloc_free (pair->value);
pair->value = talloc_strdup (map->pairs, val); pair->value = talloc_strdup (map->pairs, val);
} }
} }

6
lib/thread-fp.cc
View file

@ -40,11 +40,13 @@ ThreadFieldProcessor::operator() (const std::string & str)
std::set<std::string> terms; std::set<std::string> terms;
if (! subquery) if (! subquery)
throw Xapian::QueryParserError ("failed to create subquery for '" + subquery_str + "'"); throw Xapian::QueryParserError ("failed to create subquery for '" + subquery_str +
"'");
status = notmuch_query_search_messages (subquery, &messages); status = notmuch_query_search_messages (subquery, &messages);
if (status) if (status)
throw Xapian::QueryParserError ("failed to search messages for '" + subquery_str + "'"); throw Xapian::QueryParserError ("failed to search messages for '" + subquery_str +
"'");
for (; notmuch_messages_valid (messages); notmuch_messages_move_to_next (messages)) { for (; notmuch_messages_valid (messages); notmuch_messages_move_to_next (messages)) {
std::string term = thread_prefix; std::string term = thread_prefix;

3
lib/thread.cc
View file

@ -505,7 +505,8 @@ _resolve_thread_relationships (notmuch_thread_t *thread)
notmuch_messages_valid (roots); notmuch_messages_valid (roots);
notmuch_messages_move_to_next (roots)) { notmuch_messages_move_to_next (roots)) {
notmuch_message_t *message = notmuch_messages_get (roots); notmuch_message_t *message = notmuch_messages_get (roots);
if (_notmuch_messages_has_next (roots) || ! _notmuch_message_list_empty (thread->toplevel_list)) if (_notmuch_messages_has_next (roots) || ! _notmuch_message_list_empty (
thread->toplevel_list))
_parent_or_toplevel (thread, message); _parent_or_toplevel (thread, message);
else else
_notmuch_message_list_add_message (thread->toplevel_list, message); _notmuch_message_list_add_message (thread->toplevel_list, message);