LCOV - code coverage report
Current view: top level - tests/gpg - t-eventloop.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 79 81 97.5 %
Date: 2016-09-12 13:07:23 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /* t-eventloop.c - Regression test.
       2             :    Copyright (C) 2000 Werner Koch (dd9jn)
       3             :    Copyright (C) 2001, 2002, 2003, 2004 g10 Code GmbH
       4             : 
       5             :    This file is part of GPGME.
       6             :  
       7             :    GPGME is free software; you can redistribute it and/or modify it
       8             :    under the terms of the GNU Lesser General Public License as
       9             :    published by the Free Software Foundation; either version 2.1 of
      10             :    the License, or (at your option) any later version.
      11             :    
      12             :    GPGME is distributed in the hope that it will be useful, but
      13             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :    Lesser General Public License for more details.
      16             :    
      17             :    You should have received a copy of the GNU Lesser General Public
      18             :    License along with this program; if not, write to the Free Software
      19             :    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
      20             :    02111-1307, USA.  */
      21             : 
      22             : /* We need to include config.h so that we know whether we are building
      23             :    with large file system (LFS) support. */
      24             : #ifdef HAVE_CONFIG_H
      25             : #include <config.h>
      26             : #endif
      27             : 
      28             : #include <stdio.h>
      29             : #include <stdlib.h>
      30             : #include <string.h>
      31             : #include <assert.h>
      32             : #include <errno.h>
      33             : #include <sys/types.h>
      34             : #include <sys/select.h>
      35             : 
      36             : #include <gpgme.h>
      37             : 
      38             : #include "t-support.h"
      39             : 
      40             : 
      41             : /* Stripped down version of gpgme/wait.c.  */
      42             : 
      43             : struct op_result
      44             : {
      45             :   int done;
      46             :   gpgme_error_t err;
      47             : };
      48             : 
      49             : struct op_result op_result;
      50             : 
      51             : struct one_fd
      52             : {
      53             :   int fd;
      54             :   int dir;
      55             :   gpgme_io_cb_t fnc;
      56             :   void *fnc_data;
      57             : };
      58             : 
      59             : #define FDLIST_MAX 32
      60             : struct one_fd fdlist[FDLIST_MAX];
      61             : 
      62             : gpgme_error_t
      63           3 : add_io_cb (void *data, int fd, int dir, gpgme_io_cb_t fnc, void *fnc_data,
      64             :            void **r_tag)
      65             : {
      66           3 :   struct one_fd *fds = data;
      67             :   int i;
      68             : 
      69           6 :   for (i = 0; i < FDLIST_MAX; i++)
      70             :     {
      71           6 :       if (fds[i].fd == -1)
      72             :         {
      73           3 :           fds[i].fd = fd;
      74           3 :           fds[i].dir = dir;
      75           3 :           fds[i].fnc = fnc;
      76           3 :           fds[i].fnc_data = fnc_data;
      77           3 :           break;
      78             :         }
      79             :     }
      80           3 :   if (i == FDLIST_MAX)
      81           0 :     return gpgme_err_make (GPG_ERR_SOURCE_USER_1, GPG_ERR_GENERAL);
      82           3 :   *r_tag = &fds[i];
      83           3 :   return 0;
      84             : }
      85             : 
      86             : void
      87           3 : remove_io_cb (void *tag)
      88             : {
      89           3 :   struct one_fd *fd = tag;
      90             : 
      91           3 :   fd->fd = -1;
      92           3 : }
      93             : 
      94             : void
      95           2 : io_event (void *data, gpgme_event_io_t type, void *type_data)
      96             : {
      97           2 :   struct op_result *result = data;
      98             : 
      99           2 :   if (type == GPGME_EVENT_DONE)
     100             :     {
     101           1 :       result->done = 1;
     102           1 :       result->err = * (gpgme_error_t *) type_data;
     103             :     }
     104           2 : }
     105             : 
     106             : 
     107             : int
     108          10 : do_select (void)
     109             : {
     110             :   fd_set rfds;
     111             :   fd_set wfds;
     112             :   int i, n;
     113          10 :   int any = 0;
     114             : 
     115          10 :   FD_ZERO (&rfds);
     116          10 :   FD_ZERO (&wfds);
     117         330 :   for (i = 0; i < FDLIST_MAX; i++)
     118         320 :     if (fdlist[i].fd != -1)
     119          22 :       FD_SET (fdlist[i].fd, fdlist[i].dir ? &rfds : &wfds);
     120             : 
     121             :   do
     122             :     {
     123          10 :       n = select (FD_SETSIZE, &rfds, &wfds, NULL, 0);
     124             :     }
     125          10 :   while (n < 0 && errno == EINTR);
     126             : 
     127          10 :   if (n < 0)
     128           0 :     return n;   /* Error or timeout.  */
     129             : 
     130          26 :   for (i = 0; i < FDLIST_MAX && n; i++)
     131             :     {
     132          16 :       if (fdlist[i].fd != -1)
     133             :         {
     134          16 :           if (FD_ISSET (fdlist[i].fd, fdlist[i].dir ? &rfds : &wfds))
     135             :             {
     136          12 :               assert (n);
     137          12 :               n--;
     138          12 :               any = 1;
     139          12 :               (*fdlist[i].fnc) (fdlist[i].fnc_data, fdlist[i].fd);
     140             :             }
     141             :         }
     142             :     }
     143          10 :   return any;
     144             : }
     145             : 
     146             : int
     147          10 : my_wait (void)
     148             : {
     149             :   int n;
     150             : 
     151             :   do
     152             :     {
     153          10 :       n = do_select ();
     154             :     }
     155          10 :   while (n >= 0 && !op_result.done);
     156           1 :   return 0;
     157             : }
     158             : 
     159             : 
     160             : struct gpgme_io_cbs io_cbs =
     161             :   {
     162             :     add_io_cb,
     163             :     fdlist,
     164             :     remove_io_cb,
     165             :     io_event,
     166             :     &op_result
     167             :   };
     168             : 
     169             : 
     170             : int 
     171           1 : main (int argc, char *argv[])
     172             : {
     173             :   gpgme_ctx_t ctx;
     174             :   gpgme_error_t err;
     175             :   gpgme_data_t in, out;
     176           1 :   gpgme_key_t key[3] = { NULL, NULL, NULL };
     177             :   int i;
     178             : 
     179           1 :   init_gpgme (GPGME_PROTOCOL_OpenPGP);
     180             : 
     181          33 :   for (i = 0; i < FDLIST_MAX; i++)
     182          32 :     fdlist[i].fd = -1;
     183             : 
     184           1 :   err = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
     185           1 :   fail_if_err (err);
     186             : 
     187           1 :   err = gpgme_new (&ctx);
     188           1 :   fail_if_err (err);
     189           1 :   gpgme_set_armor (ctx, 1);
     190           1 :   gpgme_set_io_cbs (ctx, &io_cbs);
     191           1 :   op_result.done = 0;
     192             : 
     193           1 :   err = gpgme_data_new_from_mem (&in, "Hallo Leute\n", 12, 0);
     194           1 :   fail_if_err (err);
     195             : 
     196           1 :   err = gpgme_data_new (&out);
     197           1 :   fail_if_err (err);
     198             : 
     199           1 :   err = gpgme_get_key (ctx, "A0FF4590BB6122EDEF6E3C542D727CC768697734",
     200             :                        &key[0], 0);
     201           1 :   fail_if_err (err);
     202           1 :   err = gpgme_get_key (ctx, "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2",
     203             :                        &key[1], 0);
     204           1 :   fail_if_err (err);
     205             : 
     206           1 :   err = gpgme_op_encrypt_start (ctx, key, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);
     207           1 :   fail_if_err (err);
     208             : 
     209           1 :   my_wait ();
     210           1 :   fail_if_err (op_result.err);
     211           1 :   fail_if_err (err);
     212             : 
     213           1 :   fflush (NULL);
     214           1 :   fputs ("Begin Result:\n", stdout);
     215           1 :   print_data (out);
     216           1 :   fputs ("End Result.\n", stdout);
     217             :    
     218           1 :   gpgme_key_unref (key[0]);
     219           1 :   gpgme_key_unref (key[1]);
     220           1 :   gpgme_data_release (in);
     221           1 :   gpgme_data_release (out);
     222           1 :   gpgme_release (ctx);
     223             : 
     224           1 :   return 0;
     225             : }

Generated by: LCOV version 1.11