--- /dev/null
+2001-07-30 Werner Koch <wk@gnupg.org>
+
+ Encryption basically works.
+
+
+ Copyright 2001 g10 Code GmbH
+
+ This file is free software; as a special exception the author gives
+ unlimited permission to copy and/or distribute it, with or without
+ modifications, as long as this notice is preserved.
+
+ This file is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
\ No newline at end of file
## Process this file with automake to produce Makefile.in
-EXTRA_DIST = WINE-LICENSE WINE-AUTHORS
+# Because there is no free IDL compiler for OLE, we have to distribute
+# a binary typelibrary. To generate a new one, copy the idl file to a
+# system with an install MIDL and run the command
+# midl /nocpp gpgcom.idl
+# Sorry, there is no other way yet.
+EXTRA_DIST = gpgcom.idl gpgcom.tlb gpgcom.rc
-# No need to install this becuase we are cross-compiling anyway.
-noinst_PROGRAMS = gpgcom
+# No need to install this because we are cross-compiling anyway.
+noinst_PROGRAMS = gpgcom tgpgcom
INCLUDES = -I$(top_srcdir)/jnlib
-LDADD = -L ../jnlib -ljnlib
+LDADD = ../gpgme/libgpgme.la -L ../jnlib -ljnlib -lole32 -loleaut32
+gpgcom_LDADD = gpgcom_res.o $(LDADD)
-comheaders = obj_base.h basetsd.h guiddef.h wtypes.h
+gpgcom_SOURCES = gpgcom.c main.h \
+ debug.c utf8.c \
+ igpgme.h igpgme.c
-gpgcom_SOURCES = main.c main.h \
- $(comheaders) \
- ignupg.c ignupg.h
+tgpgcom_SOURCES = tgpgcom.c\
+ debug.c \
+ igpgme.h
+#regtlb_SOURCES = regtlb.c
+#guidgen_SOURCES = guidgen.c
+
+gpgcom_res.o: gpgcom.rc
+ mingw32 windres $< gpgcom_res.o
+++ /dev/null
-@c This file is processed by GNU's TeXinfo
-@c If you modify it or move it to another location, make sure that
-@c TeXinfo works (type `make' in directory documentation).
-
-@c This is a list of the Wine authors and copyright holders.
-
-Wine is available thanks to the work of:
-James Abbatiello,
-Michael Abd-El-Malek,
-Howard Abrams,
-Mark G. Adams,
-Bruno Afonso,
-Samir Al-Battran,
-Guy Albertelli,
-Gustavo Junior Alves,
-Bob Amstadt,
-Dag Asheim,
-Jim Aston,
-Martin Ayotte,
-Viktor Babrian,
-Karl Backström,
-Bradley Baetz,
-Peter Bajusz,
-Andre Malafaya Baptista,
-Aaron Barnes,
-Jean-Claude Batista,
-Marcel Baur,
-Francis Beaudet,
-Tom Bech,
-Matthew Becker,
-Georg Beyerle,
-Ross Biro,
-Dennis Björklund,
-Zygo Blaxell,
-Martin Boehme,
-Francois Boisvert,
-Pim Bollen,
-Uwe Bonnes,
-Peter Bortas,
-Noel Borthwick,
-Erik Bos,
-Fons Botman,
-Sylvain Bouchard,
-Frederic Boulanger,
-Justin Bradford,
-John Brezak,
-Andrew Bulhak,
-John Burton,
-Jonathan Buzzard,
-Jose Marcos López Caravaca,
-Eddie Carpenter,
-Niels de Carpentier,
-Mike Castle,
-Ron Cemer,
-Gordon Chaffee,
-Gael de Chalendar,
-Jimen Ching,
-Geoff Clare,
-Robert 'Admiral' Coeyman,
-Richard Cohen,
-Jean-Claude Cote,
-Stephen Crowley,
-Pascal Cuoq,
-David A. Cuthbert,
-Brian Joseph Czapiga,
-Ulrich Czekalla,
-Huw D. M. Davies,
-Moses DeJong,
-Petar Djukic,
-Roman Dolejsi,
-Frans van Dorsselaer,
-Rikhardur Egilsson,
-Morten Eriksen,
-Chris Faherty,
-Carsten Fallesen,
-Paul Falstad,
-David Faure,
-Wesley Filardo,
-Claus Fischer,
-Olaf Flebbe,
-Chad Fraleigh,
-Matthew Francis,
-Philippe Froidevaux,
-Peter Galbavy,
-Peter Ganten,
-Ramon Garcia,
-Jeff Garzik,
-Julio Cesar Gazquez,
-Klaas van Gend,
-Abey George,
-Brian Gerst,
-Matthew Ghio,
-Jody Goldberg,
-David Golding,
-François Gouget,
-Hans de Graaff,
-David Grant,
-Albert den Haan,
-Jess Haas,
-Robert W Hall,
-Noomen Hamza,
-Charles M. Hannum,
-Adrian Harvey,
-John Harvey,
-James Hatheway,
-Kalevi J Hautaniemi,
-Bill Hawes,
-Lars Heete,
-Cameron Heide,
-Bernd Herd,
-Theodore S. Hetke,
-Haithem Hmida,
-Jochen Hoenicke,
-Henning Hoffmann,
-Kevin Holbrook,
-Nick Holloway,
-Onno Hovers,
-Jeffrey Hsu,
-Peter Hunnisett,
-Miguel de Icaza,
-Jukka Iivonen,
-Kostya Ivanov,
-Serge Ivanov,
-Lee Jaekil,
-Gautam Jain,
-Niels Kristian Bech Jensen,
-Rajeev Jhangiani,
-Bill Jin,
-Jeff Johann,
-Alexandre Julliard,
-Bang Jun-Young,
-James Juran,
-Achim Kaiser,
-Alexander Kanavin,
-Jukka Kangas,
-Pavel Kankovsky,
-Michael Karcher,
-Niclas Karlsson,
-Jochen Karrer,
-Don Kelly,
-Andreas Kirschbaum,
-Rein Klazes,
-Albrecht Kleine,
-Dietmar Kling,
-Eric Kohl,
-Jon Konrath,
-Alex Korobka,
-Zoltan Kovacs,
-Greg Kreider,
-Anand Kumria,
-Ove Kåven,
-Scott A. Laird,
-David Lee Lambert,
-Stephen Langasek,
-Sean Langley,
-Dan Langlois,
-Alexander Larsson,
-David Lassonde,
-Stefan Leichter,
-Karl Lessard,
-Pascal Lessard,
-Andrew Lewycky,
-John Li,
-Weisheng Li,
-Xiang Li,
-Per Lindström,
-Brian Litzinger,
-Juergen Lock,
-Martin von Loewis,
-Michiel van Loon,
-Richard A Lough,
-Alexander V. Lukyanov,
-Jiuming Luo,
-Stephane Lussier,
-David Luyer,
-José Marcos López,
-Kenneth MacDonald,
-Peter MacDonald,
-Pierre Mageau,
-William Magro,
-Juergen Marquardt,
-Ricardo Massaro,
-Keith Matthews,
-Joerg Mayer,
-Michael McCormack,
-Jason McMullan,
-Caolan McNamara,
-Marcus Meissner,
-Graham Menhennitt,
-David Metcalfe,
-Toufic Milan,
-Paul Millar,
-Bruce Milner,
-Steffen Moeller,
-Andreas Mohr,
-Slava Monich,
-James Moody,
-Chris Morgan,
-Kai Morich,
-Richard Mortimer,
-Vasudev Mulchandani,
-Rick Mutzke,
-Philippe De Muyter,
-Itai Nahshon,
-Jonathan Naylor,
-Tim Newsome,
-Thuy Nguyen,
-Kristian Nielsen,
-Damien O'Neill,
-Henrik Olsen,
-Gerard Patel,
-Michael Patra,
-Murali Pattathe,
-Dimitrie O. Paun,
-Bernd Paysan,
-Brad Pepers,
-Jim Peterson,
-Gerald Pfeifer,
-Dave Pickles,
-Ian Pilcher,
-Brian Pirie,
-Michael Poole,
-Eric Pouech,
-Robert Pouliot,
-Vahid Pourlotfali,
-Chad Powell,
-Joseph Pranevich,
-Alex Priem,
-Paul Quinn,
-Pete Ratzlaff,
-Ron Record,
-Petter Reinholdtsen,
-Keith Reynolds,
-Slaven Rezic,
-John Richardson,
-Rick Richardson,
-Douglas Ridgway,
-Robert Riggs,
-Bernhard Rosenkraenzer,
-Matthew Robertson,
-Pavel Roskin,
-Herbert Rosmanith,
-Lilia Roumiantseva,
-Johannes Ruscheinski,
-Adam Sacarny,
-Ivan de Saedeleer,
-Thomas Sandford,
-Constantine Sapuntzakis,
-Pablo Saratxaga,
-Carl van Schaik,
-Daniel Schepler,
-Christian Schlaile,
-Peter Schlaile,
-Ulrich Schmid,
-Bernd Schmidt,
-Ian Schmidt,
-Juergen Schmied,
-Ingo Schneider,
-Victor Schneider,
-John Sheets,
-Yngvi Sigurjonsson,
-Stephen Simmons,
-Jesper Skov,
-Rick Sladkey,
-William Smith,
-Jaroslaw Piotr Sobieszek,
-Patrick Spinler,
-Sylvain St-Germain,
-Gavriel State,
-Sheri Steeves,
-Norman Stevens,
-Dominik Strasser,
-Patrik Stridvall,
-Vadim Strizhevsky,
-Bertho Stultiens,
-Abraham Sudhakar,
-Charles Suprin,
-James Sutherland,
-Erik Svendsen,
-Tristan Tarrant,
-Andrew Taylor,
-Joshua Thielen,
-Dirk Thierbach,
-Jean-Louis Thirot,
-Duncan C Thomson,
-Adrian Thurston,
-Goran Thyni,
-Steve Tibbett,
-Dmitry Timoshkov,
-Jimmy Tirtawangsa,
-Jon Tombs,
-Linus Torvalds,
-Luc Tourangeau,
-Jeff Tranter,
-Gregory Trubetskoy,
-Petri Tuomola,
-Sergey Turchanov,
-Lionel Ulmer,
-Moshe Vainer,
-Michael Veksler,
-Sven Verdoolaege,
-Todd Vierling,
-Erez Volk,
-Jerome Vouillon,
-Duc Vuong,
-Ronan Waide,
-Martin Walker,
-Owen Wang,
-Eric Warnke,
-Leigh Wedding,
-Randy Weems,
-Manfred Weichel,
-Ulrich Weigand,
-Morten Welinder,
-Jeremy White,
-Len White,
-Lawson Whitney,
-Jan Willamowius,
-Carl Williams,
-Eric Williams,
-Cliff Wright,
-Karl Guenter Wuensch,
-Eric Youngdale,
-James Youngman,
-Nikita V. Youshchenko,
-Mikolaj Zalewski,
-John Zero,
-Yuxi Zhang,
-Nathan Zorich,
-Luiz Otavio L. Zorzella,
-and Per Ångström.
+++ /dev/null
-This is the license file as it appeared in the CVS version of
-Wine at cvs@rhlx01.fht-esslingen.de:/home/wine as of 2000-12-04
-where only AUTHORS has been renamed to WINE-AUTHORS. It applies
-to the header files establishing the COM+ framework
-
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Copyright (c) 1993-2000 the Wine project authors (see the file WINE-AUTHORS
-for a complete list)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++ /dev/null
-/* basetsd.h - Compilers that uses ILP32, LP64 or P64 type models
- for both Win32 and Win64 are supported by this file.
-
- Copyright (c) 1993-2000 the Wine project authors (see the file WINE-AUTHORS
- for a complete list)
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef __WINE_BASETSD_H
-#define __WINE_BASETSD_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* defined(__cplusplus) */
-
-/*
- * Win32 was easy to implement under Unix since most (all?) 32-bit
- * Unices uses the same type model (ILP32) as Win32, where int, long
- * and pointer are 32-bit.
- *
- * Win64, however, will cause some problems when implemented under Unix.
- * Linux/{Alpha, Sparc64} and most (all?) other 64-bit Unices uses
- * the LP64 type model where int is 32-bit and long and pointer are
- * 64-bit. Win64 on the other hand uses the P64 (sometimes called LLP64)
- * type model where int and long are 32 bit and pointer is 64-bit.
- */
-
-/* Type model indepent typedefs */
-
-typedef char __int8;
-typedef unsigned char __uint8;
-
-typedef short __int16;
-typedef unsigned short __uint16;
-
-typedef int __int32;
-typedef unsigned int __uint32;
-
-typedef long long __int64;
-typedef unsigned long long __uint64;
-
-#if defined(_WIN64)
-
-typedef __uint32 __ptr32;
-typedef void *__ptr64;
-
-#else /* FIXME: defined(_WIN32) */
-
-typedef void *__ptr32;
-typedef __uint64 __ptr64;
-
-#endif
-
-/* Always signed and 32 bit wide */
-
-typedef __int32 LONG32;
-typedef __int32 INT32;
-
-typedef LONG32 *PLONG32;
-typedef INT32 *PINT32;
-
-/* Always unsigned and 32 bit wide */
-
-typedef __uint32 ULONG32;
-typedef __uint32 DWORD32;
-typedef __uint32 UINT32;
-
-typedef ULONG32 *PULONG32;
-typedef DWORD32 *PDWORD32;
-typedef UINT32 *PUINT32;
-
-/* Always signed and 64 bit wide */
-
-typedef __int64 LONG64;
-typedef __int64 INT64;
-
-typedef LONG64 *PLONG64;
-typedef INT64 *PINT64;
-
-/* Always unsigned and 64 bit wide */
-
-typedef __uint64 ULONG64;
-typedef __uint64 DWORD64;
-typedef __uint64 UINT64;
-
-typedef ULONG64 *PULONG64;
-typedef DWORD64 *PDWORD64;
-typedef UINT64 *PUINT64;
-
-/* Win32 or Win64 dependent typedef/defines. */
-
-#ifdef _WIN64
-
-typedef __int64 INT_PTR, *PINT_PTR;
-typedef __uint64 UINT_PTR, *PUINT_PTR;
-
-#define MAXINT_PTR 0x7fffffffffffffff
-#define MININT_PTR 0x8000000000000000
-#define MAXUINT_PTR 0xffffffffffffffff
-
-typedef __int32 HALF_PTR, *PHALF_PTR;
-typedef __int32 UHALF_PTR, *PUHALF_PTR;
-
-#define MAXHALF_PTR 0x7fffffff
-#define MINHALF_PTR 0x80000000
-#define MAXUHALF_PTR 0xffffffff
-
-typedef __int64 LONG_PTR, *PLONG_PTR;
-typedef __uint64 ULONG_PTR, *PULONG_PTR;
-typedef __uint64 DWORD_PTR, *PDWORD_PTR;
-
-#else /* FIXME: defined(_WIN32) */
-
-typedef __int32 INT_PTR, *PINT_PTR;
-typedef __uint32 UINT_PTR, *PUINT_PTR;
-
-#define MAXINT_PTR 0x7fffffff
-#define MININT_PTR 0x80000000
-#define MAXUINT_PTR 0xffffffff
-
-typedef __int16 HALF_PTR, *PHALF_PTR;
-typedef __uint16 UHALF_PTR, *PUHALF_PTR;
-
-#define MAXUHALF_PTR 0xffff
-#define MAXHALF_PTR 0x7fff
-#define MINHALF_PTR 0x8000
-
-typedef __int32 LONG_PTR, *PLONG_PTR;
-typedef __uint32 ULONG_PTR, *PULONG_PTR;
-typedef __uint32 DWORD_PTR, *PDWORD_PTR;
-
-#endif /* defined(_WIN64) || defined(_WIN32) */
-
-typedef INT_PTR SSIZE_T, *PSSIZE_T;
-typedef UINT_PTR SIZE_T, *PSIZE_T;
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif /* defined(__cplusplus) */
-
-#endif /* !defined(__WINE_BASETSD_H) */
-
-
-
--- /dev/null
+/* debug.c - COM+ debug helpers
+ * Copyright (C) 2001 g10 Code 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 General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <windows.h>
+#include <ole2.h>
+
+
+const char *
+debugstr_guid (const GUID *id)
+{
+ static char str[100];
+
+ if (!id)
+ return "(null)";
+ sprintf( str, "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
+ id->Data1, id->Data2, id->Data3,
+ id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
+ id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
+ return str;
+}
+
--- /dev/null
+/* gpgcom.c - COM+ component to access GnuPG
+ * Copyright (C) 2001 g10 Code 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 General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <windows.h>
+
+#include <ole2.h>
+
+#include "argparse.h"
+
+#include "main.h"
+#include "igpgme.h"
+
+static void register_server (void);
+static void unregister_server (void);
+static void enter_complus (void);
+
+
+enum cmd_and_opt_values { aNull = 0,
+ oQuiet = 'q',
+ oVerbose = 'v',
+
+ oNoVerbose = 500,
+ oOptions,
+ oDebug,
+ oDebugAll,
+ oNoGreeting,
+ oNoOptions,
+ oHomedir,
+ oGPGBinary,
+ oRegServer,
+ oUnregServer,
+ oEmbedding,
+aTest };
+
+
+static ARGPARSE_OPTS opts[] = {
+
+ { 301, NULL, 0, N_("@Options:\n ") },
+
+ { oVerbose, "verbose", 0, N_("verbose") },
+ { oQuiet, "quiet", 0, N_("be somewhat more quiet") },
+ { oOptions, "options" , 2, N_("read options from file")},
+ { oDebug, "debug" ,4|16, N_("set debugging flags")},
+ { oDebugAll, "debug-all" ,0, N_("enable full debugging")},
+ { oGPGBinary, "gpg-program", 2 , "" },
+ { oRegServer, "RegServer" , 0, "" },
+ { oUnregServer, "UnregServer" , 0, "" },
+ { oEmbedding, "Embedding" , 0, "" },
+{0} };
+
+
+
+
+static const char *
+my_strusage( int level )
+{
+ const char *p;
+ switch( level ) {
+ case 11: p = "gpgcom";
+ break;
+ case 13: p = VERSION; break;
+ /*case 17: p = PRINTABLE_OS_NAME; break;*/
+ case 19: p =
+ _("Please report bugs to <gpgme-bugs@gnupg.org>.\n");
+ break;
+ case 1:
+ case 40: p =
+ _("Usage: gpgcom [options] (-h for help)");
+ break;
+ case 41: p =
+ _("Syntax: gpgcom [options]\n"
+ "GnuPG COM+ component\n");
+ break;
+
+ default: p = NULL;
+ }
+ return p;
+}
+
+
+int
+main (int argc, char **argv )
+{
+ ARGPARSE_ARGS pargs;
+ int orig_argc;
+ char **orig_argv;
+ FILE *configfp = NULL;
+ char *configname = NULL;
+ unsigned configlineno;
+ int parse_debug = 0;
+ int default_config =1;
+ int greeting = 0;
+ int nogreeting = 0;
+ int action = 0;
+
+ set_strusage( my_strusage );
+ /*log_set_name ("gpa"); not yet implemented in logging.c */
+
+ opt.homedir = getenv("GNUPGHOME");
+ if( !opt.homedir || !*opt.homedir ) {
+ #ifdef HAVE_DRIVE_LETTERS
+ opt.homedir = "c:/gnupg";
+ #else
+ opt.homedir = "~/.gnupg";
+ #endif
+ }
+
+ /* check whether we have a config file on the commandline */
+ orig_argc = argc;
+ orig_argv = argv;
+ pargs.argc = &argc;
+ pargs.argv = &argv;
+ pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */
+ while( arg_parse( &pargs, opts) ) {
+ if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
+ parse_debug++;
+ else if( pargs.r_opt == oOptions ) {
+ /* yes there is one, so we do not try the default one, but
+ * read the option file when it is encountered at the commandline
+ */
+ default_config = 0;
+ }
+ else if( pargs.r_opt == oNoOptions )
+ default_config = 0; /* --no-options */
+ else if( pargs.r_opt == oHomedir )
+ opt.homedir = pargs.r.ret_str;
+ }
+
+ if( default_config )
+ configname = make_filename(opt.homedir, "gpgme.conf", NULL );
+
+
+ argc = orig_argc;
+ argv = orig_argv;
+ pargs.argc = &argc;
+ pargs.argv = &argv;
+ pargs.flags= 1 | (1<<5); /* do not remove the args, allow one dash */
+ next_pass:
+ if( configname ) {
+ configlineno = 0;
+ configfp = fopen( configname, "r" );
+ if( !configfp ) {
+ if( default_config ) {
+ if( parse_debug )
+ log_info(_("NOTE: no default option file `%s'\n"),
+ configname );
+ }
+ else {
+ log_error(_("option file `%s': %s\n"),
+ configname, strerror(errno) );
+ exit(2);
+ }
+ free(configname); configname = NULL;
+ }
+ if( parse_debug && configname )
+ log_info(_("reading options from `%s'\n"), configname );
+ default_config = 0;
+ }
+
+ while( optfile_parse( configfp, configname, &configlineno,
+ &pargs, opts) ) {
+ switch( pargs.r_opt ) {
+ case oQuiet: opt.quiet = 1; break;
+ case oVerbose: opt.verbose++; break;
+
+ case oDebug: opt.debug |= pargs.r.ret_ulong; break;
+ case oDebugAll: opt.debug = ~0; break;
+
+ case oOptions:
+ /* config files may not be nested (silently ignore them) */
+ if( !configfp ) {
+ free(configname);
+ configname = xstrdup(pargs.r.ret_str);
+ goto next_pass;
+ }
+ break;
+ case oNoGreeting: nogreeting = 1; break;
+ case oNoVerbose: opt.verbose = 0; break;
+ case oNoOptions: break; /* no-options */
+ case oHomedir: opt.homedir = pargs.r.ret_str; break;
+ case oGPGBinary: break;
+
+ case oRegServer: action = 1; break;
+ case oUnregServer: action = 2; break;
+ case oEmbedding: action = 3; break;
+
+ default : pargs.err = configfp? 1:2; break;
+ }
+ }
+ if( configfp ) {
+ fclose( configfp );
+ configfp = NULL;
+ free(configname); configname = NULL;
+ goto next_pass;
+ }
+ free( configname ); configname = NULL;
+ if( log_get_errorcount(0) )
+ exit(2);
+ if( nogreeting )
+ greeting = 0;
+
+ if( greeting ) {
+ fprintf(stderr, "%s %s; %s\n",
+ strusage(11), strusage(13), strusage(14) );
+ fprintf(stderr, "%s\n", strusage(15) );
+ }
+ #ifdef IS_DEVELOPMENT_VERSION
+ log_info("NOTE: this is a development version!\n");
+ #endif
+
+ if ( action == 1 )
+ register_server ();
+ else if (action == 2 )
+ unregister_server ();
+ else if (action == 3 )
+ enter_complus ();
+ else {
+ fprintf (stderr, "This is a COM+ component with no user interface.\n"
+ "gpgme --help will give you a list of options\n" );
+ exit (1);
+ }
+
+ return 0;
+}
+
+
+static void
+register_progid ( const char *name )
+{
+ HKEY hk = 0;
+ char buf[500];
+
+ /* Create a ProgID entry to point to the ClassID */
+ sprintf (buf, "%.400s", name);
+ if (RegCreateKeyA (HKEY_CLASSES_ROOT, buf, &hk)) {
+ fprintf (stderr,"RegCreateKey(`%s') failed\n", buf);
+ exit (1);
+ }
+ sprintf (buf, "g10 Code's GnuPG made easy COMponent" );
+ if (RegSetValueExA (hk, 0, 0, REG_SZ, buf, 0)) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegCloseKey (hk)) {
+ fprintf (stderr,"RegCloseKey() failed\n");
+ exit (1);
+ }
+ sprintf (buf, "%.400s\\CLSID", name);
+ if (RegCreateKeyA (HKEY_CLASSES_ROOT, buf, &hk)) {
+ fprintf (stderr,"RegCreateKey(`%s') failed\n", buf);
+ exit (1);
+ }
+ sprintf (buf, "%.100s", debugstr_guid (&CLSID_Gpgme) );
+ if (RegSetValueExA (hk, 0, 0, REG_SZ, buf, strlen (buf))) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegCloseKey (hk)) {
+ fprintf (stderr,"RegCloseKey() failed\n");
+ exit (1);
+ }
+ hk = 0;
+}
+
+
+static void
+register_typelib (void)
+{
+ ITypeLib *pTypeLib;
+ HRESULT hr;
+ char name[500];
+ wchar_t *wname;
+ size_t n;
+
+ if ( !GetModuleFileNameA (0, name, sizeof (name)-10) ) {
+ fprintf (stderr,"GetModuleFileName() failed: %d\n",
+ (int)GetLastError());
+ exit (1);
+ }
+ n = mbstowcs (NULL, name, strlen(name)+1);
+ wname = xmalloc ((n+1)*sizeof *wname);
+ mbstowcs (wname, name, strlen (name)+1);
+
+ hr = CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
+ if (hr)
+ fprintf (stderr, "CoInitializeEx() failed: hr=%lu\n", hr);
+
+ hr = LoadTypeLibEx (wname, REGKIND_REGISTER, &pTypeLib);
+ if (hr)
+ fprintf (stderr, "LoadTypeLibEx() failed: hr=%lx\n", hr);
+
+ ITypeLib_Release (pTypeLib);
+ CoUninitialize ();
+ free (wname);
+}
+
+static void
+unregister_typelib (void)
+{
+ UnRegisterTypeLib (&TLBID_Gpgcom, 1, 0, LANG_NEUTRAL, SYS_WIN32);
+}
+
+static void
+register_server ()
+{
+ HKEY hk = 0;
+ char buf[500];
+
+
+ register_typelib ();
+
+ /* Create a key for the CLSID */
+ sprintf (buf, "CLSID\\%.100s", debugstr_guid (&CLSID_Gpgme) );
+ if (RegCreateKeyA (HKEY_CLASSES_ROOT, buf, &hk)) {
+ fprintf (stderr,"RegCreateKey(`%s') failed\n", buf);
+ exit (1);
+ }
+ /* Store our class name as default value */
+ strcpy (buf, "Gpgme");
+ if (RegSetValueExA (hk, 0, 0, REG_SZ, buf, strlen (buf))) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+
+ /* Set the application ID */
+ sprintf (buf, "%.100s", debugstr_guid (&APPID_Gpgcom) );
+ if (RegSetValueExA (hk, "AppID", 0, REG_SZ, buf, strlen (buf))) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegCloseKey (hk)) {
+ fprintf (stderr,"RegCloseKey() failed\n");
+ exit (1);
+ }
+ hk = 0;
+
+ /* Create the LocalServer32 subkey under the CLSID key */
+ sprintf (buf, "CLSID\\%.100s\\LocalServer32",
+ debugstr_guid (&CLSID_Gpgme) );
+ if (RegCreateKeyA (HKEY_CLASSES_ROOT, buf, &hk)) {
+ fprintf (stderr,"RegCreateKey(`%s') failed\n", buf);
+ exit (1);
+ }
+ /* retrieve the module name and add it under the key */
+ if ( !GetModuleFileNameA (0, buf, sizeof (buf)-10) ) {
+ fprintf (stderr,"GetModuleFileName() failed\n");
+ exit (1);
+ }
+ if (RegSetValueExA (hk, 0, 0, REG_SZ, buf, strlen (buf))) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegCloseKey (hk)) {
+ fprintf (stderr,"RegCloseKey() failed\n");
+ exit (1);
+ }
+ hk = 0;
+
+ /* Create the ProgID subkey under the CLSID key */
+ sprintf (buf, "CLSID\\%.100s\\ProgID",
+ debugstr_guid (&CLSID_Gpgme) );
+ if (RegCreateKeyA (HKEY_CLASSES_ROOT, buf, &hk)) {
+ fprintf (stderr,"RegCreateKey(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegSetValueExA (hk, 0, 0, REG_SZ, "Gpgcom.Gpgme.1", 0)) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegCloseKey (hk)) {
+ fprintf (stderr,"RegCloseKey() failed\n");
+ exit (1);
+ }
+ hk = 0;
+ /* Create the VersionIndependentProgID subkey under the CLSID key */
+ sprintf (buf, "CLSID\\%.100s\\VersionIndependentProgID",
+ debugstr_guid (&CLSID_Gpgme) );
+ if (RegCreateKeyA (HKEY_CLASSES_ROOT, buf, &hk)) {
+ fprintf (stderr,"RegCreateKey(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegSetValueExA (hk, 0, 0, REG_SZ, "Gpgcom.Gpgme", 0)) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegCloseKey (hk)) {
+ fprintf (stderr,"RegCloseKey() failed\n");
+ exit (1);
+ }
+ hk = 0;
+
+
+ /* Create a key to store AppID info */
+ sprintf (buf, "AppID\\%.100s", debugstr_guid (&APPID_Gpgcom) );
+ if (RegCreateKeyA (HKEY_CLASSES_ROOT, buf, &hk)) {
+ fprintf (stderr,"RegCreateKey(`%s') failed\n", buf);
+ exit (1);
+ }
+ /* Store the name as default value */
+ strcpy (buf, "Gpgcom");
+ if (RegSetValueExA (hk, 0, 0, REG_SZ, buf, strlen (buf))) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegCloseKey (hk)) {
+ fprintf (stderr,"RegCloseKey() failed\n");
+ exit (1);
+ }
+ hk = 0;
+
+ register_progid ("Gpgcom.Gpgme");
+ register_progid ("Gpgcom.Gpgme.1");
+
+ /* Create a convenience cross reference to the AppID */
+ sprintf (buf, "AppID\\gpgcom.exe");
+ if (RegCreateKeyA (HKEY_CLASSES_ROOT, buf, &hk)) {
+ fprintf (stderr,"RegCreateKey(`%s') failed\n", buf);
+ exit (1);
+ }
+ sprintf (buf, "%.100s", debugstr_guid (&APPID_Gpgcom) );
+ if (RegSetValueExA (hk, "AppID", 0, REG_SZ, buf, strlen (buf))) {
+ fprintf (stderr,"RegSetValueEx(`%s') failed\n", buf);
+ exit (1);
+ }
+ if (RegCloseKey (hk)) {
+ fprintf (stderr,"RegCloseKey() failed\n");
+ exit (1);
+ }
+ hk = 0;
+
+ fprintf (stderr,"*** Component registered\n");
+}
+
+static void
+unregister_server ()
+{
+ char buf[500];
+
+ unregister_typelib ();
+ sprintf (buf, "CLSID\\%.100s\\LocalServer32",
+ debugstr_guid (&CLSID_Gpgme) );
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+
+ sprintf (buf, "CLSID\\%.100s\\ProgID", debugstr_guid (&CLSID_Gpgme) );
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+
+ sprintf (buf, "CLSID\\%.100s", debugstr_guid (&CLSID_Gpgme) );
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+
+ sprintf (buf, "Gpgcom.Gpgme.1\\CLSID");
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+ sprintf (buf, "Gpgcom.Gpgme.1");
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+
+ sprintf (buf, "Gpgcom.Gpgme\\CLSID");
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+ sprintf (buf, "Gpgcom.Gpgme");
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+
+
+ sprintf (buf, "AppID\\%.100s", debugstr_guid (&APPID_Gpgcom) );
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+
+ sprintf (buf, "AppID\\gpgcom.exe" );
+ if (RegDeleteKey (HKEY_CLASSES_ROOT, buf))
+ fprintf (stderr,"RegDeleteKey(`%s') failed\n", buf);
+
+ fprintf (stderr,"*** component unregistered\n");
+}
+
+
+static void
+enter_complus ()
+{
+ HANDLE running;
+ DWORD reg;
+ IClassFactory *factory;
+ CLSID clsid;
+ HRESULT hr;
+
+ fprintf (stderr,"*** enter enter_complus()\n");
+ CoInitializeEx (NULL, COINIT_MULTITHREADED);
+ running = CreateEvent (NULL, FALSE, FALSE, NULL );
+ fprintf (stderr,"*** CoInitialize() done; event=%lx\n", (unsigned long)running );
+
+ factory = igpgme_factory_new ( &clsid );
+ fprintf (stderr,"*** igpgme_factory_new() done; got=%p\n", factory );
+ hr = CoRegisterClassObject (&clsid, (IUnknown*)factory,
+ CLSCTX_LOCAL_SERVER,
+ REGCLS_SUSPENDED|REGCLS_MULTIPLEUSE, ® );
+ if (hr) {
+ fprintf (stderr, "CoRegisterClassObject() failed: hr=%lx\n", hr);
+ exit (1);
+ }
+ hr = CoResumeClassObjects ();
+ if (hr)
+ fprintf (stderr, "CoRegisterClassObject() failed: hr=%lx\n", hr);
+ fprintf (stderr,"*** class object registered; waiting\n" );
+
+ WaitForSingleObject ( running, INFINITE );
+ fprintf (stderr,"*** shutting down\n" );
+ CloseHandle (running);
+ CoRevokeClassObject ( reg );
+ fprintf (stderr,"*** class object revoked\n" );
+ igpgme_factory_release (factory);
+ fprintf (stderr,"*** factory released\n" );
+ CoUninitialize ();
+ fprintf (stderr,"*** leave enter_complus()\n" );
+}
+
--- /dev/null
+/* ignupg.idl - Interface definition for the COM+ class GnuPG
+ * Copyright (C) 2001 g10 Code 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 General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+import "unknwn.idl";
+import "oaidl.idl";
+
+
+[ object, uuid(3811fd50-7f72-11d5-8c9e-0080ad190cd5), dual]
+interface IGpgme : IDispatch
+{
+ HRESULT GetVersion([out] BSTR *retval);
+ HRESULT GetEngineInfo([out] BSTR *retval);
+ HRESULT Cancel(void);
+ [propput] HRESULT Armor([in] BOOL flag);
+ [propget] HRESULT Armor([out, retval] BOOL *retval);
+ [propput] HRESULT Textmode([in] BOOL flag);
+ [propget] HRESULT Textmode([out, retval] BOOL *retval);
+ [propput] HRESULT Plaintext([in] VARIANT val);
+ [propget] HRESULT Plaintext([out, retval] VARIANT *retval);
+ [propput] HRESULT Ciphertext([in] VARIANT val);
+ [propget] HRESULT Ciphertext([out,retval] VARIANT *retval);
+ HRESULT ClearRecipients(void);
+ HRESULT AddRecipient([in] BSTR name,
+ [in, optional, defaultvalue(-1)] signed short trust);
+ HRESULT ResetSignKeys(void);
+ HRESULT AddSignKey([in] BSTR name);
+ HRESULT Encrypt(void);
+ HRESULT Sign([in,optional,defaultvalue(0)] signed short signmode);
+ HRESULT SignEncrypt([in,optional,defaultvalue(0)] signed short signmode);
+
+};
+
+
+[ uuid(3811fd48-7f72-11d5-8c9e-0080ad190cd5),
+ helpstring("g10Code.gpgcom, type library"),
+ version(1.0) ]
+library GpgcomLib
+{
+ [ uuid(3811fd40-7f72-11d5-8c9e-0080ad190cd5) ]
+ coclass Gpgcom
+ {
+ [default] interface IGpgme;
+ }
+};
--- /dev/null
+/* gpgcom.rc - Resource file for gpgcom
+ * Copyright (C) 2001 g10 Code 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 General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+1 TYPELIB "gpgcom.tlb"
+
+++ /dev/null
-/* guiddef.h
-
- Copyright (c) 1993-2000 the Wine project authors (see the file WINE-AUTHORS
- for a complete list)
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/* already defined bu Mingw32/cpd
-#ifndef GUID_DEFINED
-#define GUID_DEFINED
-typedef struct _GUID
-{
- unsigned long Data1;
- unsigned short Data2;
- unsigned short Data3;
- unsigned char Data4[ 8 ];
-} GUID;
-#endif
-*/
-
-#undef DEFINE_GUID
-
-#ifdef INITGUID
-#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
- const GUID name = \
- { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
-#else
-#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
- extern const GUID name
-#endif
-
-#define DEFINE_OLEGUID(name, l, w1, w2) \
- DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)
-
-#ifndef _GUIDDEF_H_
-#define _GUIDDEF_H_
-
-/* typedef GUID *LPGUID;
- typedef GUID CLSID,*LPCLSID; */
-typedef GUID IID,*LPIID;
-typedef GUID FMTID,*LPFMTID;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-#define REFGUID const GUID &
-#define REFCLSID const CLSID &
-#define REFIID const IID &
-#define REFFMTID const FMTID &
-#else /* !defined(__cplusplus) && !defined(CINTERFACE) */
-#define REFGUID const GUID* const
-#define REFCLSID const CLSID* const
-#define REFIID const IID* const
-#define REFFMTID const FMTID* const
-#endif /* !defined(__cplusplus) && !defined(CINTERFACE) */
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-#define IsEqualGUID(rguid1, rguid2) (!memcmp(&(rguid1), &(rguid2), sizeof(GUID)))
-#else /* defined(__cplusplus) && !defined(CINTERFACE) */
-#define IsEqualGUID(rguid1, rguid2) (!memcmp(rguid1, rguid2, sizeof(GUID)))
-#endif /* defined(__cplusplus) && !defined(CINTERFACE) */
-#define IsEqualIID(riid1, riid2) IsEqualGUID(riid1, riid2)
-#define IsEqualCLSID(rclsid1, rclsid2) IsEqualGUID(rclsid1, rclsid2)
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-inline bool operator==(const GUID& guidOne, const GUID& guidOther)
-{
- return !memcmp(&guidOne,&guidOther,sizeof(GUID));
-}
-inline bool operator!=(const GUID& guidOne, const GUID& guidOther)
-{
- return !(guidOne == guidOther);
-}
-#endif
-
-extern const IID GUID_NULL;
-#define IID_NULL GUID_NULL
-#define CLSID_NULL GUID_NULL
-#define FMTID_NULL GUID_NULL
-
-#endif /* _GUIDDEF_H_ */
+++ /dev/null
-/* ignupg.c - COM+ class IGnuPG
- * Copyright (C) 2000 Werner Koch (dd9jn)
- *
- * This file is part of GPGME.
- *
- * GPGME is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <assert.h>
-#include <time.h>
-#include <windows.h>
-
-#define INITGUID
-#include "ignupg.h"
-
-/*
- * Declare the interface implementation structures
- */
-typedef struct IGnuPGImpl IGnuPGImpl;
-typedef struct IClassFactoryImpl IClassFactoryImpl;
-
-
-struct IGnuPGImpl {
- /* IUnknown required stuff */
- ICOM_VFIELD (IGnuPG);
- DWORD ref;
- /* Our stuff */
- int foo;
-};
-
-
-struct IClassFactoryImpl {
- /* IUnknown fields */
- ICOM_VFIELD(IClassFactory);
- DWORD ref;
-};
-
-
-
-/**********************************************************
- ************** IGnuPG Implementation *******************
- **********************************************************/
-
-static HRESULT WINAPI
-IGnuPGImpl_QueryInterface (IGnuPG *iface, REFIID refiid, LPVOID *obj)
-{
- ICOM_THIS (IGnuPGImpl,iface);
-
- fprintf (stderr,"(%p)->QueryInterface(%s,%p)\n",
- This, "debugstr_guid(refiid)", obj);
- if ( IsEqualGUID (&IID_IUnknown, refiid)
- || !IsEqualGUID (&IID_IGnuPG, refiid) ) {
- *obj = iface;
- return 0;
- }
- *obj = NULL;
- return E_NOINTERFACE;
-}
-
-
-static ULONG WINAPI
-IGnuPGImpl_AddRef (IGnuPG *iface)
-{
- ICOM_THIS (IGnuPGImpl,iface);
-
- return ++This->ref;
-}
-
-
-static ULONG WINAPI
-IGnuPGImpl_Release (IGnuPG *iface)
-{
- ICOM_THIS (IGnuPGImpl,iface);
-
- if (--This->ref)
- return This->ref;
-
- HeapFree(GetProcessHeap(),0,iface);
- return 0;
-}
-
-
-
-
-static ICOM_VTABLE(IGnuPG) gnupg_vtbl =
-{
- /* IUnknow methods */
- ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
- IGnuPGImpl_QueryInterface,
- IGnuPGImpl_AddRef,
- IGnuPGImpl_Release,
- /* Our methods */
-
-};
-
-
-
-/***************************************************************
- ****************** GnuPG Factory ****************************
- ***************************************************************/
-
-static HRESULT WINAPI
-GnuPGFactory_QueryInterface (IClassFactory *iface, REFIID refiid, LPVOID *obj)
-{
- /*ICOM_THIS(IClassFactoryImpl,iface);*/
- return E_NOINTERFACE;
-}
-
-static ULONG WINAPI
-GnuPGFactory_AddRef (IClassFactory *iface)
-{
- ICOM_THIS(IClassFactoryImpl,iface);
- return ++(This->ref);
-}
-
-static ULONG WINAPI
-GnuPGFactory_Release (IClassFactory *iface)
-{
- ICOM_THIS(IClassFactoryImpl,iface);
- return --(This->ref);
-}
-
-static HRESULT WINAPI
-GnuPGFactory_CreateInstance (IClassFactory *iface, IUnknown *outer,
- REFIID refiid, LPVOID *r_obj )
-{
- /*ICOM_THIS(IClassFactoryImpl,iface);*/
-
- if ( IsEqualGUID (&IID_IGnuPG, refiid) ) {
- IGnuPGImpl *obj;
-
- obj = HeapAlloc (GetProcessHeap(), 0, sizeof *obj );
- if ( !obj)
- return E_OUTOFMEMORY;
-
- ICOM_VTBL(obj) = &gnupg_vtbl;
- obj->ref = 1;
- *r_obj = obj;
- return 0;
- }
- *r_obj = NULL;
- return E_NOINTERFACE;
-}
-
-static HRESULT WINAPI
-GnuPGFactory_LockServer (IClassFactory *iface, BOOL dolock )
-{
- /*ICOM_THIS(IClassFactoryImpl,iface);*/
- return 0;
-}
-
-static ICOM_VTABLE(IClassFactory) gnupg_factory_vtbl = {
- ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
- GnuPGFactory_QueryInterface,
- GnuPGFactory_AddRef,
- GnuPGFactory_Release,
- GnuPGFactory_CreateInstance,
- GnuPGFactory_LockServer
-};
-static IClassFactoryImpl GnuPG_CF = {&gnupg_factory_vtbl, 1 };
-
-
-IClassFactory *
-gnupg_factory_new ( CLSID *r_clsid )
-{
- *r_clsid = CLSID_GnuPG;
- IClassFactory_AddRef((IClassFactory*)&GnuPG_CF);
- return (IClassFactory*)&GnuPG_CF;
-}
-
-void
-gnupg_factory_release ( IClassFactory *factory )
-{
- /* it's static - nothing to do */
-}
-
-
-
-
-
-
-
-
-
+++ /dev/null
-/* ignupg.h - COM+ class IGnuPG
- * Copyright (C) 2000 Werner Koch (dd9jn)
- *
- * This file is part of GPGME.
- *
- * GPGME is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#ifndef IGNUPG_H
-#define IGNUPG_H 1
-
-#include "obj_base.h"
-
-DEFINE_GUID(CLSID_GnuPG, 0x42424242, 0x62e8, 0x11cf,
- 0x93, 0xbc, 0x44, 0x45, 0x53, 0x54, 0x0, 0x0);
-DEFINE_GUID(IID_IGnuPG, 0x24242424, 0x4981, 0x11CE,
- 0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60);
-typedef struct IGnuPG IGnuPG;
-
-
-
-#define ICOM_INTERFACE IGnuPG
-
-#define IGnuPG_METHODS \
- ICOM_METHOD1(HRESULT,Initialize, REFIID,) \
- ICOM_METHOD1(HRESULT,EnumDevices, LPVOID,)
-
-#define IGnuPG_IMETHODS \
- IUnknown_IMETHODS \
- IGnuPG_METHODS
-
-ICOM_DEFINE(IGnuPG,IUnknown)
-#undef ICOM_INTERFACE
-
-
-/*** IUnknown methods ***/
-#define IGnuPG_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
-#define IGnuPG_AddRef(p) ICOM_CALL (AddRef,p)
-#define IGnuPG_Release(p) ICOM_CALL (Release,p)
-/*** IGnuPG methods ***/
-#define IGnuPG_Initialize(p,a) ICOM_CALL1(Initialize,p,a)
-#define IGnuPG_EnumDevices(p,a,b) ICOM_CALL2(EnumDevice,p,a,b)
-
-
-#endif /*IGNUPG_H*/
-
-
-
-
-
-
-
-
-
-
-
--- /dev/null
+/* igpgme.c - COM+ class IGpgme
+ * Copyright (C) 2001 g10 Code 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 General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <windows.h>
+
+#include "../gpgme/gpgme.h"
+
+/* FIXME: Put them into an extra header */
+void *_gpgme_malloc (size_t n );
+void *_gpgme_calloc (size_t n, size_t m );
+void *_gpgme_realloc (void *p, size_t n);
+char *_gpgme_strdup (const char *p);
+void _gpgme_free ( void *a );
+
+
+
+#define INITGUID
+#include "igpgme.h"
+
+/*
+ * Declare the interface implementation structures
+ */
+typedef struct IGpgmeImpl IGpgmeImpl;
+typedef struct IClassFactoryImpl IClassFactoryImpl;
+
+
+struct IGpgmeImpl {
+ /* IUnknown required stuff */
+ ICOM_VFIELD (IGpgme);
+ DWORD ref;
+ /* Delegation to IDispatch */
+ struct {
+ IUnknown *disp;
+ ITypeInfo *tinfo;
+ } std_disp;
+ /* Our stuff */
+ GpgmeCtx mainctx;
+ GpgmeData plaintext;
+ int plaintext_given_as_bstr;
+ GpgmeData ciphertext;
+ int ciphertext_is_armored;
+ GpgmeRecipients rset;
+};
+
+
+struct IClassFactoryImpl {
+ /* IUnknown fields */
+ ICOM_VFIELD(IClassFactory);
+ DWORD ref;
+};
+
+/**********************************************************
+ ************** helper functions ************************
+ *********************************************************/
+static HRESULT
+map_gpgme_error (GpgmeError err)
+{
+ HRESULT hr;
+
+ if (!err)
+ return 0;
+ if ( err < 0 || err > 0x1000 ) {
+ fprintf (stderr,"*** GpgmeError `%s' mapped to GPGME_General_Error\n",
+ gpgme_strerror (err) );
+ err = GPGME_General_Error;
+ }
+ hr = MAKE_HRESULT (SEVERITY_ERROR, FACILITY_ITF, 0x1000 + err);
+ fprintf (stderr,"*** GpgmeError `%s' mapped to %lx\n",
+ gpgme_strerror (err), (unsigned long)hr );
+ return hr;
+}
+
+
+/**********************************************************
+ ************** IGpgme Implementation *******************
+ *********************************************************/
+
+static HRESULT WINAPI
+m_IGpgme_QueryInterface (IGpgme *iface, REFIID refiid, LPVOID *obj)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ /*fprintf (stderr,"*** m_IGpgme_QueryInterface(%p,%s)",
+ This, debugstr_guid(refiid));*/
+ if ( IsEqualGUID (&IID_IUnknown, refiid)
+ || IsEqualGUID (&IID_IGpgme, refiid) ) {
+ *obj = This;
+ IGpgme_AddRef (iface);
+ fprintf (stderr," -> got %p\n", *obj);
+ return 0;
+ }
+ else if ( IsEqualGUID (&IID_IDispatch, refiid) ) {
+ HRESULT hr = IDispatch_QueryInterface (This->std_disp.disp,
+ refiid, obj);
+ /*fprintf (stderr," -> delegated, hr=%lx, got %p\n",
+ hr, hr? NULL: *obj);*/
+ return hr;
+ }
+ /*fprintf (stderr," -> none\n");*/
+ *obj = NULL;
+ return E_NOINTERFACE;
+}
+
+
+static ULONG WINAPI
+m_IGpgme_AddRef (IGpgme *iface)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ return ++This->ref;
+}
+
+
+static ULONG WINAPI
+m_IGpgme_Release (IGpgme *iface)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ if (--This->ref)
+ return This->ref;
+
+ gpgme_release (This->mainctx); This->mainctx = NULL;
+ gpgme_data_release (This->plaintext); This->plaintext = NULL;
+ gpgme_data_release (This->ciphertext); This->ciphertext = NULL;
+ gpgme_recipients_release (This->rset); This->rset = NULL;
+ if (This->std_disp.disp)
+ IDispatch_Release (This->std_disp.disp);
+ if (This->std_disp.tinfo)
+ ITypeInfo_Release (This->std_disp.tinfo);
+ HeapFree(GetProcessHeap(),0,iface);
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_stub_IDispatch_GetTypeInfoCount (IGpgme *iface, unsigned int *pctinfo)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI
+m_stub_IDispatch_GetTypeInfo (IGpgme *iface, UINT iTInfo,
+ LCID lcid, ITypeInfo **ppTInfo)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI
+m_stub_IDispatch_GetIDsOfNames (IGpgme *iface, REFIID riid,
+ LPOLESTR *rgszNames, UINT cNames,
+ LCID lcid, DISPID *rgDispId)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI
+m_stub_IDispatch_Invoke (IGpgme *iface, DISPID dispIdMember,
+ REFIID riid, LCID lcid, WORD wFlags,
+ DISPPARAMS *pDispParams, VARIANT *pVarResult,
+ EXCEPINFO *pExepInfo, UINT *puArgErr)
+{
+ return E_NOTIMPL;
+}
+
+
+
+static HRESULT WINAPI
+m_IGpgme_GetVersion (IGpgme *iface, BSTR *retvat)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI
+m_IGpgme_GetEngineInfo (IGpgme *iface, BSTR *retval)
+{
+ return E_NOTIMPL;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_Cancel (IGpgme *iface)
+{
+ return E_NOTIMPL;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_SetArmor (IGpgme *iface, BOOL yes)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+ gpgme_set_armor (This->mainctx, yes);
+ return 0;
+}
+
+static HRESULT WINAPI
+m_IGpgme_GetArmor (IGpgme *iface, BOOL *retval)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ *retval = gpgme_get_armor (This->mainctx);
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_SetTextmode (IGpgme *iface, BOOL yes)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+ gpgme_set_textmode (This->mainctx, yes);
+ return 0;
+}
+
+static HRESULT WINAPI
+m_IGpgme_GetTextmode (IGpgme *iface, BOOL *retval)
+{
+ return E_NOTIMPL;
+}
+
+
+/*
+ * Put the data from VAL into a a Gpgme data object, which is passed by
+ * reference. Valid types of the Variant are: BSTR, SAFEARRAY of BYTE and
+ * SAFEARRAY of VARIANTS of signed or unsigned integers.
+ */
+static HRESULT WINAPI
+set_data_from_variant (GpgmeData *data, VARIANT val, int *given_as_bstr)
+{
+ GpgmeError err = 0;
+ HRESULT hr;
+ unsigned char *buf;
+ SAFEARRAY *array;
+ size_t len;
+ int i;
+
+ if ( val.vt == VT_BSTR) {
+ len = bstrtoutf8 (val.u.bstrVal, NULL, 0);
+ buf = _gpgme_malloc (len);
+ if (!buf)
+ return E_OUTOFMEMORY;
+
+ if (bstrtoutf8 (val.u.bstrVal, buf, len) < 0) {
+ fprintf (stderr,"problem with bstrtoutf8\n");
+ _gpgme_free (buf);
+ return E_FAIL;
+ }
+
+ fprintf (stderr,"Got a BSTR (utf8):");
+ for (i=0; i < len; i++)
+ fprintf (stderr, " %0X", buf[i] );
+ putc ('\n', stderr);
+ gpgme_data_release (*data); *data = NULL;
+ err = gpgme_data_new_from_mem (data, buf, len, 0 /*no need to copy*/ );
+ if (!err && given_as_bstr)
+ *given_as_bstr = 1;
+ }
+ else if ( val.vt == (VT_ARRAY|VT_UI1)) {
+ array = val.u.parray;
+
+ fprintf (stderr,"Got an ARRAY of bytes:");
+ hr = SafeArrayAccessData (array, (void**)&buf);
+ if (hr) {
+ fprintf (stderr,"*** SafeArrayAccessData failed: hr=%lx\n", hr);
+ return hr;
+ }
+ len = array->rgsabound[0].cElements;
+ for (i=0; i < len; i++)
+ fprintf (stderr, " %0X", buf[i] );
+ putc ('\n', stderr);
+
+ gpgme_data_release (*data); *data = NULL;
+ err = gpgme_data_new_from_mem (data, buf, len, 1 );
+ SafeArrayUnaccessData (array);
+ if (given_as_bstr)
+ *given_as_bstr = 0;
+ }
+ else if ( val.vt == (VT_ARRAY|VT_VARIANT)) {
+ VARIANT *vp;
+ array = val.u.parray;
+
+ fprintf (stderr,"Got an ARRAY of VARIANTS:");
+ hr = SafeArrayAccessData (array, (void**)&vp);
+ if (hr) {
+ fprintf (stderr,"*** SafeArrayAccessData failed: hr=%lx\n", hr);
+ return hr;
+ }
+ len = array->rgsabound[0].cElements;
+ /* allocate the array using the gpgme allocator so that we can
+ * later use a new without the copy set*/
+ buf = _gpgme_malloc (len);
+ if (!buf) {
+ SafeArrayUnaccessData (array);
+ return E_OUTOFMEMORY;
+ }
+ /* coerce all array elements into rawtext */
+ for (i=0; i < len; i++) {
+ switch (vp[i].vt) {
+ case VT_I1: buf[i] = (BYTE)vp[i].u.cVal; break;
+ case VT_I2: buf[i] = ((UINT)vp[i].u.iVal) & 0xff; break;
+ case VT_I4: buf[i] = ((ULONG)vp[i].u.lVal) & 0xff; break;
+ case VT_INT: buf[i] = ((UINT)vp[i].u.intVal) & 0xff; break;
+ case VT_UI1: buf[i] = vp[i].u.bVal; break;
+ case VT_UI2: buf[i] = vp[i].u.uiVal & 0xff; break;
+ case VT_UI4: buf[i] = vp[i].u.ulVal & 0xff; break;
+ case VT_UINT: buf[i] = vp[i].u.uintVal & 0xff; break;
+ default:
+ fprintf (stderr, "Invalid value in array as pos %d\n", i);
+ _gpgme_free (buf);
+ SafeArrayUnaccessData (array);
+ return E_INVALIDARG;
+ }
+ }
+
+ for (i=0; i < len; i++)
+ fprintf (stderr, " %0X", buf[i] );
+ putc ('\n', stderr);
+
+ gpgme_data_release (*data); *data = NULL;
+ err = gpgme_data_new_from_mem (data, buf, len, 0);
+ SafeArrayUnaccessData (array);
+ if (given_as_bstr)
+ *given_as_bstr = 0;
+ }
+ else {
+ fprintf (stderr, "Got a variant type = %d (0x%x)\n",
+ (int)val.vt, (int)val.vt );
+ return E_INVALIDARG; /* not a safearray of bytes */
+ }
+ return map_gpgme_error (err);
+}
+
+
+static HRESULT WINAPI
+set_data_to_variant (GpgmeData data, VARIANT *retval, int use_bstr)
+{
+ GpgmeError err;
+ HRESULT hr;
+ SAFEARRAY *array;
+ char *p;
+ size_t nread, len;
+ int i;
+
+ /* Get some info on the data */
+ err = gpgme_data_rewind (data);
+ if (err ) {
+ fprintf (stderr, "*** gpgme_data_rewind failed: %d\n", err);
+ return map_gpgme_error (err);
+ }
+ err = gpgme_data_read (data, NULL, 0, &nread);
+ if (err && err != GPGME_EOF ) {
+ fprintf (stderr, "*** gpgme_data_read [length] failed: %d\n", err);
+ return map_gpgme_error (err);
+ }
+ len = nread; /*(eof returns a length of 0)*/
+ fprintf (stderr,"*** %d bytes are availabe\n", (int)len);
+
+ /* convert it to the target data type */
+ if (use_bstr) {
+ BSTR bs;
+ unsigned char *helpbuf;
+
+ fprintf (stderr," using BSTR\n");
+ /* It is easier to allocate some helper storage */
+ helpbuf = _gpgme_malloc (len);
+ if (!helpbuf)
+ return E_OUTOFMEMORY;
+ err = gpgme_data_read (data, helpbuf, len, &nread);
+ if (err ) {
+ _gpgme_free (helpbuf);
+ fprintf (stderr, "*** gpgme_data_read [data] failed: %d\n", err);
+ return map_gpgme_error (err);
+ }
+
+ bs = SysAllocStringLen (NULL, len+1);
+ if (!bs) {
+ _gpgme_free (helpbuf);
+ return E_OUTOFMEMORY;
+ }
+
+ for (i=0, p=helpbuf; i < len; i++, p++)
+ bs[i] = *p;
+ bs[i] = 0;
+ _gpgme_free (helpbuf);
+
+ /* Ready */
+ VariantInit (retval);
+ retval->vt = VT_BSTR;
+ retval->u.bstrVal = bs;
+ }
+#if 0
+ else if (use_byte_array) {
+ array = SafeArrayCreateVector (VT_UI1, 0, len);
+ if (!array)
+ return E_OUTOFMEMORY;
+
+ p = NULL;
+ hr = SafeArrayAccessData (array, (void**)&p);
+ if (hr) {
+ fprintf (stderr,"*** SafeArrayAccessData failed: hr=%lx\n", hr);
+ SafeArrayDestroyData (array);
+ SafeArrayDestroy (array);
+ return hr;
+ }
+ if (len) {
+ err = gpgme_data_read (data, p, len, &nread);
+ if (err ) {
+ SafeArrayUnaccessData (array);
+ SafeArrayDestroyData (array);
+ SafeArrayDestroy (array);
+ fprintf (stderr, "*** gpgme_data_read [data] failed: %d\n",
+ err);
+ return map_gpgme_error (err);
+ }
+ }
+ SafeArrayUnaccessData (array);
+
+ /* pass the data to the caller */
+ VariantInit (retval);
+ retval->vt = (VT_ARRAY|VT_UI1);
+ retval->u.parray = array;
+ }
+#endif
+ else { /* Create an array of variants of bytes */
+ VARIANT *v;
+ unsigned char *helpbuf;
+
+ /* It is easier to allocate some helper storage */
+ helpbuf = _gpgme_malloc (len);
+ if (!helpbuf)
+ return E_OUTOFMEMORY;
+ err = gpgme_data_read (data, helpbuf, len, &nread);
+ if (err ) {
+ _gpgme_free (helpbuf);
+ fprintf (stderr, "*** gpgme_data_read [data] failed: %d\n", err);
+ return map_gpgme_error (err);
+ }
+
+ /* The create the array */
+ array = SafeArrayCreateVector (VT_VARIANT, 0, len);
+ if (!array) {
+ _gpgme_free (helpbuf);
+ return E_OUTOFMEMORY;
+ }
+
+ v = NULL;
+ hr = SafeArrayAccessData (array, (void**)&v);
+ if (hr) {
+ fprintf (stderr,"*** SafeArrayAccessData failed: hr=%lx\n", hr);
+ _gpgme_free (helpbuf);
+ SafeArrayDestroyData (array);
+ SafeArrayDestroy (array);
+ return hr;
+ }
+
+ for (p=helpbuf; len; len--, v++) {
+ VariantInit (v);
+ v->vt = VT_UI1;
+ v->u.bVal = *p;
+ }
+ SafeArrayUnaccessData (array);
+ _gpgme_free (helpbuf);
+
+ /* pass the data to the caller */
+ VariantInit (retval);
+ retval->vt = (VT_ARRAY|VT_VARIANT);
+ retval->u.parray = array;
+ }
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_SetPlaintext (IGpgme *iface, VARIANT val)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+ return set_data_from_variant (&This->plaintext, val,
+ &This->plaintext_given_as_bstr);
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_GetPlaintext (IGpgme *iface, VARIANT *retval)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+ return set_data_to_variant (This->plaintext, retval,
+ This->plaintext_given_as_bstr);
+}
+
+static HRESULT WINAPI
+m_IGpgme_SetCiphertext (IGpgme *iface, VARIANT val)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+ return set_data_from_variant (&This->ciphertext, val, NULL);
+}
+
+static HRESULT WINAPI
+m_IGpgme_GetCiphertext (IGpgme *iface, VARIANT *retval)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+ return set_data_to_variant (This->ciphertext, retval,
+ This->ciphertext_is_armored);
+}
+
+static HRESULT WINAPI
+m_IGpgme_ClearRecipients (IGpgme *iface)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+ gpgme_recipients_release (This->rset); This->rset = NULL;
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_AddRecipient (IGpgme *iface, BSTR name, signed short int trust)
+{
+ GpgmeError err;
+ int n;
+ char *p;
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p, %d)\n", This, (int)trust);
+ if (!This->rset) {
+ err = gpgme_recipients_new (&This->rset);
+ if (err)
+ return map_gpgme_error (err);
+ }
+
+ n = bstrtoutf8 (name, NULL, 0);
+ p = HeapAlloc (GetProcessHeap(), 0, n );
+ if (!p) {
+ fprintf (stderr,"HeapAlloc failed: ec=%d\n", (int)GetLastError () );
+ return E_OUTOFMEMORY;
+ }
+ if (bstrtoutf8 (name, p, n) < 0) {
+ fprintf (stderr,"problem with bstrtoutf8\n");
+ HeapFree (GetProcessHeap(), 0, p);
+ return E_FAIL;
+ }
+ fprintf (stderr,"*** adding name `%s'\n", p);
+ err = gpgme_recipients_add_name (This->rset, p);
+ HeapFree (GetProcessHeap(), 0, p);
+ return map_gpgme_error (err);
+}
+
+static HRESULT WINAPI
+m_IGpgme_ResetSignKeys (IGpgme *iface)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI
+m_IGpgme_AddSignKey (IGpgme *iface, BSTR name)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI
+m_IGpgme_Encrypt (IGpgme *iface)
+{
+ GpgmeError err;
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+ gpgme_data_release (This->ciphertext);
+ err = gpgme_data_new (&This->ciphertext);
+ if (err)
+ return map_gpgme_error (err);
+
+
+ This->ciphertext_is_armored = gpgme_get_armor (This->mainctx);
+ err = gpgme_op_encrypt (This->mainctx, This->rset,
+ This->plaintext, This->ciphertext);
+#if 0
+ if (!err ) {
+ char buf[100];
+ size_t nread;
+
+ err = gpgme_data_rewind ( This->ciphertext );
+ if (err )
+ fprintf (stderr, "*** gpgme_data_rewind failed: %d\n", err);
+ while ( !(err = gpgme_data_read ( This->ciphertext,
+ buf, 100, &nread )) ) {
+ fwrite ( buf, nread, 1, stderr );
+ }
+ if (err != GPGME_EOF)
+ fprintf (stderr, "*** gpgme_data_read failed: %d\n", err);
+ err = 0;
+ }
+#endif
+
+ return map_gpgme_error (err);
+}
+
+static HRESULT WINAPI
+m_IGpgme_Sign (IGpgme *iface, short int signmode)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI
+m_IGpgme_SignEncrypt (IGpgme *iface, short int signmode)
+{
+ ICOM_THIS (IGpgmeImpl,iface);
+
+ fprintf (stderr,"*** " __PRETTY_FUNCTION__ "(%p)\n", This );
+
+ return E_NOTIMPL;
+}
+
+#if 0
+static HRESULT WINAPI
+m_IGpgme_SetKeylistMode( GpgmeCtx c, BOOL mode )
+{
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_SetPassphraseCB (GpgmeCtx c,
+ GpgmePassphraseCb cb, void *cb_value)
+{
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_SetProgressCB (GpgmeCtx c, GpgmeProgressCb cb, void *cb_value)
+{
+ return E_NOTIMPL;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_SignersClear (GpgmeCtx c)
+{
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_SignersAdd (GpgmeCtx c, const GpgmeKey key)
+{
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_SignersEnum (const GpgmeCtx c, int seq)
+{
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_GetSigStatus(GpgmeCtx c, int idx,
+ GpgmeSigStat *r_stat, time_t *r_created );
+{
+ return 0;
+}
+
+
+static HRESULT WINAPI
+m_IGpgme_GetSigKey (GpgmeCtx c, int idx, GpgmeKey *r_key);
+{
+ return 0;
+}
+
+static HRESULT WINAPI
+m_IGpgme_GetNotation(IGpgme *c, BSTR *retval)
+{
+ return 0;
+}
+#endif
+
+
+static ICOM_VTABLE(IGpgme) igpgme_vtbl =
+{
+ /* IUnknown methods */
+ ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+ m_IGpgme_QueryInterface,
+ m_IGpgme_AddRef,
+ m_IGpgme_Release,
+ /* IDispatch methods */
+ m_stub_IDispatch_GetTypeInfoCount,
+ m_stub_IDispatch_GetTypeInfo,
+ m_stub_IDispatch_GetIDsOfNames,
+ m_stub_IDispatch_Invoke,
+ /* Our methods */
+ m_IGpgme_GetVersion,
+ m_IGpgme_GetEngineInfo,
+ m_IGpgme_Cancel,
+ m_IGpgme_SetArmor,
+ m_IGpgme_GetArmor,
+ m_IGpgme_SetTextmode,
+ m_IGpgme_GetTextmode,
+ m_IGpgme_SetPlaintext,
+ m_IGpgme_GetPlaintext,
+ m_IGpgme_SetCiphertext,
+ m_IGpgme_GetCiphertext,
+ m_IGpgme_ClearRecipients,
+ m_IGpgme_AddRecipient,
+ m_IGpgme_ResetSignKeys,
+ m_IGpgme_AddSignKey,
+ m_IGpgme_Encrypt,
+ m_IGpgme_Sign,
+ m_IGpgme_SignEncrypt,
+/* m_IGpgme_SetKeylistMode,
+ * m_IGpgme_SetPassphraseCB,
+ * m_IGpgme_SetProgressCB,
+ * m_IGpgme_SignersClear,
+ * m_IGpgme_SignersAdd,
+ * m_IGpgme_SignersEnum,
+ * m_IGpgme_GetSigStatus,
+ * m_IGpgme_GetSigKey,
+ * m_IGpgme_GetNotation
+ */
+};
+
+
+
+/***************************************************************
+ ****************** Gpgme Factory ****************************
+ ***************************************************************/
+
+static HRESULT WINAPI
+m_GpgmeFactory_QueryInterface (IClassFactory *iface,
+ REFIID refiid, LPVOID *obj)
+{
+ ICOM_THIS (IClassFactoryImpl,iface);
+
+ /*fprintf (stderr,"*** m_GpgmeFactory_QueryInterface(%p,%s)",
+ This, debugstr_guid(refiid));*/
+ if ( IsEqualGUID (&IID_IUnknown, refiid)
+ || IsEqualGUID (&IID_IClassFactory, refiid) ) {
+ *obj = This;
+ /*fprintf (stderr," -> got %p\n", obj);*/
+ return 0;
+ }
+ *obj = NULL;
+ /*fprintf (stderr," -> none\n");*/
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI
+m_GpgmeFactory_AddRef (IClassFactory *iface)
+{
+ ICOM_THIS(IClassFactoryImpl,iface);
+ return ++(This->ref);
+}
+
+static ULONG WINAPI
+m_GpgmeFactory_Release (IClassFactory *iface)
+{
+ ICOM_THIS(IClassFactoryImpl,iface);
+ return --(This->ref);
+}
+
+static HRESULT WINAPI
+m_GpgmeFactory_CreateInstance (IClassFactory *iface, IUnknown *outer,
+ REFIID refiid, LPVOID *r_obj )
+{
+ /*ICOM_THIS(IClassFactoryImpl,iface);*/
+
+ fprintf (stderr,"*** m_GpgmeFactory_CreateInstance(%s)",
+ debugstr_guid(refiid) );
+ if ( IsEqualGUID (&IID_IUnknown, refiid)
+ || IsEqualGUID (&IID_IGpgme, refiid) ) {
+ IGpgmeImpl *obj;
+ GpgmeCtx ctx;
+ GpgmeError err;
+
+
+ err = gpgme_new (&ctx);
+ if (err) {
+ fprintf (stderr," -> gpgme_new failed: %s\n", gpgme_strerror (err));
+ return E_OUTOFMEMORY;
+ }
+
+ obj = HeapAlloc (GetProcessHeap(), 0, sizeof *obj );
+ if ( !obj) {
+ fprintf (stderr," -> out of core\n");
+ gpgme_release (ctx);
+ return E_OUTOFMEMORY;
+ }
+ memset (obj, 0, sizeof *obj);
+
+ ICOM_VTBL(obj) = &igpgme_vtbl;
+ obj->ref = 1;
+ obj->mainctx = ctx;
+ { /* Fixme: need to release some stuff on error */
+ HRESULT hr;
+ ITypeLib *pTypeLib;
+
+ hr = LoadRegTypeLib (&TLBID_Gpgcom, 1, 0, LANG_NEUTRAL, &pTypeLib);
+ if (hr) {
+ fprintf (stderr," -> LoadRegTypeLib failed: %lx\n", hr);
+ return hr;
+ }
+ hr = ITypeLib_GetTypeInfoOfGuid (pTypeLib, &IID_IGpgme,
+ &obj->std_disp.tinfo);
+ ITypeLib_Release (pTypeLib);
+ if (hr) {
+ fprintf (stderr," -> GetTypeInfoOfGuid failed: %lx\n", hr);
+ return hr;
+ }
+ hr = CreateStdDispatch ((IUnknown*)obj, obj, obj->std_disp.tinfo,
+ &obj->std_disp.disp);
+ if (hr) {
+ fprintf (stderr," -> CreateStdDispatch failed: %lx\n", hr);
+ return hr;
+ }
+ }
+
+ *r_obj = obj;
+ fprintf (stderr," -> created %p\n", obj );
+ return 0;
+ }
+ fprintf (stderr," -> no interface\n" );
+ *r_obj = NULL;
+ return E_NOINTERFACE;
+}
+
+static HRESULT WINAPI
+m_GpgmeFactory_LockServer (IClassFactory *iface, BOOL dolock )
+{
+ /*ICOM_THIS(IClassFactoryImpl,iface);*/
+ return 0;
+}
+
+static ICOM_VTABLE(IClassFactory) igpgme_factory_vtbl = {
+ ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+ m_GpgmeFactory_QueryInterface,
+ m_GpgmeFactory_AddRef,
+ m_GpgmeFactory_Release,
+ m_GpgmeFactory_CreateInstance,
+ m_GpgmeFactory_LockServer
+};
+static IClassFactoryImpl igpgme_CF = {&igpgme_factory_vtbl, 1 };
+
+
+IClassFactory *
+igpgme_factory_new ( CLSID *r_clsid )
+{
+ *r_clsid = CLSID_Gpgme;
+ IClassFactory_AddRef((IClassFactory*)&igpgme_CF);
+ return (IClassFactory*)&igpgme_CF;
+}
+
+void
+igpgme_factory_release ( IClassFactory *factory )
+{
+ /* it's static - nothing to do */
+}
--- /dev/null
+/* igpgme.h - COM+ class IGpgme
+ * Copyright (C) 2001 g10 Code 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 General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#ifndef IGPGME_H
+#define IGPGME_H 1
+
+#include <ole2.h>
+
+DEFINE_GUID(CLSID_Gpgme, 0x3811fd40, 0x7f72, 0x11d5,
+ 0x8c, 0x9e, 0x00, 0x80, 0xad, 0x19, 0x0c, 0xd5);
+#if 0
+DEFINE_GUID(CLSID_GpgmeData, 0x3811fd41, 0x7f72, 0x11d5,
+ 0x8c, 0x9e, 0x00, 0x80, 0xad, 0x19, 0x0c, 0xd5);
+DEFINE_GUID(CLSID_GpgmeKey, 0x3811fd42, 0x7f72, 0x11d5,
+ 0x8c, 0x9e, 0x00, 0x80, 0xad, 0x19, 0x0c, 0xd5);
+DEFINE_GUID(CLSID_GpgmeRSet, 0x3811fd43, 0x7f72, 0x11d5,
+ 0x8c, 0x9e, 0x00, 0x80, 0xad, 0x19, 0x0c, 0xd5);
+#endif
+
+DEFINE_GUID(TLBID_Gpgcom, 0x3811fd48, 0x7f72, 0x11d5,
+ 0x8c, 0x9e, 0x00, 0x80, 0xad, 0x19, 0x0c, 0xd5);
+DEFINE_GUID(APPID_Gpgcom, 0x3811fd4f, 0x7f72, 0x11d5,
+ 0x8c, 0x9e, 0x00, 0x80, 0xad, 0x19, 0x0c, 0xd5);
+
+
+DEFINE_GUID(IID_IGpgme, 0x3811fd50, 0x7f72, 0x11d5,
+ 0x8c, 0x9e, 0x00, 0x80, 0xad, 0x19, 0x0c, 0xd5);
+
+typedef struct IGpgme IGpgme;
+
+IClassFactory *igpgme_factory_new( CLSID *r_clsid );
+void igpgme_factory_release ( IClassFactory *factory );
+
+
+/********************************************
+ ***** The IGpgme interface *****************
+ ********************************************/
+
+#define ICOM_INTERFACE IGpgme
+
+#define IGpgme_METHODS \
+ ICOM_METHOD1(HRESULT,GetVersion, BSTR*,) \
+ ICOM_METHOD1(HRESULT,GetEngineInfo, BSTR*,) \
+ ICOM_METHOD(HRESULT,Cancel) \
+ ICOM_METHOD1(HRESULT,SetArmor,BOOL,) \
+ ICOM_METHOD1(HRESULT,GetArmor,BOOL*,) \
+ ICOM_METHOD1(HRESULT,SetTextmode,BOOL,) \
+ ICOM_METHOD1(HRESULT,GetTextmode,BOOL*,) \
+ ICOM_METHOD1(HRESULT,SetPlaintext,VARIANT,) \
+ ICOM_METHOD1(HRESULT,GetPlaintext,VARIANT*,) \
+ ICOM_METHOD1(HRESULT,SetCiphertext,VARIANT,) \
+ ICOM_METHOD1(HRESULT,GetCiphertext,VARIANT*,) \
+ ICOM_METHOD(HRESULT,ClearRecipients) \
+ ICOM_METHOD2(HRESULT,AddRecipient,BSTR,,signed short int,) \
+ ICOM_METHOD(HRESULT,ResetSignKeys) \
+ ICOM_METHOD1(HRESULT,AddSignKey,BSTR,) \
+ ICOM_METHOD(HRESULT,Encrypt) \
+ ICOM_METHOD1(HRESULT,Sign,signed short int,) \
+ ICOM_METHOD1(HRESULT,SignEncrypt,signed short int,)
+
+#if 0
+ ICOM_METHOD1(HRESULT,SetKeylistMode,)
+ ICOM_METHOD1(HRESULT,SetPassphraseCB,)
+ ICOM_METHOD1(HRESULT,SetProgressCB,)
+ ICOM_METHOD1(HRESULT,SignersClear,)
+ ICOM_METHOD1(HRESULT,SignersAdd,)
+ ICOM_METHOD1(HRESULT,SignersEnum,)
+ ICOM_METHOD1(HRESULT,GetSigStatus,)
+ ICOM_METHOD1(HRESULT,GetNotation,)
+#endif
+
+#define IGpgme_IMETHODS \
+ IDispatch_IMETHODS \
+ IGpgme_METHODS
+
+ICOM_DEFINE(IGpgme,IDispatch)
+#undef ICOM_INTERFACE
+
+
+/*** IUnknown methods ***/
+#define IGpgme_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
+#define IGpgme_AddRef(p) ICOM_CALL (AddRef,p)
+#define IGpgme_Release(p) ICOM_CALL (Release,p)
+/*** IGpgme methods ***/
+#define IGpgme_GetVersion(p,r) ICOM_CALL1(GetVersion,p,r)
+#define IGpgme_GetEngineInfo(p,r) ICOM_CALL1(GetEngineInfo,p,r)
+#define IGpgme_Cancel(p,a) ICOM_CALL1(Cancel,p,a)
+#define IGpgme_SetArmor(p,a) ICOM_CALL1(SetArmor,p,a)
+#define IGpgme_GetArmor(p,a) ICOM_CALL1(GetArmor,p,a)
+#define IGpgme_SetTextmode(p,a) ICOM_CALL1(SetTextmode,p,a)
+#define IGpgme_GetTextmode(p,a) ICOM_CALL1(GetTextmode,p,a)
+#define IGpgme_SetPlaintext(p,a) ICOM_CALL1(SetPlaintext,p,a)
+#define IGpgme_GetPlaintext(p,a) ICOM_CALL1(GetPlaintext,p,a)
+#define IGpgme_SetCiphertext(p,a) ICOM_CALL1(SetCiphertext,p,a)
+#define IGpgme_GetCiphertext(p,a) ICOM_CALL1(GetCiphertext,p,a)
+#define IGpgme_ClearRecipients(p) ICOM_CALL (ClearRecipients,p)
+#define IGpgme_AddRecipient(p,a,b) ICOM_CALL2(AddRecipient,p,a,b)
+#define IGpgme_ResetSignKeys(p) ICOM_CALL (ResetSignKeys,p)
+#define IGpgme_AddSignKey(p,a) ICOM_CALL (AddSignKey,p,a)
+#define IGpgme_Encrypt(p) ICOM_CALL (Encrypt,p)
+#define IGpgme_Sign(p,a) ICOM_CALL (Sign,p,a)
+#define IGpgme_SignEncrypt(p,a) ICOM_CALL (SignEncrypt,p,a)
+#if 0
+#define IGpgme_SetKeylistMode(p,a) ICOM_CALL1(SetKeylistMode,p,a)
+#define IGpgme_SetPassphraseCB(p,a) ICOM_CALL1(SetPassphraseCB,p,a)
+#define IGpgme_SetProgressCB(p,a) ICOM_CALL1(SetProgressCB,p,a)
+#define IGpgme_SignersClear(p,a) ICOM_CALL1(SignersClear,p,a)
+#define IGpgme_SignersAdd(p,a) ICOM_CALL1(SignersAdd,p,a)
+#define IGpgme_SignersEnum(p,a) ICOM_CALL1(SignersEnum,p,a)
+#define IGpgme_GetSigStatus(p,a) ICOM_CALL1(GetSigStatus,p,a)
+#define IGpgme_GetSigKey(p,a) ICOM_CALL1(GetSigKey,p,a)
+#define IGpgme_GetNotation(p,a) ICOM_CALL1(GetNotation,p,a)
+#endif
+
+
+#if 0
+/********************************************
+ ***** The IGpgmeKey interface **************
+ ********************************************/
+
+#define ICOM_INTERFACE IGpgmeKey
+
+#define IGpgmeKey_METHODS \
+ ICOM_METHOD1(HRESULT,GetVersion, BSTR,) \
+ ICOM_METHOD1(HRESULT,GetEngineInfo, BSTR,)
+
+
+#define IGpgmeKey_IMETHODS \
+ IUnknown_IMETHODS \
+ IGpgmeKey_METHODS
+
+ICOM_DEFINE(IGpgmeKey,IUnknown)
+#undef ICOM_INTERFACE
+
+/*** IUnknown methods ***/
+#define IGpgmeKey_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
+#define IGpgmeKey_AddRef(p) ICOM_CALL (AddRef,p)
+#define IGpgmeKey_Release(p) ICOM_CALL (Release,p)
+/*** IGpgmeKey methods ***/
+#define IGpgmeKey_GetVersion(p,r) ICOM_CALL1(GetVersion,p,r)
+#define IGpgmeKey_GetEngineInfo(p,r) ICOM_CALL1(GetEngineInfo,p,r)
+#endif
+
+#endif /*IGPGME_H*/
+
+++ /dev/null
-/* main.c - COM+ component to access GnuPG
- * Copyright (C) 2000 Werner Koch (dd9jn)
- *
- * This file is part of GPGME.
- *
- * GPGME is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <assert.h>
-#include <time.h>
-#include <windows.h>
-
-#include "obj_base.h"
-
-#include "argparse.h"
-
-#include "main.h"
-
-
-static void register_server (void);
-static void unregister_server (void);
-static void enter_complus (void);
-
-
-enum cmd_and_opt_values { aNull = 0,
- oQuiet = 'q',
- oVerbose = 'v',
-
- oNoVerbose = 500,
- oOptions,
- oDebug,
- oDebugAll,
- oNoGreeting,
- oNoOptions,
- oHomedir,
- oGPGBinary,
- oRegServer,
- oUnregServer,
- oEmbedding,
-aTest };
-
-
-static ARGPARSE_OPTS opts[] = {
-
- { 301, NULL, 0, N_("@Options:\n ") },
-
- { oVerbose, "verbose", 0, N_("verbose") },
- { oQuiet, "quiet", 0, N_("be somewhat more quiet") },
- { oOptions, "options" , 2, N_("read options from file")},
- { oDebug, "debug" ,4|16, N_("set debugging flags")},
- { oDebugAll, "debug-all" ,0, N_("enable full debugging")},
- { oGPGBinary, "gpg-program", 2 , "@" },
- { oRegServer, "RegServer" , 0, "@" },
- { oUnregServer, "UnregServer" , 0, "@" },
- { oEmbedding, "Embedding" , 0, "@" },
-{0} };
-
-
-
-
-static const char *
-my_strusage( int level )
-{
- const char *p;
- switch( level ) {
- case 11: p = "gpgme";
- break;
- case 13: p = VERSION; break;
- /*case 17: p = PRINTABLE_OS_NAME; break;*/
- case 19: p =
- _("Please report bugs to <gpgme-bugs@gnupg.org>.\n");
- break;
- case 1:
- case 40: p =
- _("Usage: gpgme [options] (-h for help)");
- break;
- case 41: p =
- _("Syntax: gpgme [options]\n"
- "GnuPG COM+ component\n");
- break;
-
- default: p = NULL;
- }
- return p;
-}
-
-
-int
-main (int argc, char **argv )
-{
- ARGPARSE_ARGS pargs;
- int orig_argc;
- char **orig_argv;
- FILE *configfp = NULL;
- char *configname = NULL;
- unsigned configlineno;
- int parse_debug = 0;
- int default_config =1;
- int greeting = 0;
- int nogreeting = 0;
- int action = 0;
-
- set_strusage( my_strusage );
- /*log_set_name ("gpa"); not yet implemented in logging.c */
-
- opt.homedir = getenv("GNUPGHOME");
- if( !opt.homedir || !*opt.homedir ) {
- #ifdef HAVE_DRIVE_LETTERS
- opt.homedir = "c:/gnupg";
- #else
- opt.homedir = "~/.gnupg";
- #endif
- }
-
- /* check whether we have a config file on the commandline */
- orig_argc = argc;
- orig_argv = argv;
- pargs.argc = &argc;
- pargs.argv = &argv;
- pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */
- while( arg_parse( &pargs, opts) ) {
- if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
- parse_debug++;
- else if( pargs.r_opt == oOptions ) {
- /* yes there is one, so we do not try the default one, but
- * read the option file when it is encountered at the commandline
- */
- default_config = 0;
- }
- else if( pargs.r_opt == oNoOptions )
- default_config = 0; /* --no-options */
- else if( pargs.r_opt == oHomedir )
- opt.homedir = pargs.r.ret_str;
- }
-
- if( default_config )
- configname = make_filename(opt.homedir, "gpgme.conf", NULL );
-
-
- argc = orig_argc;
- argv = orig_argv;
- pargs.argc = &argc;
- pargs.argv = &argv;
- pargs.flags= 1 | (1<<5); /* do not remove the args, allow one dash */
- next_pass:
- if( configname ) {
- configlineno = 0;
- configfp = fopen( configname, "r" );
- if( !configfp ) {
- if( default_config ) {
- if( parse_debug )
- log_info(_("NOTE: no default option file `%s'\n"),
- configname );
- }
- else {
- log_error(_("option file `%s': %s\n"),
- configname, strerror(errno) );
- exit(2);
- }
- free(configname); configname = NULL;
- }
- if( parse_debug && configname )
- log_info(_("reading options from `%s'\n"), configname );
- default_config = 0;
- }
-
- while( optfile_parse( configfp, configname, &configlineno,
- &pargs, opts) ) {
- switch( pargs.r_opt ) {
- case oQuiet: opt.quiet = 1; break;
- case oVerbose: opt.verbose++; break;
-
- case oDebug: opt.debug |= pargs.r.ret_ulong; break;
- case oDebugAll: opt.debug = ~0; break;
-
- case oOptions:
- /* config files may not be nested (silently ignore them) */
- if( !configfp ) {
- free(configname);
- configname = xstrdup(pargs.r.ret_str);
- goto next_pass;
- }
- break;
- case oNoGreeting: nogreeting = 1; break;
- case oNoVerbose: opt.verbose = 0; break;
- case oNoOptions: break; /* no-options */
- case oHomedir: opt.homedir = pargs.r.ret_str; break;
- case oGPGBinary: break;
-
- case oRegServer: action = 1; break;
- case oUnregServer: action = 2; break;
- case oEmbedding: action = 3; break;
-
- default : pargs.err = configfp? 1:2; break;
- }
- }
- if( configfp ) {
- fclose( configfp );
- configfp = NULL;
- free(configname); configname = NULL;
- goto next_pass;
- }
- free( configname ); configname = NULL;
- if( log_get_errorcount(0) )
- exit(2);
- if( nogreeting )
- greeting = 0;
-
- if( greeting ) {
- fprintf(stderr, "%s %s; %s\n",
- strusage(11), strusage(13), strusage(14) );
- fprintf(stderr, "%s\n", strusage(15) );
- }
- #ifdef IS_DEVELOPMENT_VERSION
- log_info("NOTE: this is a development version!\n");
- #endif
-
- if ( action == 1 )
- register_server ();
- else if (action == 2 )
- unregister_server ();
- else if (action == 3 )
- enter_complus ();
- else {
- fprintf (stderr, "This is a COM+ component with no user interface.\n"
- "gpgme --help will give you a list of options\n" );
- exit (1);
- }
-
- return 0;
-}
-
-static void
-register_server ()
-{
-}
-
-static void
-unregister_server ()
-{
-}
-
-static void
-enter_complus ()
-{
- HANDLE running;
- int reg;
- IClassFactory *factory;
- CLSID clsid;
-
- CoInitializeEx (NULL, COINIT_MULTITHREADED);
- running = CreateEvent (NULL, FALSE, FALSE, NULL );
-
- factory = gnupg_factory_new ( &clsid );
- CoRegisterClassObject (&clsid, (IUnknown*)factory,
- CLSCTX_LOCAL_SERVER,
- REGCLS_SUSPENDED|REGCLS_MULTIPLEUSE, ® );
- CoResumeClassObjects ();
-
- WaitForSingleObject ( running, INFINITE );
- CloseHandle (running);
- CoRevokeClassObject ( reg );
- gnupg_factory_release (factory);
- CoUninitialize ();
-}
-
-
} opt;
-/*-- ignupg.c --*/
-IClassFactory *gnupg_factory_new ( CLSID *r_clsid );
-void gnupg_factory_release ( IClassFactory *factory );
-
-
#endif /* COMPLUS_MAIN_H */
+++ /dev/null
-/* obj_base.h - This file defines the macros and types necessary to
- define COM interfaces, and the three most basic COM interfaces:
- IUnknown, IMalloc and IClassFactory.
-
- Copyright (c) 1993-2000 the Wine project authors (see the file WINE-AUTHORS
- for a complete list)
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef __WINE_WINE_OBJ_BASE_H
-#define __WINE_WINE_OBJ_BASE_H
-
-/* check these values! */
-#define E_NOINTERFACE 0x80040002
-#define E_OUTOFMEMORY 0x8007000E
-
-/*****************************************************************************
- * define ICOM_MSVTABLE_COMPAT
- * to implement the microsoft com vtable compatibility workaround for g++.
- *
- * NOTE: Turning this option on will produce a winelib that is incompatible
- * with the binary emulator.
- *
- * If the compiler supports the com_interface attribute, leave this off, and
- * define the ICOM_USE_COM_INTERFACE_ATTRIBUTE macro below. This may also
- * require the addition of the -vtable-thunks option for g++.
- *
- * If you aren't interested in Winelib C++ compatibility at all, leave both
- * options off.
- *
- * The preferable method for using ICOM_USE_COM_INTERFACE_ATTRIBUTE macro
- * would be to define it only for your Winelib application. This allows you
- * to have both binary and Winelib compatibility for C and C++ at the same
- * time :)
- */
-/* #define ICOM_MSVTABLE_COMPAT 1 */
-/* #define ICOM_USE_COM_INTERFACE_ATTRIBUTE 1 */
-
-/*****************************************************************************
- * Defines the basic types
- */
-#include "wtypes.h"
-#include "guiddef.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#ifndef NONAMELESSSTRUCT
-#define LISet32(li, v) ((li).HighPart = (v) < 0 ? -1 : 0, (li).LowPart = (v))
-#define ULISet32(li, v) ((li).HighPart = 0, (li).LowPart = (v))
-#else
-#define LISet32(li, v) ((li).s.HighPart = (v) < 0 ? -1 : 0, (li).s.LowPart = (v))
-#define ULISet32(li, v) ((li).s.HighPart = 0, (li).s.LowPart = (v))
-#endif
-
-/*****************************************************************************
- * GUID API
- */
-HRESULT WINAPI StringFromCLSID16(REFCLSID id, LPOLESTR16*);
-HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR*);
-
-HRESULT WINAPI CLSIDFromString16(LPCOLESTR16, CLSID *);
-HRESULT WINAPI CLSIDFromString(LPCOLESTR, CLSID *);
-
-HRESULT WINAPI CLSIDFromProgID16(LPCOLESTR16 progid, LPCLSID riid);
-HRESULT WINAPI CLSIDFromProgID(LPCOLESTR progid, LPCLSID riid);
-
-HRESULT WINAPI ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *lplpszProgID);
-
-
-INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax);
-
-
-/*****************************************************************************
- * Macros to define a COM interface
- */
-/*
- * The goal of the following set of definitions is to provide a way to use the same
- * header file definitions to provide both a C interface and a C++ object oriented
- * interface to COM interfaces. The type of interface is selected automatically
- * depending on the language but it is always possible to get the C interface in C++
- * by defining CINTERFACE.
- *
- * It is based on the following assumptions:
- * - all COM interfaces derive from IUnknown, this should not be a problem.
- * - the header file only defines the interface, the actual fields are defined
- * separately in the C file implementing the interface.
- *
- * The natural approach to this problem would be to make sure we get a C++ class and
- * virtual methods in C++ and a structure with a table of pointer to functions in C.
- * Unfortunately the layout of the virtual table is compiler specific, the layout of
- * g++ virtual tables is not the same as that of an egcs virtual table which is not the
- * same as that generated by Visual C+. There are workarounds to make the virtual tables
- * compatible via padding but unfortunately the one which is imposed to the WINE emulator
- * by the Windows binaries, i.e. the Visual C++ one, is the most compact of all.
- *
- * So the solution I finally adopted does not use virtual tables. Instead I use inline
- * non virtual methods that dereference the method pointer themselves and perform the call.
- *
- * Let's take Direct3D as an example:
- *
- * #define ICOM_INTERFACE IDirect3D
- * #define IDirect3D_METHODS \
- * ICOM_METHOD1(HRESULT,Initialize, REFIID,) \
- * ICOM_METHOD2(HRESULT,EnumDevices, LPD3DENUMDEVICESCALLBACK,, LPVOID,) \
- * ICOM_METHOD2(HRESULT,CreateLight, LPDIRECT3DLIGHT*,, IUnknown*,) \
- * ICOM_METHOD2(HRESULT,CreateMaterial,LPDIRECT3DMATERIAL*,, IUnknown*,) \
- * ICOM_METHOD2(HRESULT,CreateViewport,LPDIRECT3DVIEWPORT*,, IUnknown*,) \
- * ICOM_METHOD2(HRESULT,FindDevice, LPD3DFINDDEVICESEARCH,, LPD3DFINDDEVICERESULT,)
- * #define IDirect3D_IMETHODS \
- * IUnknown_IMETHODS \
- * IDirect3D_METHODS
- * ICOM_DEFINE(IDirect3D,IUnknown)
- * #undef ICOM_INTERFACE
- *
- * #ifdef ICOM_CINTERFACE
- * // *** IUnknown methods *** //
- * #define IDirect3D_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
- * #define IDirect3D_AddRef(p) ICOM_CALL (AddRef,p)
- * #define IDirect3D_Release(p) ICOM_CALL (Release,p)
- * // *** IDirect3D methods *** //
- * #define IDirect3D_Initialize(p,a) ICOM_CALL1(Initialize,p,a)
- * #define IDirect3D_EnumDevices(p,a,b) ICOM_CALL2(EnumDevice,p,a,b)
- * #define IDirect3D_CreateLight(p,a,b) ICOM_CALL2(CreateLight,p,a,b)
- * #define IDirect3D_CreateMaterial(p,a,b) ICOM_CALL2(CreateMaterial,p,a,b)
- * #define IDirect3D_CreateViewport(p,a,b) ICOM_CALL2(CreateViewport,p,a,b)
- * #define IDirect3D_FindDevice(p,a,b) ICOM_CALL2(FindDevice,p,a,b)
- * #endif
- *
- * Comments:
- * - The ICOM_INTERFACE macro is used in the ICOM_METHOD macros to define the type of the 'this'
- * pointer. Defining this macro here saves us the trouble of having to repeat the interface
- * name everywhere. Note however that because of the way macros work, a macro like ICOM_METHOD1
- * cannot use 'ICOM_INTERFACE##_VTABLE' because this would give 'ICOM_INTERFACE_VTABLE' and not
- * 'IDirect3D_VTABLE'.
- * - ICOM_METHODS defines the methods specific to this interface. It is then aggregated with the
- * inherited methods to form ICOM_IMETHODS.
- * - ICOM_IMETHODS defines the list of methods that are inheritable from this interface. It must
- * be written manually (rather than using a macro to generate the equivalent code) to avoid
- * macro recursion (which compilers don't like).
- * - The ICOM_DEFINE finally declares all the structures necessary for the interface. We have to
- * explicitly use the interface name for macro expansion reasons again.
- * Inherited methods are inherited in C by using the IDirect3D_METHODS macro and the parent's
- * Xxx_IMETHODS macro. In C++ we need only use the IDirect3D_METHODS since method inheritance
- * is taken care of by the language.
- * - In C++ the ICOM_METHOD macros generate a function prototype and a call to a function pointer
- * method. This means using once 't1 p1, t2 p2, ...' and once 'p1, p2' without the types. The
- * only way I found to handle this is to have one ICOM_METHOD macro per number of parameters and
- * to have it take only the type information (with const if necessary) as parameters.
- * The 'undef ICOM_INTERFACE' is here to remind you that using ICOM_INTERFACE in the following
- * macros will not work. This time it's because the ICOM_CALL macro expansion is done only once
- * the 'IDirect3D_Xxx' macro is expanded. And by that time ICOM_INTERFACE will be long gone
- * anyway.
- * - You may have noticed the double commas after each parameter type. This allows you to put the
- * name of that parameter which I think is good for documentation. It is not required and since
- * I did not know what to put there for this example (I could only find doc about IDirect3D2),
- * I left them blank.
- * - Finally the set of 'IDirect3D_Xxx' macros is a standard set of macros defined to ease access
- * to the interface methods in C. Unfortunately I don't see any way to avoid having to duplicate
- * the inherited method definitions there. This time I could have used a trick to use only one
- * macro whatever the number of parameters but I prefered to have it work the same way as above.
- * - You probably have noticed that we don't define the fields we need to actually implement this
- * interface: reference count, pointer to other resources and miscellaneous fields. That's
- * because these interfaces are just that: interfaces. They may be implemented more than once, in
- * different contexts and sometimes not even in Wine. Thus it would not make sense to impose
- * that the interface contains some specific fields.
- *
- *
- * In C this gives:
- * typedef struct IDirect3DVtbl IDirect3DVtbl;
- * struct IDirect3D {
- * IDirect3DVtbl* lpVtbl;
- * };
- * struct IDirect3DVtbl {
- * HRESULT (*fnQueryInterface)(IDirect3D* me, REFIID riid, LPVOID* ppvObj);
- * ULONG (*fnQueryInterface)(IDirect3D* me);
- * ULONG (*fnQueryInterface)(IDirect3D* me);
- * HRESULT (*fnInitialize)(IDirect3D* me, REFIID a);
- * HRESULT (*fnEnumDevices)(IDirect3D* me, LPD3DENUMDEVICESCALLBACK a, LPVOID b);
- * HRESULT (*fnCreateLight)(IDirect3D* me, LPDIRECT3DLIGHT* a, IUnknown* b);
- * HRESULT (*fnCreateMaterial)(IDirect3D* me, LPDIRECT3DMATERIAL* a, IUnknown* b);
- * HRESULT (*fnCreateViewport)(IDirect3D* me, LPDIRECT3DVIEWPORT* a, IUnknown* b);
- * HRESULT (*fnFindDevice)(IDirect3D* me, LPD3DFINDDEVICESEARCH a, LPD3DFINDDEVICERESULT b);
- * };
- *
- * #ifdef ICOM_CINTERFACE
- * // *** IUnknown methods *** //
- * #define IDirect3D_QueryInterface(p,a,b) (p)->lpVtbl->fnQueryInterface(p,a,b)
- * #define IDirect3D_AddRef(p) (p)->lpVtbl->fnAddRef(p)
- * #define IDirect3D_Release(p) (p)->lpVtbl->fnRelease(p)
- * // *** IDirect3D methods *** //
- * #define IDirect3D_Initialize(p,a) (p)->lpVtbl->fnInitialize(p,a)
- * #define IDirect3D_EnumDevices(p,a,b) (p)->lpVtbl->fnEnumDevice(p,a,b)
- * #define IDirect3D_CreateLight(p,a,b) (p)->lpVtbl->fnCreateLight(p,a,b)
- * #define IDirect3D_CreateMaterial(p,a,b) (p)->lpVtbl->fnCreateMaterial(p,a,b)
- * #define IDirect3D_CreateViewport(p,a,b) (p)->lpVtbl->fnCreateViewport(p,a,b)
- * #define IDirect3D_FindDevice(p,a,b) (p)->lpVtbl->fnFindDevice(p,a,b)
- * #endif
- *
- * Comments:
- * - IDirect3D only contains a pointer to the IDirect3D virtual/jump table. This is the only thing
- * the user needs to know to use the interface. Of course the structure we will define to
- * implement this interface will have more fields but the first one will match this pointer.
- * - The code generated by ICOM_DEFINE defines both the structure representing the interface and
- * the structure for the jump table. ICOM_DEFINE uses the parent's Xxx_IMETHODS macro to
- * automatically repeat the prototypes of all the inherited methods and then uses IDirect3D_METHODS
- * to define the IDirect3D methods.
- * - Each method is declared as a pointer to function field in the jump table. The implementation
- * will fill this jump table with appropriate values, probably using a static variable, and
- * initialize the lpVtbl field to point to this variable.
- * - The IDirect3D_Xxx macros then just derefence the lpVtbl pointer and use the function pointer
- * corresponding to the macro name. This emulates the behavior of a virtual table and should be
- * just as fast.
- * - This C code should be quite compatible with the Windows headers both for code that uses COM
- * interfaces and for code implementing a COM interface.
- *
- *
- * And in C++ (with gcc's g++):
- *
- * typedef struct IDirect3D: public IUnknown {
- * private: HRESULT (*fnInitialize)(IDirect3D* me, REFIID a);
- * public: inline HRESULT Initialize(REFIID a) { return ((IDirect3D*)t.lpVtbl)->fnInitialize(this,a); };
- * private: HRESULT (*fnEnumDevices)(IDirect3D* me, LPD3DENUMDEVICESCALLBACK a, LPVOID b);
- * public: inline HRESULT EnumDevices(LPD3DENUMDEVICESCALLBACK a, LPVOID b)
- * { return ((IDirect3D*)t.lpVtbl)->fnEnumDevices(this,a,b); };
- * private: HRESULT (*fnCreateLight)(IDirect3D* me, LPDIRECT3DLIGHT* a, IUnknown* b);
- * public: inline HRESULT CreateLight(LPDIRECT3DLIGHT* a, IUnknown* b)
- * { return ((IDirect3D*)t.lpVtbl)->fnCreateLight(this,a,b); };
- * private: HRESULT (*fnCreateMaterial)(IDirect3D* me, LPDIRECT3DMATERIAL* a, IUnknown* b);
- * public: inline HRESULT CreateMaterial(LPDIRECT3DMATERIAL* a, IUnknown* b)
- * { return ((IDirect3D*)t.lpVtbl)->fnCreateMaterial(this,a,b); };
- * private: HRESULT (*fnCreateViewport)(IDirect3D* me, LPDIRECT3DVIEWPORT* a, IUnknown* b);
- * public: inline HRESULT CreateViewport(LPDIRECT3DVIEWPORT* a, IUnknown* b)
- * { return ((IDirect3D*)t.lpVtbl)->fnCreateViewport(this,a,b); };
- * private: HRESULT (*fnFindDevice)(IDirect3D* me, LPD3DFINDDEVICESEARCH a, LPD3DFINDDEVICERESULT b);
- * public: inline HRESULT FindDevice(LPD3DFINDDEVICESEARCH a, LPD3DFINDDEVICERESULT b)
- * { return ((IDirect3D*)t.lpVtbl)->fnFindDevice(this,a,b); };
- * };
- *
- * Comments:
- * - In C++ IDirect3D does double duty as both the virtual/jump table and as the interface
- * definition. The reason for this is to avoid having to duplicate the mehod definitions: once
- * to have the function pointers in the jump table and once to have the methods in the interface
- * class. Here one macro can generate both. This means though that the first pointer, t.lpVtbl
- * defined in IUnknown, must be interpreted as the jump table pointer if we interpret the
- * structure as the the interface class, and as the function pointer to the QueryInterface
- * method, t.fnQueryInterface, if we interpret the structure as the jump table. Fortunately this
- * gymnastic is entirely taken care of in the header of IUnknown.
- * - Of course in C++ we use inheritance so that we don't have to duplicate the method definitions.
- * - Since IDirect3D does double duty, each ICOM_METHOD macro defines both a function pointer and
- * a non-vritual inline method which dereferences it and calls it. This way this method behaves
- * just like a virtual method but does not create a true C++ virtual table which would break the
- * structure layout. If you look at the implementation of these methods you'll notice that they
- * would not work for void functions. We have to return something and fortunately this seems to
- * be what all the COM methods do (otherwise we would need another set of macros).
- * - Note how the ICOM_METHOD generates both function prototypes mixing types and formal parameter
- * names and the method invocation using only the formal parameter name. This is the reason why
- * we need different macros to handle different numbers of parameters.
- * - Finally there is no IDirect3D_Xxx macro. These are not needed in C++ unless the CINTERFACE
- * macro is defined in which case we would not be here.
- * - This C++ code works well for code that just uses COM interfaces. But it will not work with
- * C++ code implement a COM interface. That's because such code assumes the interface methods
- * are declared as virtual C++ methods which is not the case here.
- *
- *
- * Implementing a COM interface.
- *
- * This continues the above example. This example assumes that the implementation is in C.
- *
- * typedef struct _IDirect3D {
- * void* lpVtbl;
- * // ...
- *
- * } _IDirect3D;
- *
- * static ICOM_VTABLE(IDirect3D) d3dvt;
- *
- * // implement the IDirect3D methods here
- *
- * int IDirect3D_fnQueryInterface(IDirect3D* me)
- * {
- * ICOM_THIS(IDirect3D,me);
- * // ...
- * }
- *
- * // ...
- *
- * static ICOM_VTABLE(IDirect3D) d3dvt = {
- * ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
- * IDirect3D_fnQueryInterface,
- * IDirect3D_fnAdd,
- * IDirect3D_fnAdd2,
- * IDirect3D_fnInitialize,
- * IDirect3D_fnSetWidth
- * };
- *
- * Comments:
- * - We first define what the interface really contains. This is th e_IDirect3D structure. The
- * first field must of course be the virtual table pointer. Everything else is free.
- * - Then we predeclare our static virtual table variable, we will need its address in some
- * methods to initialize the virtual table pointer of the returned interface objects.
- * - Then we implement the interface methods. To match what has been declared in the header file
- * they must take a pointer to a IDirect3D structure and we must cast it to an _IDirect3D so that
- * we can manipulate the fields. This is performed by the ICOM_THIS macro.
- * - Finally we initialize the virtual table.
- */
-
-
-#define ICOM_VTABLE(iface) iface##Vtbl
-#define ICOM_VFIELD(iface) ICOM_VTABLE(iface)* lpVtbl
-#define ICOM_VTBL(iface) (iface)->lpVtbl
-
-
-#if !defined(__cplusplus) || defined(CINTERFACE)
-#define ICOM_CINTERFACE 1
-#endif
-
-#ifndef ICOM_CINTERFACE
-/* C++ interface */
-
-#define ICOM_METHOD(ret,xfn) \
- public: virtual ret CALLBACK (xfn)(void) = 0;
-#define ICOM_METHOD1(ret,xfn,ta,na) \
- public: virtual ret CALLBACK (xfn)(ta a) = 0;
-#define ICOM_METHOD2(ret,xfn,ta,na,tb,nb) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b) = 0;
-#define ICOM_METHOD3(ret,xfn,ta,na,tb,nb,tc,nc) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c) = 0;
-#define ICOM_METHOD4(ret,xfn,ta,na,tb,nb,tc,nc,td,nd) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d) = 0;
-#define ICOM_METHOD5(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e) = 0;
-#define ICOM_METHOD6(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f) = 0;
-#define ICOM_METHOD7(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g) = 0;
-#define ICOM_METHOD8(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h) = 0;
-#define ICOM_METHOD9(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i) = 0;
-#define ICOM_METHOD10(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j) = 0;
-#define ICOM_METHOD11(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk) \
- public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k) = 0;
-
-
-#define ICOM_VMETHOD(xfn) \
- public: virtual void CALLBACK (xfn)(void) = 0;
-#define ICOM_VMETHOD1(xfn,ta,na) \
- public: virtual void CALLBACK (xfn)(ta a) = 0;
-#define ICOM_VMETHOD2(xfn,ta,na,tb,nb) \
- public: virtual void CALLBACK (xfn)(ta a,tb b) = 0;
-#define ICOM_VMETHOD3(xfn,ta,na,tb,nb,tc,nc) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c) = 0;
-#define ICOM_VMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d) = 0;
-#define ICOM_VMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e) = 0;
-#define ICOM_VMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f) = 0;
-#define ICOM_VMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g) = 0;
-#define ICOM_VMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h) = 0;
-#define ICOM_VMETHOD9(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i) = 0;
-#define ICOM_VMETHOD10(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i, tj j) = 0;
-#define ICOM_VMETHOD11(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk) \
- public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i, tj j, tk k) = 0;
-
-
-#ifdef ICOM_USE_COM_INTERFACE_ATTRIBUTE
-
-#define ICOM_DEFINE(iface,ibase) \
- typedef struct iface: public ibase { \
- iface##_METHODS \
- } __attribute__ ((com_interface));
-
-#else
-
-#define ICOM_DEFINE(iface,ibase) \
- typedef struct iface: public ibase { \
- iface##_METHODS \
- };
-
-#endif /* ICOM_USE_COM_INTERFACE_ATTRIBUTE */
-
-#define ICOM_CALL(xfn, p) (p)->xfn()
-#define ICOM_CALL1(xfn, p,a) (p)->xfn(a)
-#define ICOM_CALL2(xfn, p,a,b) (p)->xfn(a,b)
-#define ICOM_CALL3(xfn, p,a,b,c) (p)->xfn(a,b,c)
-#define ICOM_CALL4(xfn, p,a,b,c,d) (p)->xfn(a,b,c,d)
-#define ICOM_CALL5(xfn, p,a,b,c,d,e) (p)->xfn(a,b,c,d,e)
-#define ICOM_CALL6(xfn, p,a,b,c,d,e,f) (p)->xfn(a,b,c,d,e,f)
-#define ICOM_CALL7(xfn, p,a,b,c,d,e,f,g) (p)->xfn(a,b,c,d,e,f,g)
-#define ICOM_CALL8(xfn, p,a,b,c,d,e,f,g,h) (p)->xfn(a,b,c,d,e,f,g,h)
-#define ICOM_CALL9(xfn, p,a,b,c,d,e,f,g,h,i) (p)->xfn(a,b,c,d,e,f,g,h,i)
-#define ICOM_CALL10(xfn, p,a,b,c,d,e,f,g,h,i,j) (p)->xfn(a,b,c,d,e,f,g,h,i,j)
-#define ICOM_CALL11(xfn, p,a,b,c,d,e,f,g,h,i,j,k) (p)->xfn(a,b,c,d,e,f,g,h,i,j,k)
-
-
-#else
-/* C interface */
-
-
-#ifdef __WINE__
-
-#define ICOM_METHOD(ret,xfn) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me);
-#define ICOM_METHOD1(ret,xfn,ta,na) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a);
-#define ICOM_METHOD2(ret,xfn,ta,na,tb,nb) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b);
-#define ICOM_METHOD3(ret,xfn,ta,na,tb,nb,tc,nc) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
-#define ICOM_METHOD4(ret,xfn,ta,na,tb,nb,tc,nc,td,nd) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
-#define ICOM_METHOD5(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
-#define ICOM_METHOD6(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
-#define ICOM_METHOD7(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
-#define ICOM_METHOD8(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
-#define ICOM_METHOD9(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
-#define ICOM_METHOD10(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
-#define ICOM_METHOD11(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk) \
- ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
-
-#define ICOM_VMETHOD(xfn) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me);
-#define ICOM_VMETHOD1(xfn,ta,na) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a);
-#define ICOM_VMETHOD2(xfn,ta,na,tb,nb) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b);
-#define ICOM_VMETHOD3(xfn,ta,na,tb,nb,tc,nc) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
-#define ICOM_VMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
-#define ICOM_VMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
-#define ICOM_VMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
-#define ICOM_VMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
-#define ICOM_VMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,nh) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
-#define ICOM_VMETHOD9(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ni) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
-#define ICOM_VMETHOD10(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,nj) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
-#define ICOM_VMETHOD11(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,nk) \
- void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
-
-#define ICOM_CALL(xfn, p) ICOM_VTBL(p)->fn##xfn(p)
-#define ICOM_CALL1(xfn, p,a) ICOM_VTBL(p)->fn##xfn(p,a)
-#define ICOM_CALL2(xfn, p,a,b) ICOM_VTBL(p)->fn##xfn(p,a,b)
-#define ICOM_CALL3(xfn, p,a,b,c) ICOM_VTBL(p)->fn##xfn(p,a,b,c)
-#define ICOM_CALL4(xfn, p,a,b,c,d) ICOM_VTBL(p)->fn##xfn(p,a,b,c,d)
-#define ICOM_CALL5(xfn, p,a,b,c,d,e) ICOM_VTBL(p)->fn##xfn(p,a,b,c,d,e)
-#define ICOM_CALL6(xfn, p,a,b,c,d,e,f) ICOM_VTBL(p)->fn##xfn(p,a,b,c,d,e,f)
-#define ICOM_CALL7(xfn, p,a,b,c,d,e,f,g) ICOM_VTBL(p)->fn##xfn(p,a,b,c,d,e,f,g)
-#define ICOM_CALL8(xfn, p,a,b,c,d,e,f,g,h) ICOM_VTBL(p)->fn##xfn(p,a,b,c,d,e,f,g,h)
-#define ICOM_CALL9(xfn, p,a,b,c,d,e,f,g,h,i) ICOM_VTBL(p)->fn##xfn(p,a,b,c,d,e,f,g,h,i)
-#define ICOM_CALL10(xfn, p,a,b,c,d,e,f,g,h,i,j) ICOM_VTBL(p)->fn##xfn(p,a,b,c,d,e,f,g,h,i,j)
-#define ICOM_CALL11(xfn, p,a,b,c,d,e,f,g,h,i,j,k) ICOM_VTBL(p)->fn##xfn(p,a,b,c,d,e,f,g,h,i,j,k)
-
-#else
-
-/* WINELIB case */
-
-#define ICOM_METHOD(ret,xfn) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me);
-#define ICOM_METHOD1(ret,xfn,ta,na) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a);
-#define ICOM_METHOD2(ret,xfn,ta,na,tb,nb) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b);
-#define ICOM_METHOD3(ret,xfn,ta,na,tb,nb,tc,nc) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
-#define ICOM_METHOD4(ret,xfn,ta,na,tb,nb,tc,nc,td,nd) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
-#define ICOM_METHOD5(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
-#define ICOM_METHOD6(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
-#define ICOM_METHOD7(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
-#define ICOM_METHOD8(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
-#define ICOM_METHOD9(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
-#define ICOM_METHOD10(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
-#define ICOM_METHOD11(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk) \
- ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
-
-#define ICOM_VMETHOD(xfn) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me);
-#define ICOM_VMETHOD1(xfn,ta,na) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a);
-#define ICOM_VMETHOD2(xfn,ta,na,tb,nb) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b);
-#define ICOM_VMETHOD3(xfn,ta,na,tb,nb,tc,nc) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
-#define ICOM_VMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
-#define ICOM_VMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
-#define ICOM_VMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
-#define ICOM_VMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
-#define ICOM_VMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,nh) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
-#define ICOM_VMETHOD9(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ni) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
-#define ICOM_VMETHOD10(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,nj) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
-#define ICOM_VMETHOD11(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,nk) \
- void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
-
-#define ICOM_CVMETHOD(xfn) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me);
-#define ICOM_CVMETHOD1(xfn,ta,na) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a);
-#define ICOM_CVMETHOD2(xfn,ta,na,tb,nb) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b);
-#define ICOM_CVMETHOD3(xfn,ta,na,tb,nb,tc,nc) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c);
-#define ICOM_CVMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
-#define ICOM_CVMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
-#define ICOM_CVMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
-#define ICOM_CVMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
-#define ICOM_CVMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
-
-#define ICOM_CVMETHOD9(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
-#define ICOM_CVMETHOD10(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
-#define ICOM_CVMETHOD11(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk) \
- void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
-
-#define ICOM_CALL(xfn, p) ICOM_VTBL(p)->xfn(p)
-#define ICOM_CALL1(xfn, p,a) ICOM_VTBL(p)->xfn(p,a)
-#define ICOM_CALL2(xfn, p,a,b) ICOM_VTBL(p)->xfn(p,a,b)
-#define ICOM_CALL3(xfn, p,a,b,c) ICOM_VTBL(p)->xfn(p,a,b,c)
-#define ICOM_CALL4(xfn, p,a,b,c,d) ICOM_VTBL(p)->xfn(p,a,b,c,d)
-#define ICOM_CALL5(xfn, p,a,b,c,d,e) ICOM_VTBL(p)->xfn(p,a,b,c,d,e)
-#define ICOM_CALL6(xfn, p,a,b,c,d,e,f) ICOM_VTBL(p)->xfn(p,a,b,c,d,e,f)
-#define ICOM_CALL7(xfn, p,a,b,c,d,e,f,g) ICOM_VTBL(p)->xfn(p,a,b,c,d,e,f,g)
-#define ICOM_CALL8(xfn, p,a,b,c,d,e,f,g,h) ICOM_VTBL(p)->xfn(p,a,b,c,d,e,f,g,h)
-#define ICOM_CALL9(xfn, p,a,b,c,d,e,f,g,h,i) ICOM_VTBL(p)->xfn(p,a,b,c,d,e,f,g,h,i)
-#define ICOM_CALL10(xfn, p,a,b,c,d,e,f,g,h,i,j) ICOM_VTBL(p)->xfn(p,a,b,c,d,e,f,g,h,i,j)
-#define ICOM_CALL11(xfn, p,a,b,c,d,e,f,g,h,i,j,k) ICOM_VTBL(p)->xfn(p,a,b,c,d,e,f,g,h,i,j,k)
-
-#endif /* __WINE__ */
-
-#ifdef ICOM_MSVTABLE_COMPAT
-#define ICOM_DEFINE(iface,ibase) \
- typedef struct ICOM_VTABLE(iface) ICOM_VTABLE(iface); \
- struct iface { \
- const ICOM_VFIELD(iface); \
- }; \
- struct ICOM_VTABLE(iface) { \
- long dummyRTTI1; \
- long dummyRTTI2; \
- ibase##_IMETHODS \
- iface##_METHODS \
- };
-#define ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE 0,0,
-
-#else
-#define ICOM_DEFINE(iface,ibase) \
- typedef struct ICOM_VTABLE(iface) ICOM_VTABLE(iface); \
- struct iface { \
- const ICOM_VFIELD(iface); \
- }; \
- struct ICOM_VTABLE(iface) { \
- ibase##_IMETHODS \
- iface##_METHODS \
- };
-#define ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
-#endif /* ICOM_MSVTABLE_COMPAT */
-
-
-#define ICOM_THIS(impl,iface) impl* const This=(impl*)iface
-#define ICOM_CTHIS(impl,iface) const impl* const This=(const impl*)iface
-
-#endif
-
-
-/*****************************************************************************
- * Predeclare the interfaces
- */
-DEFINE_OLEGUID(IID_IClassFactory, 0x00000001L, 0, 0);
-typedef struct IClassFactory IClassFactory, *LPCLASSFACTORY;
-
-DEFINE_OLEGUID(IID_IMalloc, 0x00000002L, 0, 0);
-typedef struct IMalloc IMalloc,*LPMALLOC;
-
-DEFINE_OLEGUID(IID_IUnknown, 0x00000000L, 0, 0);
-typedef struct IUnknown IUnknown, *LPUNKNOWN;
-
-
-/*****************************************************************************
- * IUnknown interface
- */
-#define ICOM_INTERFACE IUnknown
-#define IUnknown_IMETHODS \
- ICOM_METHOD2(HRESULT,QueryInterface,REFIID,riid, LPVOID*,ppvObj) \
- ICOM_METHOD (ULONG,AddRef) \
- ICOM_METHOD (ULONG,Release)
-#ifdef ICOM_CINTERFACE
-typedef struct ICOM_VTABLE(IUnknown) ICOM_VTABLE(IUnknown);
-struct IUnknown {
- ICOM_VFIELD(IUnknown);
-#if defined(ICOM_USE_COM_INTERFACE_ATTRIBUTE)
-} __attribute__ ((com_interface));
-#else
-};
-#endif /* ICOM_US_COM_INTERFACE_ATTRIBUTE */
-
-struct ICOM_VTABLE(IUnknown) {
-#ifdef ICOM_MSVTABLE_COMPAT
- long dummyRTTI1;
- long dummyRTTI2;
-#endif /* ICOM_MSVTABLE_COMPAT */
-
-#else /* ICOM_CINTERFACE */
-struct IUnknown {
-
-#endif /* ICOM_CINTERFACE */
-
- ICOM_METHOD2(HRESULT,QueryInterface,REFIID,riid, LPVOID*,ppvObj)
- ICOM_METHOD (ULONG,AddRef)
- ICOM_METHOD (ULONG,Release)
-#if defined(ICOM_USE_COM_INTERFACE_ATTRIBUTE)
-} __attribute__ ((com_interface));
-#else
-};
-#endif /* ICOM_US_COM_INTERFACE_ATTRIBUTE */
-
-#undef ICOM_INTERFACE
-
-/*** IUnknown methods ***/
-#define IUnknown_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
-#define IUnknown_AddRef(p) ICOM_CALL (AddRef,p)
-#define IUnknown_Release(p) ICOM_CALL (Release,p)
-
-/*****************************************************************************
- * IClassFactory interface
- */
-#define ICOM_INTERFACE IClassFactory
-#define IClassFactory_METHODS \
- ICOM_METHOD3(HRESULT,CreateInstance, LPUNKNOWN,pUnkOuter, REFIID,riid, LPVOID*,ppvObject) \
- ICOM_METHOD1(HRESULT,LockServer, BOOL,fLock)
-#define IClassFactory_IMETHODS \
- IUnknown_IMETHODS \
- IClassFactory_METHODS
-ICOM_DEFINE(IClassFactory,IUnknown)
-#undef ICOM_INTERFACE
-
-/*** IUnknown methods ***/
-#define IClassFactory_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
-#define IClassFactory_AddRef(p) ICOM_CALL (AddRef,p)
-#define IClassFactory_Release(p) ICOM_CALL (Release,p)
-/*** IClassFactory methods ***/
-#define IClassFactory_CreateInstance(p,a,b,c) ICOM_CALL3(CreateInstance,p,a,b,c)
-#define IClassFactory_LockServer(p,a) ICOM_CALL1(LockServer,p,a)
-
-
-/*****************************************************************************
- * IMalloc interface
- */
-#define ICOM_INTERFACE IMalloc
-#define IMalloc_METHODS \
- ICOM_METHOD1 (LPVOID,Alloc, DWORD,cb) \
- ICOM_METHOD2 (LPVOID,Realloc, LPVOID,pv, DWORD,cb) \
- ICOM_VMETHOD1( Free, LPVOID,pv) \
- ICOM_METHOD1(DWORD, GetSize, LPVOID,pv) \
- ICOM_METHOD1(INT, DidAlloc, LPVOID,pv) \
- ICOM_METHOD (VOID, HeapMinimize)
-#define IMalloc_IMETHODS \
- IUnknown_IMETHODS \
- IMalloc_METHODS
-ICOM_DEFINE(IMalloc,IUnknown)
-#undef ICOM_INTERFACE
-
-/*** IUnknown methods ***/
-#define IMalloc_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
-#define IMalloc_AddRef(p) ICOM_CALL (AddRef,p)
-#define IMalloc_Release(p) ICOM_CALL (Release,p)
-/*** IMalloc32 methods ***/
-#define IMalloc_Alloc(p,a) ICOM_CALL1(Alloc,p,a)
-#define IMalloc_Realloc(p,a,b) ICOM_CALL2(Realloc,p,a,b)
-#define IMalloc_Free(p,a) ICOM_CALL1(Free,p,a)
-#define IMalloc_GetSize(p,a) ICOM_CALL1(GetSize,p,a)
-#define IMalloc_DidAlloc(p,a) ICOM_CALL1(DidAlloc,p,a)
-#define IMalloc_HeapMinimize(p) ICOM_CALL (HeapMinimize,p)
-
-
-HRESULT WINAPI CoGetMalloc(DWORD dwMemContext,LPMALLOC* lpMalloc);
-
-LPVOID WINAPI CoTaskMemAlloc(ULONG size);
-
-void WINAPI CoTaskMemFree(LPVOID ptr);
-
-/* FIXME: unimplemented */
-LPVOID WINAPI CoTaskMemRealloc(LPVOID ptr, ULONG size);
-
-
-/*****************************************************************************
- * Additional API
- */
-
-HRESULT WINAPI CoCreateGuid(GUID* pguid);
-
-HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree);
-
-void WINAPI CoFreeAllLibraries(void);
-
-void WINAPI CoFreeLibrary(HINSTANCE hLibrary);
-
-void WINAPI CoFreeUnusedLibraries(void);
-
-HRESULT WINAPI CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv);
-
-HRESULT WINAPI CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pvReserved, REFIID iid, LPVOID *ppv);
-
-HRESULT WINAPI CoInitialize(LPVOID lpReserved);
-HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit);
-
-void WINAPI CoUninitialize(void);
-
-typedef enum tagCOINIT
-{
- COINIT_APARTMENTTHREADED = 0x2, /* Apartment model */
- COINIT_MULTITHREADED = 0x0, /* OLE calls objects on any thread */
- COINIT_DISABLE_OLE1DDE = 0x4, /* Don't use DDE for Ole1 support */
- COINIT_SPEED_OVER_MEMORY = 0x8 /* Trade memory for speed */
-} COINIT;
-
-
-/* FIXME: not implemented */
-BOOL WINAPI CoIsOle1Class(REFCLSID rclsid);
-
-HRESULT WINAPI CoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases);
-
-/* class registration flags; passed to CoRegisterClassObject */
-typedef enum tagREGCLS
-{
- REGCLS_SINGLEUSE = 0,
- REGCLS_MULTIPLEUSE = 1,
- REGCLS_MULTI_SEPARATE = 2,
- REGCLS_SUSPENDED = 4
-} REGCLS;
-
-HRESULT WINAPI CoResumeClassObjects (void);
-HRESULT WINAPI CoRegisterClassObject(REFCLSID rclsid,LPUNKNOWN pUnk,DWORD dwClsContext,DWORD flags,LPDWORD lpdwRegister);
-
-HRESULT WINAPI CoRevokeClassObject(DWORD dwRegister);
-
-/*****************************************************************************
- * COM Server dll - exports
- */
-HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID * ppv);
-HRESULT WINAPI DllCanUnloadNow(void);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* __WINE_WINE_OBJ_BASE_H */
+++ /dev/null
-/* wtypes.h - Defines the basic types used by COM interfaces.
-
- Copyright (c) 1993-2000 the Wine project authors (see the file WINE-AUTHORS
- for a complete list)
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef __WINE_WTYPES_H
-#define __WINE_WTYPES_H
-
-#include "basetsd.h"
-#include "guiddef.h"
-/*#include "rpc.h"*/
-/*#include "rpcndr.h"*/
-
-typedef WORD CLIPFORMAT, *LPCLIPFORMAT;
-
-/* FIXME: does not belong here */
-typedef CHAR OLECHAR16;
-typedef LPSTR LPOLESTR16;
-typedef LPCSTR LPCOLESTR16;
-typedef OLECHAR16 *BSTR16;
-typedef BSTR16 *LPBSTR16;
-#define OLESTR16(x) x
-
-typedef WCHAR OLECHAR;
-typedef LPWSTR LPOLESTR;
-typedef LPCWSTR LPCOLESTR;
-typedef OLECHAR *BSTR;
-typedef BSTR *LPBSTR;
-
-/*
-#ifndef _DWORDLONG_
-#define _DWORDLONG_
-typedef __uint64 DWORDLONG, *PDWORDLONG;
-#endif
-
-#ifndef _ULONGLONG_
-#define _ULONGLONG_
-typedef __int64 LONGLONG, *PLONGLONG;
-typedef __uint64 ULONGLONG, *PULONGLONG;
-#endif
-*/
-
-#define OLESTR(x) L##x
-
-typedef enum tagDVASPECT
-{
- DVASPECT_CONTENT = 1,
- DVASPECT_THUMBNAIL = 2,
- DVASPECT_ICON = 4,
- DVASPECT_DOCPRINT = 8
-} DVASPECT;
-
-typedef enum tagSTGC
-{
- STGC_DEFAULT = 0,
- STGC_OVERWRITE = 1,
- STGC_ONLYIFCURRENT = 2,
- STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE = 4,
- STGC_CONSOLIDATE = 8
-} STGC;
-
-typedef enum tagSTGMOVE
-{
- STGMOVE_MOVE = 0,
- STGMOVE_COPY = 1,
- STGMOVE_SHALLOWCOPY = 2
-} STGMOVE;
-
-
-typedef struct _COAUTHIDENTITY
-{
- USHORT* User;
- ULONG UserLength;
- USHORT* Domain;
- ULONG DomainLength;
- USHORT* Password;
- ULONG PasswordLength;
- ULONG Flags;
-} COAUTHIDENTITY;
-
-typedef struct _COAUTHINFO
-{
- DWORD dwAuthnSvc;
- DWORD dwAuthzSvc;
- LPWSTR pwszServerPrincName;
- DWORD dwAuthnLevel;
- DWORD dwImpersonationLevel;
- COAUTHIDENTITY* pAuthIdentityData;
- DWORD dwCapabilities;
-} COAUTHINFO;
-
-typedef struct _COSERVERINFO
-{
- DWORD dwReserved1;
- LPWSTR pwszName;
- COAUTHINFO* pAuthInfo;
- DWORD dwReserved2;
-} COSERVERINFO;
-
-typedef enum tagCLSCTX
-{
- CLSCTX_INPROC_SERVER = 0x1,
- CLSCTX_INPROC_HANDLER = 0x2,
- CLSCTX_LOCAL_SERVER = 0x4,
- CLSCTX_INPROC_SERVER16 = 0x8,
- CLSCTX_REMOTE_SERVER = 0x10,
- CLSCTX_INPROC_HANDLER16 = 0x20,
- CLSCTX_INPROC_SERVERX86 = 0x40,
- CLSCTX_INPROC_HANDLERX86 = 0x80,
- CLSCTX_ESERVER_HANDLER = 0x100
-} CLSCTX;
-
-#define CLSCTX_INPROC (CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER)
-#define CLSCTX_ALL (CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER)
-#define CLSCTX_SERVER (CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER)
-
-typedef enum tagMSHLFLAGS
-{
- MSHLFLAGS_NORMAL = 0,
- MSHLFLAGS_TABLESTRONG = 1,
- MSHLFLAGS_TABLEWEAK = 2,
- MSHLFLAGS_NOPING = 4
-} MSHLFLAGS;
-
-typedef enum tagMSHCTX
-{
- MSHCTX_LOCAL = 0,
- MSHCTX_NOSHAREDMEM = 1,
- MSHCTX_DIFFERENTMACHINE = 2,
- MSHCTX_INPROC = 3
-} MSHCTX;
-
-typedef unsigned short VARTYPE;
-
-typedef ULONG PROPID;
-
-/*
-#ifndef _tagBLOB_DEFINED
-#define _tagBLOB_DEFINED
-#define _BLOB_DEFINED
-#define _LPBLOB_DEFINED
-typedef struct tagBLOB
-{
- ULONG cbSize;
- BYTE *pBlobData;
-} BLOB, *LPBLOB;
-#endif
-*/
-
-#ifndef _tagCY_DEFINED
-#define _tagCY_DEFINED
-
-typedef union tagCY {
- struct {
-#ifdef BIG_ENDIAN
- LONG Hi;
- LONG Lo;
-#else /* defined(BIG_ENDIAN) */
- ULONG Lo;
- LONG Hi;
-#endif /* defined(BIG_ENDIAN) */
- } DUMMYSTRUCTNAME;
- LONGLONG int64;
-} CY;
-
-#endif /* _tagCY_DEFINED */
-
-/*
- * 0 == FALSE and -1 == TRUE
- */
-#define VARIANT_TRUE ((VARIANT_BOOL)0xFFFF)
-#define VARIANT_FALSE ((VARIANT_BOOL)0x0000)
-typedef short VARIANT_BOOL,_VARIANT_BOOL;
-
-typedef struct tagCLIPDATA
-{
- ULONG cbSize;
- long ulClipFmt;
- BYTE *pClipData;
-} CLIPDATA;
-
-/* Macro to calculate the size of the above pClipData */
-#define CBPCLIPDATA(clipdata) ( (clipdata).cbSize - sizeof((clipdata).ulClipFmt) )
-
-typedef LONG SCODE;
-
-/*
-#ifndef _FILETIME_
-#define _FILETIME_
-*/
-/* 64 bit number of 100 nanoseconds intervals since January 1, 1601 */
-/*
-typedef struct
-{
- DWORD dwLowDateTime;
- DWORD dwHighDateTime;
-} FILETIME, *LPFILETIME;
-#endif
-*/
-
-#ifndef _SECURITY_DEFINED
-#define _SECURITY_DEFINED
-
-/*
-typedef struct {
- BYTE Value[6];
-} SID_IDENTIFIER_AUTHORITY,*PSID_IDENTIFIER_AUTHORITY;
-
-typedef struct _SID {
- BYTE Revision;
- BYTE SubAuthorityCount;
- SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
- DWORD SubAuthority[1];
-} SID,*PSID;
-*/
-/*
- * ACL
- */
-/*
-typedef struct _ACL {
- BYTE AclRevision;
- BYTE Sbz1;
- WORD AclSize;
- WORD AceCount;
- WORD Sbz2;
-} ACL, *PACL;
-
-typedef DWORD SECURITY_INFORMATION;
-typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
-typedef DWORD ACCESS_MASK, *PACCESS_MASK;
-
-typedef PVOID PGENERIC_MAPPING;
-*/
-/* The security descriptor structure */
-/*
-typedef struct {
- BYTE Revision;
- BYTE Sbz1;
- SECURITY_DESCRIPTOR_CONTROL Control;
- PSID Owner;
- PSID Group;
- PACL Sacl;
- PACL Dacl;
-} SECURITY_DESCRIPTOR, *PSECURITY_DESCRIPTOR;
-*/
-#endif /* _SECURITY_DEFINED */
-
-#ifndef _ROTFLAGS_DEFINED
-#define _ROTFLAGS_DEFINED
-#define ROTFLAGS_REGISTRATIONKEEPSALIVE 0x1
-#define ROTFLAGS_ALLOWANYCLIENT 0x2
-#endif /* !defined(_ROTFLAGS_DEFINED) */
-
-#endif /* __WINE_WTYPES_H */
projects / gpgme.git / commitdiff