cli: modify mime_node_open to take new crypto struct as argument

[notmuch] / mime-node.c

diff --git a/mime-node.c b/mime-node.c
index 27077f7f40f34cdb89080ed43a64f72ac4e2a81d..67f4b1635be95cbc1657b50bf8113e2af2b1a0cb 100644 (file)
--- a/mime-node.c
+++ b/mime-node.c
@@ -33,11 +33,7 @@ typedef struct mime_node_context {
     GMimeMessage *mime_message;
 
     /* Context provided by the caller. */
-#ifdef GMIME_ATLEAST_26
-    GMimeCryptoContext *cryptoctx;
-#else
-    GMimeCipherContext *cryptoctx;
-#endif
+    notmuch_crypto_context_t *cryptoctx;
     notmuch_bool_t decrypt;
 } mime_node_context_t;
 
@@ -61,12 +57,7 @@ _mime_node_context_free (mime_node_context_t *res)
 
 notmuch_status_t
 mime_node_open (const void *ctx, notmuch_message_t *message,
-#ifdef GMIME_ATLEAST_26
-               GMimeCryptoContext *cryptoctx,
-#else
-               GMimeCipherContext *cryptoctx,
-#endif
-               notmuch_bool_t decrypt, mime_node_t **root_out)
+               notmuch_crypto_t *crypto, mime_node_t **root_out)
 {
     const char *filename = notmuch_message_get_filename (message);
     mime_node_context_t *mctx;
@@ -97,14 +88,29 @@ mime_node_open (const void *ctx, notmuch_message_t *message,
     }
 
     mctx->stream = g_mime_stream_file_new (mctx->file);
+    if (!mctx->stream) {
+       fprintf (stderr, "Out of memory.\n");
+       status = NOTMUCH_STATUS_OUT_OF_MEMORY;
+       goto DONE;
+    }
     g_mime_stream_file_set_owner (GMIME_STREAM_FILE (mctx->stream), FALSE);
 
     mctx->parser = g_mime_parser_new_with_stream (mctx->stream);
+    if (!mctx->parser) {
+       fprintf (stderr, "Out of memory.\n");
+       status = NOTMUCH_STATUS_OUT_OF_MEMORY;
+       goto DONE;
+    }
 
     mctx->mime_message = g_mime_parser_construct_message (mctx->parser);
+    if (!mctx->mime_message) {
+       fprintf (stderr, "Failed to parse %s\n", filename);
+       status = NOTMUCH_STATUS_FILE_ERROR;
+       goto DONE;
+    }
 
-    mctx->cryptoctx = cryptoctx;
-    mctx->decrypt = decrypt;
+    mctx->cryptoctx = crypto->gpgctx;
+    mctx->decrypt = crypto->decrypt;
 
     /* Create the root node */
     root->part = GMIME_OBJECT (mctx->mime_message);
@@ -112,6 +118,11 @@ mime_node_open (const void *ctx, notmuch_message_t *message,
     root->nchildren = 1;
     root->ctx = mctx;
 
+    root->parent = NULL;
+    root->part_num = 0;
+    root->next_child = 0;
+    root->next_part_num = 1;
+
     *root_out = root;
     return NOTMUCH_STATUS_SUCCESS;
 
@@ -137,7 +148,7 @@ _signature_validity_free (GMimeSignatureValidity **proxy)
 #endif
 
 static mime_node_t *
-_mime_node_create (const mime_node_t *parent, GMimeObject *part)
+_mime_node_create (mime_node_t *parent, GMimeObject *part)
 {
     mime_node_t *node = talloc_zero (parent, mime_node_t);
     GError *err = NULL;
@@ -150,6 +161,9 @@ _mime_node_create (const mime_node_t *parent, GMimeObject *part)
        talloc_free (node);
        return NULL;
     }
+    node->parent = parent;
+    node->part_num = node->next_part_num = -1;
+    node->next_child = 0;
 
     /* Deal with the different types of parts */
     if (GMIME_IS_PART (part)) {
@@ -267,9 +281,10 @@ _mime_node_create (const mime_node_t *parent, GMimeObject *part)
 }
 
 mime_node_t *
-mime_node_child (const mime_node_t *parent, int child)
+mime_node_child (mime_node_t *parent, int child)
 {
     GMimeObject *sub;
+    mime_node_t *node;
 
     if (!parent || child < 0 || child >= parent->nchildren)
        return NULL;
@@ -287,7 +302,30 @@ mime_node_child (const mime_node_t *parent, int child)
        INTERNAL_ERROR ("Unexpected GMimeObject type: %s",
                        g_type_name (G_OBJECT_TYPE (parent->part)));
     }
-    return _mime_node_create (parent, sub);
+    node = _mime_node_create (parent, sub);
+
+    if (child == parent->next_child && parent->next_part_num != -1) {
+       /* We're traversing in depth-first order.  Record the child's
+        * depth-first numbering. */
+       node->part_num = parent->next_part_num;
+       node->next_part_num = node->part_num + 1;
+
+       /* Prepare the parent for its next depth-first child. */
+       parent->next_child++;
+       parent->next_part_num = -1;
+
+       if (node->nchildren == 0) {
+           /* We've reached a leaf, so find the parent that has more
+            * children and set it up to number its next child. */
+           mime_node_t *iter = node->parent;
+           while (iter && iter->next_child == iter->nchildren)
+               iter = iter->parent;
+           if (iter)
+               iter->next_part_num = node->part_num + 1;
+       }
+    }
+
+    return node;
 }
 
 static mime_node_t *