git.notmuchmail.org Git - notmuch/blob - lib/notmuch-private.h

   1 /* notmuch-private.h - Internal interfaces for notmuch.
   2  *
   3  * Copyright © 2009 Carl Worth
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see https://www.gnu.org/licenses/ .
  17  *
  18  * Author: Carl Worth <cworth@cworth.org>
  19  */
  20
  21 #ifndef NOTMUCH_PRIVATE_H
  22 #define NOTMUCH_PRIVATE_H
  23
  24 #ifndef _GNU_SOURCE
  25 #define _GNU_SOURCE /* For getline and asprintf */
  26 #endif
  27 #include <stdbool.h>
  28 #include <stdio.h>
  29
  30 #include "compat.h"
  31
  32 #include "notmuch.h"
  33
  34 NOTMUCH_BEGIN_DECLS
  35
  36 #include <stdlib.h>
  37 #include <stdarg.h>
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <sys/mman.h>
  41 #include <string.h>
  42 #include <errno.h>
  43 #include <fcntl.h>
  44 #include <unistd.h>
  45 #include <ctype.h>
  46 #include <assert.h>
  47
  48 #include <talloc.h>
  49
  50 #include "gmime-extra.h"
  51
  52 #include "xutil.h"
  53 #include "error_util.h"
  54 #include "string-util.h"
  55 #include "crypto.h"
  56
  57 #ifdef DEBUG
  58 # define DEBUG_DATABASE_SANITY 1
  59 # define DEBUG_THREADING 1
  60 # define DEBUG_QUERY 1
  61 #endif
  62
  63 #define COMPILE_TIME_ASSERT(pred) ((void)sizeof(char[1 - 2*!(pred)]))
  64
  65 #define STRNCMP_LITERAL(var, literal) \
  66     strncmp ((var), (literal), sizeof (literal) - 1)
  67
  68 /* Robust bit test/set/reset macros */
  69 #define _NOTMUCH_VALID_BIT(bit) \
  70     ((bit) >= 0 && ((unsigned long) bit) < CHAR_BIT * sizeof (unsigned long long))
  71 #define NOTMUCH_TEST_BIT(val, bit) \
  72     (_NOTMUCH_VALID_BIT(bit) ? !!((val) & (1ull << (bit))) : 0)
  73 #define NOTMUCH_SET_BIT(valp, bit) \
  74     (_NOTMUCH_VALID_BIT(bit) ? (*(valp) |= (1ull << (bit))) : *(valp))
  75 #define NOTMUCH_CLEAR_BIT(valp,  bit) \
  76     (_NOTMUCH_VALID_BIT(bit) ? (*(valp) &= ~(1ull << (bit))) : *(valp))
  77
  78 #define unused(x) x __attribute__ ((unused))
  79
  80 /* Thanks to Andrew Tridgell's (SAMBA's) talloc for this definition of
  81  * unlikely. The talloc source code comes to us via the GNU LGPL v. 3.
  82  */
  83 /* these macros gain us a few percent of speed on gcc */
  84 #if (__GNUC__ >= 3)
  85 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
  86    as its first argument */
  87 #ifndef likely
  88 #define likely(x)   __builtin_expect(!!(x), 1)
  89 #endif
  90 #ifndef unlikely
  91 #define unlikely(x) __builtin_expect(!!(x), 0)
  92 #endif
  93 #else
  94 #ifndef likely
  95 #define likely(x) (x)
  96 #endif
  97 #ifndef unlikely
  98 #define unlikely(x) (x)
  99 #endif
 100 #endif
 101
 102 typedef enum {
 103     NOTMUCH_VALUE_TIMESTAMP = 0,
 104     NOTMUCH_VALUE_MESSAGE_ID,
 105     NOTMUCH_VALUE_FROM,
 106     NOTMUCH_VALUE_SUBJECT,
 107     NOTMUCH_VALUE_LAST_MOD,
 108 } notmuch_value_t;
 109
 110 /* Xapian (with flint backend) complains if we provide a term longer
 111  * than this, but I haven't yet found a way to query the limit
 112  * programmatically. */
 113 #define NOTMUCH_TERM_MAX 245
 114
 115 #define NOTMUCH_METADATA_THREAD_ID_PREFIX "thread_id_"
 116
 117 /* For message IDs we have to be even more restrictive. Beyond fitting
 118  * into the term limit, we also use message IDs to construct
 119  * metadata-key values. And the documentation says that these should
 120  * be restricted to about 200 characters. (The actual limit for the
 121  * chert backend at least is 252.)
 122  */
 123 #define NOTMUCH_MESSAGE_ID_MAX (200 - sizeof (NOTMUCH_METADATA_THREAD_ID_PREFIX))
 124
 125 typedef enum _notmuch_private_status {
 126     /* First, copy all the public status values. */
 127     NOTMUCH_PRIVATE_STATUS_SUCCESS = NOTMUCH_STATUS_SUCCESS,
 128     NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY = NOTMUCH_STATUS_OUT_OF_MEMORY,
 129     NOTMUCH_PRIVATE_STATUS_READ_ONLY_DATABASE = NOTMUCH_STATUS_READ_ONLY_DATABASE,
 130     NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION = NOTMUCH_STATUS_XAPIAN_EXCEPTION,
 131     NOTMUCH_PRIVATE_STATUS_FILE_NOT_EMAIL = NOTMUCH_STATUS_FILE_NOT_EMAIL,
 132     NOTMUCH_PRIVATE_STATUS_NULL_POINTER = NOTMUCH_STATUS_NULL_POINTER,
 133     NOTMUCH_PRIVATE_STATUS_TAG_TOO_LONG = NOTMUCH_STATUS_TAG_TOO_LONG,
 134     NOTMUCH_PRIVATE_STATUS_UNBALANCED_FREEZE_THAW = NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW,
 135
 136     /* Then add our own private values. */
 137     NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG = NOTMUCH_STATUS_LAST_STATUS,
 138     NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND,
 139
 140     NOTMUCH_PRIVATE_STATUS_LAST_STATUS
 141 } notmuch_private_status_t;
 142
 143 /* Coerce a notmuch_private_status_t value to a notmuch_status_t
 144  * value, generating an internal error if the private value is equal
 145  * to or greater than NOTMUCH_STATUS_LAST_STATUS. (The idea here is
 146  * that the caller has previously handled any expected
 147  * notmuch_private_status_t values.)
 148  *
 149  * Note that the function _internal_error does not return. Evaluating
 150  * to NOTMUCH_STATUS_SUCCESS is done purely to appease the compiler.
 151  */
 152 #define COERCE_STATUS(private_status, format, ...)                      \
 153     ((private_status >= (notmuch_private_status_t) NOTMUCH_STATUS_LAST_STATUS)\
 154      ?                                                                  \
 155      _internal_error (format " (%s).\n",                                \
 156                       ##__VA_ARGS__,                                    \
 157                       __location__),                                    \
 158      (notmuch_status_t) NOTMUCH_PRIVATE_STATUS_SUCCESS                  \
 159      :                                                                  \
 160      (notmuch_status_t) private_status)
 161
 162 /* Flags shared by various lookup functions. */
 163 typedef enum _notmuch_find_flags {
 164     /* Lookup without creating any documents.  This is the default
 165      * behavior. */
 166     NOTMUCH_FIND_LOOKUP = 0,
 167     /* If set, create the necessary document (or documents) if they
 168      * are missing.  Requires a read/write database. */
 169     NOTMUCH_FIND_CREATE = 1<<0,
 170 } notmuch_find_flags_t;
 171
 172 typedef struct _notmuch_doc_id_set notmuch_doc_id_set_t;
 173
 174 /* database.cc */
 175
 176 /* Lookup a prefix value by name.
 177  *
 178  * XXX: This should really be static inside of message.cc, and we can
 179  * do that once we convert database.cc to use the
 180  * _notmuch_message_add/remove_term functions. */
 181 const char *
 182 _find_prefix (const char *name);
 183
 184 char *
 185 _notmuch_message_id_compressed (void *ctx, const char *message_id);
 186
 187 notmuch_status_t
 188 _notmuch_database_ensure_writable (notmuch_database_t *notmuch);
 189
 190 notmuch_status_t
 191 _notmuch_database_reopen (notmuch_database_t *notmuch);
 192
 193 void
 194 _notmuch_database_log (notmuch_database_t *notmuch,
 195                        const char *format, ...);
 196
 197 void
 198 _notmuch_database_log_append (notmuch_database_t *notmuch,
 199                               const char *format, ...);
 200
 201 unsigned long
 202 _notmuch_database_new_revision (notmuch_database_t *notmuch);
 203
 204 const char *
 205 _notmuch_database_relative_path (notmuch_database_t *notmuch,
 206                                  const char *path);
 207
 208 notmuch_status_t
 209 _notmuch_database_split_path (void *ctx,
 210                               const char *path,
 211                               const char **directory,
 212                               const char **basename);
 213
 214 const char *
 215 _notmuch_database_get_directory_db_path (const char *path);
 216
 217 unsigned int
 218 _notmuch_database_generate_doc_id (notmuch_database_t *notmuch);
 219
 220 notmuch_private_status_t
 221 _notmuch_database_find_unique_doc_id (notmuch_database_t *notmuch,
 222                                       const char *prefix_name,
 223                                       const char *value,
 224                                       unsigned int *doc_id);
 225
 226 notmuch_status_t
 227 _notmuch_database_find_directory_id (notmuch_database_t *database,
 228                                      const char *path,
 229                                      notmuch_find_flags_t flags,
 230                                      unsigned int *directory_id);
 231
 232 const char *
 233 _notmuch_database_get_directory_path (void *ctx,
 234                                       notmuch_database_t *notmuch,
 235                                       unsigned int doc_id);
 236
 237 notmuch_status_t
 238 _notmuch_database_filename_to_direntry (void *ctx,
 239                                         notmuch_database_t *notmuch,
 240                                         const char *filename,
 241                                         notmuch_find_flags_t flags,
 242                                         char **direntry);
 243
 244 /* directory.cc */
 245
 246 notmuch_directory_t *
 247 _notmuch_directory_create (notmuch_database_t *notmuch,
 248                            const char *path,
 249                            notmuch_find_flags_t flags,
 250                            notmuch_status_t *status_ret);
 251
 252 unsigned int
 253 _notmuch_directory_get_document_id (notmuch_directory_t *directory);
 254
 255 /* message.cc */
 256
 257 notmuch_message_t *
 258 _notmuch_message_create (const void *talloc_owner,
 259                          notmuch_database_t *notmuch,
 260                          unsigned int doc_id,
 261                          notmuch_private_status_t *status);
 262
 263 notmuch_message_t *
 264 _notmuch_message_create_for_message_id (notmuch_database_t *notmuch,
 265                                         const char *message_id,
 266                                         notmuch_private_status_t *status);
 267
 268 unsigned int
 269 _notmuch_message_get_doc_id (notmuch_message_t *message);
 270
 271 const char *
 272 _notmuch_message_get_in_reply_to (notmuch_message_t *message);
 273
 274 notmuch_private_status_t
 275 _notmuch_message_add_term (notmuch_message_t *message,
 276                            const char *prefix_name,
 277                            const char *value);
 278
 279 notmuch_private_status_t
 280 _notmuch_message_remove_term (notmuch_message_t *message,
 281                               const char *prefix_name,
 282                               const char *value);
 283
 284 notmuch_private_status_t
 285 _notmuch_message_has_term (notmuch_message_t *message,
 286                            const char *prefix_name,
 287                            const char *value,
 288                            bool *result);
 289
 290 notmuch_private_status_t
 291 _notmuch_message_gen_terms (notmuch_message_t *message,
 292                             const char *prefix_name,
 293                             const char *text);
 294
 295 void
 296 _notmuch_message_upgrade_filename_storage (notmuch_message_t *message);
 297
 298 void
 299 _notmuch_message_upgrade_folder (notmuch_message_t *message);
 300
 301 notmuch_status_t
 302 _notmuch_message_add_filename (notmuch_message_t *message,
 303                                const char *filename);
 304
 305 notmuch_status_t
 306 _notmuch_message_remove_filename (notmuch_message_t *message,
 307                                   const char *filename);
 308
 309 notmuch_status_t
 310 _notmuch_message_rename (notmuch_message_t *message,
 311                          const char *new_filename);
 312
 313 void
 314 _notmuch_message_ensure_thread_id (notmuch_message_t *message);
 315
 316 void
 317 _notmuch_message_set_header_values (notmuch_message_t *message,
 318                                     const char *date,
 319                                     const char *from,
 320                                     const char *subject);
 321
 322 void
 323 _notmuch_message_upgrade_last_mod (notmuch_message_t *message);
 324
 325 void
 326 _notmuch_message_sync (notmuch_message_t *message);
 327
 328 notmuch_status_t
 329 _notmuch_message_delete (notmuch_message_t *message);
 330
 331 notmuch_private_status_t
 332 _notmuch_message_initialize_ghost (notmuch_message_t *message,
 333                                    const char *thread_id);
 334
 335 void
 336 _notmuch_message_close (notmuch_message_t *message);
 337
 338 /* Get a copy of the data in this message document.
 339  *
 340  * Caller should talloc_free the result when done.
 341  *
 342  * This function is intended to support database upgrade and really
 343  * shouldn't be used otherwise. */
 344 char *
 345 _notmuch_message_talloc_copy_data (notmuch_message_t *message);
 346
 347 /* Clear the data in this message document.
 348  *
 349  * This function is intended to support database upgrade and really
 350  * shouldn't be used otherwise. */
 351 void
 352 _notmuch_message_clear_data (notmuch_message_t *message);
 353
 354 /* Set the author member of 'message' - this is the representation used
 355  * when displaying the message */
 356 void
 357 _notmuch_message_set_author (notmuch_message_t *message, const char *author);
 358
 359 /* Get the author member of 'message' */
 360 const char *
 361 _notmuch_message_get_author (notmuch_message_t *message);
 362
 363 /* message-file.c */
 364
 365 /* XXX: I haven't decided yet whether these will actually get exported
 366  * into the public interface in notmuch.h
 367  */
 368
 369 typedef struct _notmuch_message_file notmuch_message_file_t;
 370
 371 /* Open a file containing a single email message.
 372  *
 373  * The caller should call notmuch_message_close when done with this.
 374  *
 375  * Returns NULL if any error occurs.
 376  */
 377 notmuch_message_file_t *
 378 _notmuch_message_file_open (notmuch_database_t *notmuch, const char *filename);
 379
 380 /* Like notmuch_message_file_open but with 'ctx' as the talloc owner. */
 381 notmuch_message_file_t *
 382 _notmuch_message_file_open_ctx (notmuch_database_t *notmuch,
 383                                 void *ctx, const char *filename);
 384
 385 /* Close a notmuch message previously opened with notmuch_message_open. */
 386 void
 387 _notmuch_message_file_close (notmuch_message_file_t *message);
 388
 389 /* Parse the message.
 390  *
 391  * This will be done automatically as necessary on other calls
 392  * depending on it, but an explicit call allows for better error
 393  * status reporting.
 394  */
 395 notmuch_status_t
 396 _notmuch_message_file_parse (notmuch_message_file_t *message);
 397
 398 /* Get the gmime message of a message file.
 399  *
 400  * The message file is parsed as necessary.
 401  *
 402  * The GMimeMessage* is set to *mime_message on success (which the
 403  * caller must not unref).
 404  *
 405  * XXX: Would be nice to not have to expose GMimeMessage here.
 406  */
 407 notmuch_status_t
 408 _notmuch_message_file_get_mime_message (notmuch_message_file_t *message,
 409                                         GMimeMessage **mime_message);
 410
 411 /* Get the value of the specified header from the message as a UTF-8 string.
 412  *
 413  * The message file is parsed as necessary.
 414  *
 415  * The header name is case insensitive.
 416  *
 417  * The Received: header is special - for it all Received: headers in
 418  * the message are concatenated
 419  *
 420  * The returned value is owned by the notmuch message and is valid
 421  * only until the message is closed. The caller should copy it if
 422  * needing to modify the value or to hold onto it for longer.
 423  *
 424  * Returns NULL on errors, empty string if the message does not
 425  * contain a header line matching 'header'.
 426  */
 427 const char *
 428 _notmuch_message_file_get_header (notmuch_message_file_t *message,
 429                                  const char *header);
 430
 431 notmuch_status_t
 432 _notmuch_message_file_get_headers (notmuch_message_file_t *message_file,
 433                                    const char **from_out,
 434                                    const char **subject_out,
 435                                    const char **to_out,
 436                                    const char **date_out,
 437                                    char **message_id_out);
 438
 439 const char *
 440 _notmuch_message_file_get_filename (notmuch_message_file_t *message);
 441
 442 /* add-message.cc */
 443 notmuch_status_t
 444 _notmuch_database_link_message_to_parents (notmuch_database_t *notmuch,
 445                                            notmuch_message_t *message,
 446                                            notmuch_message_file_t *message_file,
 447                                            const char **thread_id);
 448 /* index.cc */
 449
 450 notmuch_status_t
 451 _notmuch_message_index_file (notmuch_message_t *message,
 452                              notmuch_indexopts_t *indexopts,
 453                              notmuch_message_file_t *message_file);
 454
 455 /* messages.c */
 456
 457 typedef struct _notmuch_message_node {
 458     notmuch_message_t *message;
 459     struct _notmuch_message_node *next;
 460 } notmuch_message_node_t;
 461
 462 typedef struct _notmuch_message_list {
 463     notmuch_message_node_t *head;
 464     notmuch_message_node_t **tail;
 465 } notmuch_message_list_t;
 466
 467 /* There's a rumor that there's an alternate struct _notmuch_messages
 468  * somewhere with some nasty C++ objects in it. We'll try to maintain
 469  * ignorance of that here. (See notmuch_mset_messages_t in query.cc)
 470  */
 471 struct _notmuch_messages {
 472     bool is_of_list_type;
 473     notmuch_doc_id_set_t *excluded_doc_ids;
 474     notmuch_message_node_t *iterator;
 475 };
 476
 477 notmuch_message_list_t *
 478 _notmuch_message_list_create (const void *ctx);
 479
 480 bool
 481 _notmuch_message_list_empty (notmuch_message_list_t *list);
 482
 483 void
 484 _notmuch_message_list_add_message (notmuch_message_list_t *list,
 485                                    notmuch_message_t *message);
 486
 487 notmuch_messages_t *
 488 _notmuch_messages_create (notmuch_message_list_t *list);
 489
 490 bool
 491 _notmuch_messages_has_next (notmuch_messages_t *messages);
 492
 493 /* query.cc */
 494
 495 bool
 496 _notmuch_mset_messages_valid (notmuch_messages_t *messages);
 497
 498 notmuch_message_t *
 499 _notmuch_mset_messages_get (notmuch_messages_t *messages);
 500
 501 void
 502 _notmuch_mset_messages_move_to_next (notmuch_messages_t *messages);
 503
 504 bool
 505 _notmuch_doc_id_set_contains (notmuch_doc_id_set_t *doc_ids,
 506                               unsigned int doc_id);
 507
 508 void
 509 _notmuch_doc_id_set_remove (notmuch_doc_id_set_t *doc_ids,
 510                             unsigned int doc_id);
 511
 512 /* querying xapian documents by type (e.g. "mail" or "ghost"): */
 513 notmuch_status_t
 514 _notmuch_query_search_documents (notmuch_query_t *query,
 515                                  const char *type,
 516                                  notmuch_messages_t **out);
 517
 518 notmuch_status_t
 519 _notmuch_query_count_documents (notmuch_query_t *query,
 520                                 const char *type,
 521                                 unsigned *count_out);
 522 /* message-id.c */
 523
 524 /* Parse an RFC 822 message-id, discarding whitespace, any RFC 822
 525  * comments, and the '<' and '>' delimiters.
 526  *
 527  * If not NULL, then *next will be made to point to the first character
 528  * not parsed, (possibly pointing to the final '\0' terminator.
 529  *
 530  * Returns a newly talloc'ed string belonging to 'ctx'.
 531  *
 532  * Returns NULL if there is any error parsing the message-id. */
 533 char *
 534 _notmuch_message_id_parse (void *ctx, const char *message_id, const char **next);
 535
 536 /* Parse a message-id, discarding leading and trailing whitespace, and
 537  * '<' and '>' delimiters.
 538  *
 539  * Apply a probably-stricter-than RFC definition of what is allowed in
 540  * a message-id. In particular, forbid whitespace.
 541  *
 542  * Returns a newly talloc'ed string belonging to 'ctx'.
 543  *
 544  * Returns NULL if there is any error parsing the message-id.
 545  */
 546
 547 char *
 548 _notmuch_message_id_parse_strict (void *ctx, const char *message_id);
 549
 550
 551 /* message.cc */
 552
 553 void
 554 _notmuch_message_add_reply (notmuch_message_t *message,
 555                             notmuch_message_t *reply);
 556
 557 void
 558 _notmuch_message_remove_unprefixed_terms (notmuch_message_t *message);
 559
 560 const char *
 561 _notmuch_message_get_thread_id_only(notmuch_message_t *message);
 562
 563 size_t _notmuch_message_get_thread_depth (notmuch_message_t *message);
 564
 565 void
 566 _notmuch_message_label_depths (notmuch_message_t *message,
 567                                size_t depth);
 568
 569 notmuch_message_list_t *
 570 _notmuch_message_sort_subtrees (void *ctx, notmuch_message_list_t *list);
 571
 572 /* sha1.c */
 573
 574 char *
 575 _notmuch_sha1_of_string (const char *str);
 576
 577 char *
 578 _notmuch_sha1_of_file (const char *filename);
 579
 580 /* string-list.c */
 581
 582 typedef struct _notmuch_string_node {
 583     char *string;
 584     struct _notmuch_string_node *next;
 585 } notmuch_string_node_t;
 586
 587 typedef struct _notmuch_string_list {
 588     int length;
 589     notmuch_string_node_t *head;
 590     notmuch_string_node_t **tail;
 591 } notmuch_string_list_t;
 592
 593 notmuch_string_list_t *
 594 _notmuch_string_list_create (const void *ctx);
 595
 596 /*
 597  * return the number of strings in 'list'
 598  */
 599 int
 600 _notmuch_string_list_length (notmuch_string_list_t *list);
 601
 602 /* Add 'string' to 'list'.
 603  *
 604  * The list will create its own talloced copy of 'string'.
 605  */
 606 void
 607 _notmuch_string_list_append (notmuch_string_list_t *list,
 608                              const char *string);
 609
 610 void
 611 _notmuch_string_list_sort (notmuch_string_list_t *list);
 612
 613 const notmuch_string_list_t *
 614 _notmuch_message_get_references(notmuch_message_t *message);
 615
 616 /* string-map.c */
 617 typedef struct _notmuch_string_map  notmuch_string_map_t;
 618 typedef struct _notmuch_string_map_iterator notmuch_string_map_iterator_t;
 619 notmuch_string_map_t *
 620 _notmuch_string_map_create (const void *ctx);
 621
 622 void
 623 _notmuch_string_map_append (notmuch_string_map_t *map,
 624                             const char *key,
 625                             const char *value);
 626
 627 const char *
 628 _notmuch_string_map_get (notmuch_string_map_t *map, const char *key);
 629
 630 notmuch_string_map_iterator_t *
 631 _notmuch_string_map_iterator_create (notmuch_string_map_t *map, const char *key,
 632                                      bool exact);
 633
 634 bool
 635 _notmuch_string_map_iterator_valid (notmuch_string_map_iterator_t *iter);
 636
 637 void
 638 _notmuch_string_map_iterator_move_to_next (notmuch_string_map_iterator_t *iter);
 639
 640 const char *
 641 _notmuch_string_map_iterator_key (notmuch_string_map_iterator_t *iterator);
 642
 643 const char *
 644 _notmuch_string_map_iterator_value (notmuch_string_map_iterator_t *iterator);
 645
 646 void
 647 _notmuch_string_map_iterator_destroy (notmuch_string_map_iterator_t *iterator);
 648
 649 /* tags.c */
 650
 651 notmuch_tags_t *
 652 _notmuch_tags_create (const void *ctx, notmuch_string_list_t *list);
 653
 654 /* filenames.c */
 655
 656 /* The notmuch_filenames_t iterates over a notmuch_string_list_t of
 657  * file names */
 658 notmuch_filenames_t *
 659 _notmuch_filenames_create (const void *ctx,
 660                            notmuch_string_list_t *list);
 661
 662 /* thread.cc */
 663
 664 notmuch_thread_t *
 665 _notmuch_thread_create (void *ctx,
 666                         notmuch_database_t *notmuch,
 667                         unsigned int seed_doc_id,
 668                         notmuch_doc_id_set_t *match_set,
 669                         notmuch_string_list_t *excluded_terms,
 670                         notmuch_exclude_t omit_exclude,
 671                         notmuch_sort_t sort);
 672
 673 /* indexopts.c */
 674
 675 struct _notmuch_indexopts {
 676     _notmuch_crypto_t crypto;
 677 };
 678
 679 NOTMUCH_END_DECLS
 680
 681 #ifdef __cplusplus
 682 /* Implicit typecast from 'void *' to 'T *' is okay in C, but not in
 683  * C++. In talloc_steal, an explicit cast is provided for type safety
 684  * in some GCC versions. Otherwise, a cast is required. Provide a
 685  * template function for this to maintain type safety, and redefine
 686  * talloc_steal to use it.
 687  */
 688 #if !(__GNUC__ >= 3)
 689 template <class T> T *
 690 _notmuch_talloc_steal (const void *new_ctx, const T *ptr)
 691 {
 692     return static_cast<T *> (talloc_steal (new_ctx, ptr));
 693 }
 694 #undef talloc_steal
 695 #define talloc_steal _notmuch_talloc_steal
 696 #endif
 697 #endif
 698
 699 #endif