diff --git a/src/lib/rnp.cpp b/src/lib/rnp.cpp
index 51945bb10e..4207830d71 100644
--- a/src/lib/rnp.cpp
+++ b/src/lib/rnp.cpp
@@ -3132,14 +3132,17 @@ rnp_verify_dest_provider(pgp_parse_handler_t *handler,
                          const char *         filename,
                          uint32_t             mtime)
 {
+    RNP_LOG("here");
     rnp_op_verify_t op = (rnp_op_verify_t) handler->param;
     if (!op->output) {
+        RNP_LOG("here");
         return false;
     }
     *dst = &(op->output->dst);
     *closedst = false;
     op->filename = filename ? std::string(filename) : "";
     op->file_mtime = mtime;
+    RNP_LOG("here");
     return true;
 }
 
diff --git a/src/librepgp/stream-common.cpp b/src/librepgp/stream-common.cpp
index f1f2270a45..69c44a12b0 100644
--- a/src/librepgp/stream-common.cpp
+++ b/src/librepgp/stream-common.cpp
@@ -60,11 +60,13 @@ src_read(pgp_source_t *src, void *buf, size_t len, size_t *readres)
     bool                readahead = cache ? cache->readahead : false;
 
     if (src->error) {
+        RNP_LOG("here");
         return false;
     }
 
     if (src->eof || (len == 0)) {
         *readres = 0;
+        RNP_LOG("here");
         return true;
     }
 
@@ -96,8 +98,10 @@ src_read(pgp_source_t *src, void *buf, size_t len, size_t *readres)
             // If there is no cache or chunk is larger then read directly
             if (!src->read(src, buf, left, &read)) {
                 src->error = 1;
+                RNP_LOG("here");
                 return false;
             }
