diff --git a/tests/run-threaded.c b/tests/run-threaded.c
index 93d15883..02524b22 100644
--- a/tests/run-threaded.c
+++ b/tests/run-threaded.c
@@ -1,679 +1,680 @@
 /* run-threaded.c  - Helper to put GPGME under multithread load.
  * Copyright (C) 2018 by Bundesamt für Sicherheit in der Informationstechnik
  *               Software engineering by Intevation GmbH
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <https://gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 /* The idea of this test is not to be run as unit test but as part
  * of development to find threading issues and resource leaks. */
 
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
 
 #include <gpgme.h>
 #include <gpg-error.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 
 #include <unistd.h>
 
 #define PGM "run-threaded"
 
 #include "run-support.h"
 
 static volatile int stop;
 static volatile int thread_cnt;
 static volatile int running_threads;
 static int verbose;
 static int data_type;
 static int mem_only;
 
 #ifdef HAVE_W32_SYSTEM
 # include <windows.h>
 # define THREAD_RET DWORD CALLBACK
 
 static void
 create_thread (THREAD_RET (*func) (void *), void *arg)
 {
   running_threads++;
   if (CloseHandle (CreateThread (NULL, 0, func, arg, 0, NULL)))
     {
       fprintf (stderr, "Failed to create thread!\n");
       exit (1);
     }
 }
 
 #else
 # include <pthread.h>
 # define THREAD_RET void *
 
 static void
 create_thread (THREAD_RET (func) (void *), void *arg)
 {
   pthread_t handle;
   running_threads++;
   if (pthread_create (&handle, NULL, func, arg))
     {
       fprintf (stderr, "Failed to create thread!\n");
       exit (1);
     }
 }
 #endif
 
 #include <gpg-error.h>
 
 GPGRT_LOCK_DEFINE (out_lock);
 
 #define out(format, ...) \
   { \
     gpgrt_lock_lock (&out_lock); \
     printf (format "\n", ##__VA_ARGS__); \
     gpgrt_lock_unlock (&out_lock); \
   }
 
 #define errpoint \
 { \
   out ("Error on %i", __LINE__); \
   exit (1); \
 }
 
 #define log(format, ...) \
 if (verbose) \
   { \
     gpgrt_lock_lock (&out_lock); \
     printf (format "\n", ##__VA_ARGS__); \
     gpgrt_lock_unlock (&out_lock); \
   }
 
 /* Lazy mans signal */
 GPGRT_LOCK_DEFINE (threads_lock);
 
 void del_thread (void)
 {
   if (--running_threads == 0)
     {
       gpgrt_lock_unlock (&threads_lock);
     }
 }
 
 static int
 show_usage (int ex)
 {
   fputs ("usage: " PGM " [options] [messages]\n\n"
          "Options:\n"
          "  --verbose     run in verbose mode\n"
          "  --no-list     do not do keylistings\n"
          "  --data-type   mem function to use one of:\n"
          "                    1: fstream\n"
          "                    2: posix fd\n"
          "                    3: memory\n"
          "                    4: gpgrt_stream\n"
          "                    default: random\n"
 /*         "  --mem-cache   read data only once and then work on memory\n"
            "                exlusive with data-type option\n" */
          "  --threads N   use 4+N threads (4 are used for keylisting"
 " default 1)\n"
          "  --repeat  N   do N repeats on the messages (default 1)\n\n"
          "Note: The test does keylistings of both S/MIME and OpenPGP\n"
          "      in the background while running operations on the\n"
          "      messages, depending on their type.\n"
          "      (Currently decrypt / verify).\n\n"
          "      Without messages only keylistings will be done.\n"
          , stderr);
   exit (ex);
 }
 
 
 struct msg_list_s
 {
   const char *file_name;
   struct msg_list_s *next;
 };
 typedef struct msg_list_s *msg_list_t;
 
 struct data_s
 {
   int fd;
   FILE *file;
   gpgrt_stream_t stream;
   unsigned char *mem;
   gpgme_data_t dh;
 };
 typedef struct data_s *data_t;
 
 struct keylist_args_s
 {
   gpgme_protocol_t proto;
   int secret;
 };
 typedef struct keylist_args_s *keylist_args_t;
 
 static volatile int keylists;
 
 static THREAD_RET
 do_keylist (void *keylist_args)
 {
   gpgme_error_t err;
   gpgme_ctx_t ctx;
   gpgme_key_t key;
 
   keylist_args_t args = (keylist_args_t) keylist_args;
 
   log ("Keylist %i, Protocol: %s, Secret %i",
        keylists++,
        args->proto == GPGME_PROTOCOL_CMS ? "CMS" : "OpenPGP",
        args->secret);
 
   err = gpgme_new (&ctx);
   fail_if_err (err);
 
   err = gpgme_set_protocol (ctx, args->proto);
   fail_if_err (err);
 
   err = gpgme_op_keylist_start (ctx, NULL, args->secret);
   fail_if_err (err);
 
   while (!(err = gpgme_op_keylist_next (ctx, &key)))
     {
       gpgme_key_unref (key);
     }
 
   if (gpgme_err_code (err) != GPG_ERR_EOF)
     {
       fail_if_err (err);
     }
 
   gpgme_release (ctx);
 
   if (!stop)
     {
       create_thread (do_keylist, keylist_args);
     }
   del_thread ();
   return 0;
 }
 
 
 static unsigned char *
 get_file (const char *fname, size_t *r_size)
 {
   gpg_error_t err;
   gpgrt_stream_t fp;
   struct stat st;
   unsigned char *buf;
   size_t buflen;
 
   fp = gpgrt_fopen (fname, "r");
   if (!fp)
     {
       err = gpg_error_from_syserror ();
       fprintf (stderr, "Error: can't open '%s': %s\n", fname,
                gpg_strerror (err));
       return NULL;
     }
 
   if (fstat (gpgrt_fileno(fp), &st))
     {
       err = gpg_error_from_syserror ();
       fprintf (stderr, "Error: can't stat '%s': %s\n", fname,
                gpg_strerror (err));
       gpgrt_fclose (fp);
       return NULL;
     }
 
   buflen = st.st_size;
   buf = malloc (buflen+1);
   if (!buf)
     {
       fprintf (stderr, "Error: no mem\n");
       gpgrt_fclose (fp);
       return NULL;
     }
 
   if (gpgrt_fread (buf, buflen, 1, fp) != 1)
     {
       err = gpg_error_from_syserror ();
       fprintf (stderr, "error reading '%s': %s\n", fname,
                gpg_strerror (err));
       gpgrt_fclose (fp);
       free (buf);
       return NULL;
     }
   buf[buflen] = 0;
   gpgrt_fclose (fp);
 
   if (r_size)
     {
       *r_size = buflen;
     }
 
   return buf;
 }
 
 /** Lets use random data. This should also introduce a bit
     of randomness into the system by changing the runtimes
     of various data functions. Esp. Mem against the file ops. */
 data_t
 random_data_new (const char *fname)
 {
   data_t ret = calloc (1, sizeof (struct data_s));
   int data_rand;
   if (data_type)
     {
       data_rand = data_type;
     }
   else
     {
       data_rand = rand () % 3;
     }
 
   if (data_rand == 0) /* stream */
     {
       FILE *f_stream = fopen (fname, "rb");
       if (!f_stream)
         {
           errpoint;
         }
       fail_if_err (gpgme_data_new_from_stream (&(ret->dh), f_stream));
       ret->file = f_stream;
       return ret;
     }
   if (data_rand == 1) /* fd */
     {
       int fd = open (fname, O_RDONLY);
       gpgme_data_t dh;
       if (fd == -1)
         {
           errpoint;
         }
       fail_if_err (gpgme_data_new_from_fd (&dh, fd));
       ret->fd = fd;
       ret->dh = dh;
       return ret;
     }
   if (data_rand == 2) /* mem */
     {
       unsigned char *mem;
       size_t size;
 
       mem = get_file (fname, &size);
       if (!mem)
         {
           errpoint;
         }
       fail_if_err (gpgme_data_new_from_mem (&(ret->dh),
                                             (const char *)mem,
                                             size, 0));
       ret->mem = mem;
       return ret;
     }
   if (data_rand == 3) /* estream */
     {
       gpgrt_stream_t stream = gpgrt_fopen (fname, "rb");
 
       if (!stream)
         {
           errpoint;
         }
 
       fail_if_err (gpgme_data_new_from_estream (&(ret->dh), stream));
       ret->stream = stream;
       return ret;
     }
   /* notreached */
   return ret;
 }
 
 void
 random_data_close (data_t data)
 {
   if (data->dh)
     {
       gpgme_data_release (data->dh);
     }
   if (data->fd)
     {
       close (data->fd);
     }
   else if (data->file)
     {
       fclose (data->file);
     }
   else if (data->stream)
     {
       gpgrt_fclose (data->stream);
     }
   else if (data->mem)
     {
       free (data->mem);
     }
   free (data);
 }
 
 void
 verify (const char *fname, gpgme_protocol_t proto)
 {
   gpgme_ctx_t ctx;
   gpgme_error_t err;
   gpgme_data_t out;
   char *msg;
   size_t msg_len;
   data_t data = random_data_new (fname);
 
   log ("Starting verify on: %s with protocol %s", fname,
        proto == GPGME_PROTOCOL_CMS ? "CMS" : "OpenPGP");
 
   gpgme_data_new (&out);
 
   err = gpgme_new (&ctx);
   fail_if_err (err);
 
   err = gpgme_set_protocol (ctx, proto);
   fail_if_err (err);
 
   err = gpgme_op_verify (ctx, data->dh, NULL, out);
   out ("Data: %p, %i %p %p %p", data->dh,
        data->fd, data->file, data->stream,
        data->mem);
   fail_if_err (err);
 
   msg = gpgme_data_release_and_get_mem (out, &msg_len);
 
   if (msg_len)
     {
       log ("Verify result \n'%.*s'", (int)msg_len, msg);
     }
 
   gpgme_release (ctx);
 
   random_data_close (data);
+  free (msg);
 }
 
 
 /* We randomize data access to put in a bit additional
    entropy in this test and also to check if maybe
    some data functions might not be properly thread
    safe. */
 void
 decrypt (const char *fname, gpgme_protocol_t proto)
 {
   gpgme_ctx_t ctx;
   gpgme_error_t err;
   gpgme_data_t out;
   char *msg;
   size_t msg_len;
   data_t data = random_data_new (fname);
 
   log ("Starting decrypt on: %s", fname);
 
   gpgme_data_new (&out);
 
   err = gpgme_new (&ctx);
   fail_if_err (err);
 
   err = gpgme_set_protocol (ctx, proto);
   fail_if_err (err);
 
   err = gpgme_op_decrypt (ctx, data->dh, out);
   fail_if_err (err);
 
   gpgme_release (ctx);
 
   msg = gpgme_data_release_and_get_mem (out, &msg_len);
 
   if (msg_len)
     {
       log ("Decrypt result \n'%.*s'", (int)msg_len, msg);
     }
 
   random_data_close (data);
 }
 
 
 static THREAD_RET
 do_data_op (void *file_name)
 {
   gpgme_data_t data;
   const char *fname = (const char *) file_name;
   FILE *f = fopen (fname, "rb");
   gpgme_data_type_t type;
 
   if (!f)
     {
       fprintf (stderr, "Failed to open '%s'\n", fname);
       exit (1);
     }
 
   fail_if_err (gpgme_data_new_from_stream (&data, f));
 
   type = gpgme_data_identify (data, 0);
   gpgme_data_release (data);
   fclose (f);
 
   switch (type)
     {
       case GPGME_DATA_TYPE_INVALID:
       case GPGME_DATA_TYPE_UNKNOWN:
         {
           fprintf (stderr, "Failed to identify '%s'", fname);
           exit(1);
         }
       case GPGME_DATA_TYPE_PGP_SIGNED:
         {
           verify (fname, GPGME_PROTOCOL_OpenPGP);
           break;
         }
       case GPGME_DATA_TYPE_CMS_SIGNED:
         {
           verify (fname, GPGME_PROTOCOL_CMS);
           break;
         }
       case GPGME_DATA_TYPE_PGP_ENCRYPTED:
         {
           decrypt (fname, GPGME_PROTOCOL_OpenPGP);
           break;
         }
       case GPGME_DATA_TYPE_CMS_ENCRYPTED:
         {
           decrypt (fname, GPGME_PROTOCOL_CMS);
           break;
         }
       default:
         {
           fprintf (stderr, "Unhandled data type 0x%x for '%s'", type, fname);
           exit(1);
         }
     }
 
   del_thread ();
   return 0;
 }
 
 
 void
 start_keylistings (void)
 {
   static struct keylist_args_s args[4];
 
   args[0].proto = GPGME_PROTOCOL_OpenPGP;
   args[0].secret = 0;
 
   args[1].proto = GPGME_PROTOCOL_OpenPGP;
   args[1].secret = 1;
 
   args[2].proto = GPGME_PROTOCOL_CMS;
   args[2].secret = 0;
 
   args[3].proto = GPGME_PROTOCOL_CMS;
   args[3].secret = 1;
 
   for (int i = 0; i < 4; i++)
     {
       thread_cnt--;
       create_thread (do_keylist, &args[i]);
     }
 }
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   int repeats = 1;
   int threads = 0;
   int no_list = 0;
   msg_list_t msgs = NULL;
   msg_list_t msg_it = NULL;
   stop = 0;
 
   srand (1 /* Somewhat deterministic results */);
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--help"))
         {
           show_usage (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--no-list"))
         {
           no_list = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--mem-only"))
         {
           if (data_type)
             {
               show_usage (1);
             }
           mem_only = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--threads"))
         {
           argc--; argv++;
           if (!argc)
             {
               show_usage (1);
             }
           threads = atoi (*argv);
           if (!threads)
             {
               show_usage (1);
             }
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--data-type"))
         {
           argc--; argv++;
           if (!argc || mem_only)
             {
               show_usage (1);
             }
           data_type = atoi (*argv);
           if (data_type > 4)
             {
               show_usage (1);
             }
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--repeat"))
         {
           argc--; argv++;
           if (!argc)
             {
               show_usage (1);
             }
           repeats = atoi (*argv);
           if (!repeats)
             {
               show_usage (1);
             }
           argc--; argv++;
         }
     }
 
   init_gpgme_basic ();
 
   if (threads < argc)
     {
       /* Make sure we run once on each arg */
       threads += argc;
     }
   while (argc)
     {
       if (!msgs)
         {
           msgs = calloc (1, sizeof *msgs);
           msg_it = msgs;
         }
       else
         {
           msg_it->next = calloc (1, sizeof *msgs);
           msg_it = msg_it->next;
         }
       msg_it->file_name = *argv;
       argc--; argv++;
     }
 
   gpgrt_lock_lock (&threads_lock);
   do
     {
       stop = 0;
       thread_cnt = threads + 4;
       out ("Repeats left: %i", repeats);
 
       if (!no_list)
         {
           start_keylistings ();
         }
       else
         {
           thread_cnt -= 4;
         }
 
       while (thread_cnt)
         {
           log ("Thread %i", thread_cnt);
           for (msg_it = msgs; msg_it && thread_cnt; msg_it = msg_it->next)
             {
               thread_cnt--;
               create_thread (do_data_op, (void *)msg_it->file_name);
             }
         }
 
       stop = 1;
       gpgrt_lock_lock (&threads_lock);
     }
   while (--repeats != 0);
 
   return 0;
 }