+            RNP_LOG("here: %p %zu", src->read, read);
             if (!read) {
                 src->eof = 1;
                 len = len - left;
@@ -109,8 +113,10 @@ src_read(pgp_source_t *src, void *buf, size_t len, size_t *readres)
             // Try to fill the cache to avoid small reads
             if (!src->read(src, &cache->buf[0], sizeof(cache->buf), &read)) {
                 src->error = 1;
+                RNP_LOG("here");
                 return false;
             }
+            RNP_LOG("here: %p %zu", src->read, read);
             if (!read) {
                 src->eof = 1;
                 len = len - left;
@@ -129,6 +135,7 @@ src_read(pgp_source_t *src, void *buf, size_t len, size_t *readres)
     }
 
 finish:
+    RNP_LOG("here: %p", src->read);
     src->readb += len;
     if (src->knownsize && (src->readb == src->size)) {
         src->eof = 1;
diff --git a/src/librepgp/stream-parse.cpp b/src/librepgp/stream-parse.cpp
index f80fe5d16d..b59ff96984 100644
--- a/src/librepgp/stream-parse.cpp
+++ b/src/librepgp/stream-parse.cpp
@@ -323,10 +323,13 @@ init_partial_pkt_src(pgp_source_t *src, pgp_source_t *readsrc, pgp_packet_hdr_t
 static bool
 literal_src_read(pgp_source_t *src, void *buf, size_t len, size_t *read)
 {
+    RNP_LOG("here");
     pgp_source_literal_param_t *param = (pgp_source_literal_param_t *) src->param;
     if (!param) {
+        RNP_LOG("here");
         return false;
     }
+    RNP_LOG("here: %d", (int) param->pkt.readsrc->type);
     return src_read(param->pkt.readsrc, buf, len, read);
 }
 
@@ -704,28 +707,35 @@ encrypted_src_read_aead(pgp_source_t *src, void *buf, size_t len, size_t *read)
 static bool
 encrypted_src_read_cfb(pgp_source_t *src, void *buf, size_t len, size_t *readres)
 {
+    RNP_LOG("here");
     pgp_source_encrypted_param_t *param = (pgp_source_encrypted_param_t *) src->param;
     if (param == NULL) {
+        RNP_LOG("here");
         return false;
     }
 
     if (src->eof) {
         *readres = 0;
+        RNP_LOG("here");
         return true;
     }
 
+    RNP_LOG("here");
     size_t read;
     if (!src_read(param->pkt.readsrc, buf, len, &read)) {
+        RNP_LOG("here");
         return false;
     }
     if (!read) {
         *readres = 0;
+        RNP_LOG("here");
         return true;
     }
 
     bool    parsemdc = false;
     uint8_t mdcbuf[MDC_V1_SIZE];
     if (param->auth_type == rnp::AuthType::MDC) {
+        RNP_LOG("here");
         size_t mdcread = 0;
         /* make sure there are always 22 bytes left on input */
         if (!src_peek(param->pkt.readsrc, mdcbuf, MDC_V1_SIZE, &mdcread) ||
@@ -743,10 +753,13 @@ encrypted_src_read_cfb(pgp_source_t *src, void *buf, size_t len, size_t *readres
         }
     }
 
+    RNP_LOG("here");
     pgp_cipher_cfb_decrypt(&param->decrypt, (uint8_t *) buf, (uint8_t *) buf, read);
+    RNP_LOG("here");
 
     if (param->auth_type == rnp::AuthType::MDC) {
         try {
+            RNP_LOG("here");
             param->mdc->add(buf, read);
 
             if (parsemdc) {
@@ -774,6 +787,7 @@ encrypted_src_read_cfb(pgp_source_t *src, void *buf, size_t len, size_t *readres
         }
     }
     *readres = read;
+    RNP_LOG("here");
     return true;
 }
 
@@ -2338,6 +2352,7 @@ encrypted_read_packet_data(pgp_source_encrypted_param_t *param)
 static rnp_result_t
 init_encrypted_src(pgp_parse_handler_t *handler, pgp_source_t *src, pgp_source_t *readsrc)
 {
+    RNP_LOG("here");
     if (!init_src_common(src, 0)) {
         return RNP_ERROR_OUT_OF_MEMORY;
     }
@@ -2354,11 +2369,13 @@ init_encrypted_src(pgp_parse_handler_t *handler, pgp_source_t *src, pgp_source_t
     src->type = PGP_STREAM_ENCRYPTED;
 
     /* Read the packet-related information */
+    RNP_LOG("here");
     rnp_result_t errcode = encrypted_read_packet_data(param);
     if (errcode) {
         goto finish;
     }
 
+    RNP_LOG("here");
     src->read = (!param->use_cfb()
 #ifdef ENABLE_CRYPTO_REFRESH
                  || param->is_v2_seipd()
@@ -2374,11 +2391,13 @@ init_encrypted_src(pgp_parse_handler_t *handler, pgp_source_t *src, pgp_source_t
         goto finish;
     }
 
+    RNP_LOG("here");
     /* informing handler about the available pubencs/symencs */
     if (handler->on_recipients) {
         handler->on_recipients(param->pubencs, param->symencs, handler->param);
     }
 
+    RNP_LOG("here");
     bool have_key;
     have_key = false;
     /* Trying public-key decryption */
@@ -2456,15 +2475,19 @@ init_encrypted_src(pgp_parse_handler_t *handler, pgp_source_t *src, pgp_source_t
 
     /* Trying password-based decryption */
     if (!have_key && !param->symencs.empty()) {
+        RNP_LOG("here");
         rnp::secure_array<char, MAX_PASSWORD_LENGTH> password;
         pgp_password_ctx_t                           pass_ctx(PGP_OP_DECRYPT_SYM);
         if (!pgp_request_password(
               handler->password_provider, &pass_ctx, password.data(), password.size())) {
             errcode = RNP_ERROR_BAD_PASSWORD;
+            RNP_LOG("here");
             goto finish;
         }
 
+        RNP_LOG("here");
         int intres = encrypted_try_password(param, password.data());
+        RNP_LOG("here: %d", intres);
         if (intres > 0) {
             have_key = true;
         } else if (intres < 0) {
@@ -2475,13 +2498,16 @@ init_encrypted_src(pgp_parse_handler_t *handler, pgp_source_t *src, pgp_source_t
     }
 
     /* report decryption start to the handler */
+    RNP_LOG("here");
     if (handler->on_decryption_info) {
+        RNP_LOG("here");
         handler->on_decryption_info(param->auth_type == rnp::AuthType::MDC,
                                     param->aead_hdr.aalg,
                                     param->salg,
                                     handler->param);
     }
 
+    RNP_LOG("here");
     if (!have_key) {
         RNP_LOG("failed to obtain decrypting key or password");
         if (!errcode) {
@@ -2712,6 +2738,7 @@ init_packet_sequence(pgp_processing_ctx_t &ctx, pgp_source_t &src)
     pgp_source_t *lsrc = &src;
     size_t        srcnum = ctx.sources.size();
 
+    RNP_LOG("here");
     while (1) {
         uint8_t ptag = 0;
         if (!src_peek_eq(lsrc, &ptag, 1)) {
@@ -2848,6 +2875,7 @@ process_pgp_source(pgp_parse_handler_t *handler, pgp_source_t &src)
     bool                 closeout = true;
     uint8_t *            readbuf = NULL;
 
+    RNP_LOG("here");
     ctx.handler = *handler;
     /* Building readers sequence. Checking whether it is binary data */
     if (is_pgp_source(src)) {
@@ -2902,6 +2930,7 @@ process_pgp_source(pgp_parse_handler_t *handler, pgp_source_t &src)
         }
         src_close(&datasrc);
     } else {
+        RNP_LOG("here");
         if (handler->ctx->detached) {
             RNP_LOG("Detached signature expected.");
             res = RNP_ERROR_BAD_STATE;
@@ -2912,25 +2941,34 @@ process_pgp_source(pgp_parse_handler_t *handler, pgp_source_t &src)
         char *   filename = NULL;
         uint32_t mtime = 0;
 
+        RNP_LOG("here");
         if (ctx.literal_src) {
             auto *param = static_cast<pgp_source_literal_param_t *>(ctx.literal_src->param);
             filename = param->hdr.fname;
             mtime = param->hdr.timestamp;
         }
 
+        RNP_LOG("here: %s", filename);
         if (!handler->dest_provider ||
             !handler->dest_provider(handler, &outdest, &closeout, filename, mtime)) {
             res = RNP_ERROR_WRITE;
+            RNP_LOG("here");
             goto finish;
         }
 
         /* reading the input */
+        RNP_LOG("here: %p", decsrc);
+        RNP_LOG("here: %d", decsrc->eof);
+        RNP_LOG("here: %d", (int) decsrc->type);
         while (!decsrc->eof) {
             size_t read = 0;
+            RNP_LOG("here");
             if (!src_read(decsrc, readbuf, PGP_INPUT_CACHE_SIZE, &read)) {
                 res = RNP_ERROR_GENERIC;
+                RNP_LOG("here");
                 break;
             }
+            RNP_LOG("here: %zu", read);
             if (!read) {
                 continue;
             }
@@ -2938,6 +2976,7 @@ process_pgp_source(pgp_parse_handler_t *handler, pgp_source_t &src)
                 signed_src_update(ctx.signed_src, readbuf, read);
             }
             dst_write(outdest, readbuf, read);
+            RNP_LOG("here");
             if (outdest->werr != RNP_SUCCESS) {
                 RNP_LOG("failed to output data");
                 res = RNP_ERROR_WRITE;
@@ -2961,6 +3000,7 @@ process_pgp_source(pgp_parse_handler_t *handler, pgp_source_t &src)
     }
 
 finish:
+    RNP_LOG("here: %x", (int) res);
     free(readbuf);
     return res;
 }