extensions/workben/testpgp.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: testpgp.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_extensions.hxx"
  33 #include <sal/types.h>
  34 #include <rtl/memory.h>
  35 #ifndef _RTL_WSTRING_
  36 #include <rtl/wstring>
  37 #endif
  38 #include <vos/macros.hxx>
  39
  40 #ifndef _USR_SMARTSERVICES_HXX_
  41 #include <usr/smartservices.hxx>
  42 #endif
  43 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  44 #include <com/sun/star/io/XInputStream.hpp>
  45 #include <com/sun/star/io/XOutputStream.hpp>
  46 #include <com/sun/star/pgp/RecipientsEvent.hpp>
  47 #include <com/sun/star/pgp/SignatureEvent.hpp>
  48 #include <com/sun/star/pgp/XPGPDecoder.hpp>
  49 #include <com/sun/star/pgp/XPGPDecoderListener.hpp>
  50 #include <com/sun/star/pgp/XPGPEncoder.hpp>
  51 #include <com/sun/star/pgp/XPGPPreferences.hpp>
  52 #include <com/sun/star/uno/XInterface.hpp>
  53 #include <com/sun/star/uno/Any.h>
  54 #include <com/sun/star/uno/Reference.h>
  55 #include <com/sun/star/uno/Sequence.hxx>
  56 #include <cppuhelper/weak.hxx>
  57
  58 #include <stdio.h>
  59 #include <stdlib.h>
  60 #include <string.h>
  61
  62 #include <fcntl.h>
  63 #include <io.h>
  64
  65 using namespace com::sun::star::lang;
  66 using namespace com::sun::star::io;
  67 using namespace com::sun::star::pgp;
  68 using namespace com::sun::star::uno;
  69
  70 /*========================================================================
  71  *
  72  * DataSource_Impl interface.
  73  *
  74  *======================================================================*/
  75 class DataSource_Impl :
  76     public OWeakObject,
  77     public XInputStream
  78 {
  79     Sequence<sal_Int8> m_buffer;
  80     sal_Int32          m_position;
  81     int                m_fd;
  82
  83 public:
  84     DataSource_Impl (int fd = 0);
  85     virtual ~DataSource_Impl (void);
  86
  87     void setBuffer (const Sequence<sal_Int8> &rBuffer);
  88
  89     /** XInterface.
  90      */
  91     virtual sal_Bool SAL_CALL queryInterface (
  92         const Uik &rUik, Any &rIfc) throw(RuntimeException);
  93
  94     virtual void SAL_CALL acquire (void) throw(RuntimeException);
  95
  96     virtual void SAL_CALL release (void) throw(RuntimeException);
  97
  98     /** XInputStream.
  99      */
 100     virtual sal_Int32 SAL_CALL readBytes (
 101         Sequence<sal_Int8> &rData, sal_Int32 nBytesToRead)
 102         throw (NotConnectedException,
 103                BufferSizeExceededException,
 104                IOException);
 105
 106     virtual sal_Int32 SAL_CALL readSomeBytes (
 107         Sequence<sal_Int8> &rData, sal_Int32 nMaxBytesToRead)
 108         throw (NotConnectedException,
 109                BufferSizeExceededException,
 110                IOException);
 111
 112     virtual void SAL_CALL skipBytes (sal_Int32 nBytesToSkip)
 113         throw (NotConnectedException,
 114                BufferSizeExceededException,
 115                IOException);
 116
 117     virtual sal_Int32 SAL_CALL available (void)
 118         throw (NotConnectedException, IOException);
 119
 120     virtual void SAL_CALL closeInput (void)
 121         throw (NotConnectedException, IOException);
 122 };
 123
 124 /*========================================================================
 125  *
 126  * DataSink_Impl interface.
 127  *
 128  *======================================================================*/
 129 class DataSink_Impl :
 130     public OWeakObject,
 131     public XOutputStream
 132 {
 133     Sequence<sal_Int8> m_buffer;
 134
 135 public:
 136     DataSink_Impl (void);
 137     virtual ~DataSink_Impl (void);
 138
 139     const Sequence<sal_Int8>& getBuffer (void) const { return m_buffer; }
 140
 141     /** XInterface.
 142      */
 143     virtual sal_Bool SAL_CALL queryInterface (
 144         const Uik &rUik, Any &rIfc) throw(RuntimeException);
 145
 146     virtual void SAL_CALL acquire (void) throw(RuntimeException);
 147     virtual void SAL_CALL release (void) throw(RuntimeException);
 148
 149     /** XOutputStream.
 150      */
 151     virtual void SAL_CALL writeBytes (
 152         const Sequence<sal_Int8> &rBuffer)
 153         throw (NotConnectedException,
 154                BufferSizeExceededException,
 155                IOException);
 156
 157     virtual void SAL_CALL flush (void)
 158         throw (NotConnectedException,
 159                BufferSizeExceededException,
 160                IOException);
 161
 162     virtual void SAL_CALL closeOutput (void)
 163         throw (NotConnectedException,
 164                BufferSizeExceededException,
 165                IOException);
 166 };
 167
 168 /*========================================================================
 169  *
 170  * DecoderListener_Impl interface.
 171  *
 172  *======================================================================*/
 173 class DecoderListener_Impl :
 174     public OWeakObject,
 175     public XPGPDecoderListener
 176 {
 177 public:
 178     DecoderListener_Impl (void);
 179     virtual ~DecoderListener_Impl (void);
 180
 181     /** XInterface.
 182      */
 183     virtual sal_Bool SAL_CALL queryInterface (
 184         const Uik &rUik, Any &rIfc) throw(RuntimeException);
 185
 186     virtual void SAL_CALL acquire (void) throw(RuntimeException);
 187
 188     virtual void SAL_CALL release (void) throw(RuntimeException);
 189
 190     /** XEventListener.
 191      */
 192     virtual void SAL_CALL disposing (const EventObject &rSource);
 193
 194     /** XPGPDecoderListener.
 195      */
 196     virtual void SAL_CALL decrypted (const RecipientsEvent &rEvent);
 197     virtual void SAL_CALL verified  (const SignatureEvent &rEvent);
 198 };
 199
 200 /*========================================================================
 201  *
 202  * DataSource_Impl implementation.
 203  *
 204  *======================================================================*/
 205 /*
 206  * DataSource_Impl.
 207  */
 208 DataSource_Impl::DataSource_Impl (int fd)
 209     : m_fd (fd), m_position (0)
 210 {
 211 }
 212
 213 /*
 214  * ~DataSource_Impl.
 215  */
 216 DataSource_Impl::~DataSource_Impl (void)
 217 {
 218 }
 219
 220 /*
 221  * DataSource_Impl: setBuffer.
 222  */
 223 void DataSource_Impl::setBuffer (const Sequence<sal_Int8> &rBuffer)
 224 {
 225     m_buffer = rBuffer;
 226     if (!m_buffer.getLength())
 227     {
 228         // Fill buffer from file descriptor.
 229         char buffer[1024];
 230         rtl_zeroMemory (buffer, sizeof(buffer));
 231
 232         int k = read (m_fd, buffer, sizeof(buffer));
 233         while (k > 0)
 234         {
 235             sal_Int32 n = m_buffer.getLength();
 236             m_buffer.realloc (n + k);
 237
 238             rtl_copyMemory (m_buffer.getArray() + n, buffer, k);
 239             n += k;
 240
 241             rtl_zeroMemory (buffer, k);
 242             k = read (m_fd, buffer, sizeof(buffer));
 243         }
 244     }
 245     m_position = 0;
 246 }
 247
 248 /*
 249  * XInterface: queryInterface.
 250  */
 251 sal_Bool SAL_CALL DataSource_Impl::queryInterface (
 252     const Uik &rUik, Any &rIfc) throw(RuntimeException)
 253 {
 254     if (com::sun::star::uno::queryInterface (
 255         rUik, rIfc,
 256         SAL_STATIC_CAST (XInputStream*, this)))
 257         return sal_True;
 258     else
 259         return OWeakObject::queryInterface (rUik, rIfc);
 260 }
 261
 262 /*
 263  * XInterface: acquire.
 264  */
 265 void SAL_CALL DataSource_Impl::acquire (void) throw(RuntimeException)
 266 {
 267     OWeakObject::acquire();
 268 }
 269
 270 /*
 271  * XInterface: release.
 272  */
 273 void SAL_CALL DataSource_Impl::release (void) throw(RuntimeException)
 274 {
 275     OWeakObject::release();
 276 }
 277
 278 /*
 279  * XInputStream: readBytes.
 280  */
 281 sal_Int32 SAL_CALL DataSource_Impl::readBytes (
 282     Sequence<sal_Int8> &rData, sal_Int32 nBytesToRead)
 283     throw (NotConnectedException, BufferSizeExceededException, IOException)
 284 {
 285     if (nBytesToRead < 0)
 286         throw IOException();
 287
 288     sal_Int32 k = m_buffer.getLength() - m_position;
 289     k = VOS_BOUND(k, 0, nBytesToRead);
 290     if (k > 0)
 291     {
 292         rData.realloc(k);
 293         rtl_copyMemory (
 294             rData.getArray(), m_buffer.getConstArray() + m_position, k);
 295         m_position += k;
 296     }
 297     return k;
 298 }
 299
 300 /*
 301  * XInputStream: readSomeBytes.
 302  */
 303 sal_Int32 SAL_CALL DataSource_Impl::readSomeBytes (
 304     Sequence<sal_Int8> &rData, sal_Int32 nMaxBytesToRead)
 305     throw (NotConnectedException, BufferSizeExceededException, IOException)
 306 {
 307     return readBytes (rData, nMaxBytesToRead);
 308 }
 309
 310 /*
 311  * XInputStream: skipBytes.
 312  */
 313 void SAL_CALL DataSource_Impl::skipBytes (sal_Int32 nBytesToSkip)
 314     throw (NotConnectedException, BufferSizeExceededException, IOException)
 315 {
 316     if (nBytesToSkip < 0)
 317         throw IOException();
 318
 319     m_position += nBytesToSkip;
 320 }
 321
 322 /*
 323  * XInputStream: available.
 324  */
 325 sal_Int32 SAL_CALL DataSource_Impl::available (void)
 326     throw (NotConnectedException, IOException)
 327 {
 328     sal_Int32 k = m_buffer.getLength() - m_position;
 329     return ((k > 0) ? k : 0);
 330 }
 331
 332 /*
 333  * XInputStream: closeInput.
 334  */
 335 void SAL_CALL DataSource_Impl::closeInput (void)
 336     throw (NotConnectedException, IOException)
 337 {
 338 }
 339
 340 /*========================================================================
 341  *
 342  * DataSink_Impl implementation.
 343  *
 344  *======================================================================*/
 345 /*
 346  * DataSink_Impl.
 347  */
 348 DataSink_Impl::DataSink_Impl (void)
 349 {
 350 }
 351
 352 /*
 353  * ~DataSink_Impl.
 354  */
 355 DataSink_Impl::~DataSink_Impl (void)
 356 {
 357 }
 358
 359 /*
 360  * XInterface: queryInterface.
 361  */
 362 sal_Bool SAL_CALL DataSink_Impl::queryInterface (
 363     const Uik &rUik, Any &rIfc) throw(RuntimeException)
 364 {
 365     if (com::sun::star::uno::queryInterface (
 366         rUik, rIfc,
 367         SAL_STATIC_CAST (XOutputStream*, this)))
 368         return sal_True;
 369     else
 370         return OWeakObject::queryInterface (rUik, rIfc);
 371 }
 372
 373 /*
 374  * XInterface: acquire.
 375  */
 376 void SAL_CALL DataSink_Impl::acquire (void) throw(RuntimeException)
 377 {
 378     OWeakObject::acquire();
 379 }
 380
 381 /*
 382  * XInterface: release.
 383  */
 384 void SAL_CALL DataSink_Impl::release (void) throw(RuntimeException)
 385 {
 386     OWeakObject::release();
 387 }
 388
 389 /*
 390  * XOutputStream: writeBytes.
 391  */
 392 void SAL_CALL DataSink_Impl::writeBytes (const Sequence<sal_Int8> &rBuffer)
 393     throw (NotConnectedException, BufferSizeExceededException, IOException)
 394 {
 395     if (rBuffer.getLength())
 396     {
 397         sal_Int32 n = m_buffer.getLength();
 398         m_buffer.realloc (n + rBuffer.getLength());
 399
 400         rtl_copyMemory (
 401             m_buffer.getArray() + n,
 402             rBuffer.getConstArray(),
 403             rBuffer.getLength());
 404     }
 405 }
 406
 407 /*
 408  * XOutputStream: flush.
 409  */
 410 void SAL_CALL DataSink_Impl::flush (void)
 411     throw (NotConnectedException, BufferSizeExceededException, IOException)
 412 {
 413     if (m_buffer.getLength())
 414     {
 415         // Write data to stdout.
 416         const sal_Int8 *pData = m_buffer.getConstArray();
 417         sal_Int32       nData = m_buffer.getLength();
 418
 419         int prev = ::setmode (1, O_BINARY);
 420         if (!(prev < 0))
 421         {
 422             int k = ::write (1, pData, nData);
 423             if (k > 0)
 424                 ::write (1, "\n", 1);
 425             ::setmode (1, prev);
 426         }
 427     }
 428 }
 429
 430 /*
 431  * XOutputStream: closeOutput.
 432  */
 433 void SAL_CALL DataSink_Impl::closeOutput (void)
 434     throw (NotConnectedException, BufferSizeExceededException, IOException)
 435 {
 436     flush();
 437 }
 438
 439 /*========================================================================
 440  *
 441  * DecoderListener_Impl implementation.
 442  *
 443  *======================================================================*/
 444 /*
 445  * DecoderListener_Impl.
 446  */
 447 DecoderListener_Impl::DecoderListener_Impl (void)
 448 {
 449 }
 450
 451 /*
 452  * ~DecoderListener_Impl.
 453  */
 454 DecoderListener_Impl::~DecoderListener_Impl (void)
 455 {
 456 }
 457
 458 /*
 459  * XInterface: queryInterface.
 460  */
 461 sal_Bool SAL_CALL DecoderListener_Impl::queryInterface (
 462     const Uik &rUik, Any &rIfc) throw(RuntimeException)
 463 {
 464     if (com::sun::star::uno::queryInterface (
 465         rUik, rIfc,
 466         SAL_STATIC_CAST (XEventListener*, this),
 467         SAL_STATIC_CAST (XPGPDecoderListener*, this)))
 468         return sal_True;
 469     else
 470         return OWeakObject::queryInterface (rUik, rIfc);
 471 }
 472
 473 /*
 474  * XInterface: acquire.
 475  */
 476 void SAL_CALL DecoderListener_Impl::acquire (void) throw(RuntimeException)
 477 {
 478     OWeakObject::acquire();
 479 }
 480
 481 /*
 482  * XInterface: release.
 483  */
 484 void SAL_CALL DecoderListener_Impl::release (void) throw(RuntimeException)
 485 {
 486     OWeakObject::release();
 487 }
 488
 489 /*
 490  * XEventListener: disposing.
 491  */
 492 void SAL_CALL DecoderListener_Impl::disposing (const EventObject &rSource)
 493 {
 494 }
 495
 496 /*
 497  * XPGPDecoderListener: decrypted.
 498  */
 499 void SAL_CALL DecoderListener_Impl::decrypted (const RecipientsEvent &rEvent)
 500 {
 501 }
 502
 503 /*
 504  * XPGPDecoderListener: verified.
 505  */
 506 void SAL_CALL DecoderListener_Impl::verified (const SignatureEvent &rEvent)
 507 {
 508 }
 509
 510 /*========================================================================
 511  *
 512  * Main.
 513  *
 514  *======================================================================*/
 515 inline rtl::OWString S2U (const sal_Char *ascii)
 516 {
 517     return rtl::OWString::createFromAscii (ascii);
 518 }
 519
 520 #if 0  /* OLD */
 521
 522 /*
 523  * queryModuleActivator.
 524  */
 525 BOOL queryModuleActivator (
 526     const XServiceManagerRef &rxManager,
 527     XServiceActivatorRef     &rxActivator)
 528 {
 529     XServiceProviderRef xProv;
 530     XInterfaceRef       xProvInst;
 531
 532     xProv = rxManager->queryServiceProvider (
 533         L"stardiv.uno.ServiceActivator.module");
 534     if (!xProv.is())
 535     {
 536         printf ("Error: no ServiceActivator service.\n");
 537         return FALSE;
 538     }
 539
 540     xProvInst = xProv->createInstance();
 541     if (!xProvInst.is())
 542     {
 543         printf ("Error: no ServiceActivator instance.\n");
 544         return FALSE;
 545     }
 546
 547     return xProvInst->queryInterface (
 548         XServiceActivator::getSmartUik(), rxActivator);
 549 }
 550
 551 /*
 552  * install.
 553  */
 554 BOOL install (
 555     const XServiceActivatorRef &rxActivator,
 556     const char                 *prefix)
 557 {
 558     String aModule ("module://");
 559     char   pBuffer[1024];
 560
 561     NAMESPACE_VOS(ORealDynamicLoader)::computeModuleName (
 562         prefix, pBuffer, sizeof(pBuffer));
 563     aModule += pBuffer;
 564
 565     return rxActivator->install (
 566         StringToUString (aModule, CHARSET_SYSTEM));
 567 }
 568
 569 /*
 570  * uninstall.
 571  */
 572 BOOL uninstall (
 573     const XServiceActivatorRef &rxActivator,
 574     const char                 *prefix)
 575 {
 576     String aModule ("module://");
 577     char   pBuffer[1024];
 578
 579     NAMESPACE_VOS(ORealDynamicLoader)::computeModuleName (
 580         prefix, pBuffer, sizeof(pBuffer));
 581     aModule += pBuffer;
 582
 583     return rxActivator->deinstall (
 584         StringToUString (aModule, CHARSET_SYSTEM));
 585 }
 586
 587 #endif /* OLD */
 588
 589 /*
 590  * main.
 591  */
 592 int SAL_CALL main (int argc, char **argv)
 593 {
 594     enum Option
 595     {
 596         OPTION_INSTALL   = 0x01,
 597         OPTION_UNINSTALL = 0x02,
 598
 599         OPTION_DECRYPT   = 0x04,
 600         OPTION_ENCRYPT   = 0x08,
 601         OPTION_SIGN      = 0x10,
 602
 603         OPTION_FILE      = 0x20,
 604         OPTION_HELP      = 0x40
 605     };
 606
 607     int fd = 0;
 608     unsigned long nOptions = 0;
 609
 610     for (int i = 1; i < argc; i++)
 611     {
 612         const char *opt = argv[i];
 613         if (opt[0] == '-')
 614         {
 615             switch (opt[1])
 616             {
 617                 case 'i':
 618                     nOptions |= OPTION_INSTALL;
 619                     break;
 620
 621                 case 'u':
 622                     nOptions |= OPTION_UNINSTALL;
 623                     break;
 624
 625                 case 'd':
 626                     nOptions |= OPTION_DECRYPT;
 627                     break;
 628
 629                 case 'e':
 630                     nOptions |= OPTION_ENCRYPT;
 631                     break;
 632
 633                 case 's':
 634                     nOptions |= OPTION_SIGN;
 635                     break;
 636
 637                 case 'f':
 638                     nOptions |= OPTION_FILE;
 639                     break;
 640
 641                 case 'h':
 642                 default:
 643                     nOptions |= OPTION_HELP;
 644                     break;
 645             }
 646         }
 647         else
 648         {
 649             if (nOptions & OPTION_FILE)
 650             {
 651                 if ((fd = open (argv[i], O_RDONLY | O_BINARY)) < 0)
 652                 {
 653                     printf ("Error: can't open file: %s\n", argv[i]);
 654                     exit (0);
 655                 }
 656             }
 657         }
 658     }
 659
 660     if ((nOptions == 0) || (nOptions & OPTION_HELP))
 661     {
 662         printf ("Options:\n");
 663         printf ("-i\tinstall module\n");
 664         printf ("-u\tuninstall module\n");
 665         printf ("-d\tdecrypt and verify\n");
 666         printf ("-e\tencrypt test pattern\n");
 667         printf ("-s\tsign test pattern\n");
 668         printf ("-h\thelp\n");
 669         exit (0);
 670     }
 671
 672     Reference<XMultiServiceFactory> xManager (
 673         usr::createDefaultSmartRegistryServiceFactory());
 674     if (!xManager.is())
 675     {
 676         printf ("Error: no ProcessServiceManager.\n");
 677         exit (1);
 678     }
 679     usr::setProcessServiceFactory (xManager);
 680
 681     if (nOptions & OPTION_INSTALL)
 682     {
 683 #if 0  /* OLD */
 684         XServiceActivatorRef xActivator;
 685         if (queryModuleActivator (xManager, xActivator))
 686         {
 687             if (install (xActivator, "pgp"))
 688                 printf ("Module PGP installed.\n");
 689             else
 690                 printf ("Error: module PGP not installed.\n");
 691         }
 692         nOptions &= ~OPTION_INSTALL;
 693 #endif /* OLD */
 694     }
 695
 696     if (nOptions & (OPTION_DECRYPT | OPTION_ENCRYPT | OPTION_SIGN))
 697     {
 698         Reference<XMultiServiceFactory> xProv (
 699             xManager->createInstance (
 700                 S2U("com.sun.star.pgp.PGPFactory")),
 701             UNO_QUERY);
 702         if (!xProv.is())
 703         {
 704             printf ("Error: no PGPFactory service.\n");
 705             exit (1);
 706         }
 707
 708         Reference<XInterface> xProvInst (
 709             xProv->createInstance (
 710                 S2U("com.sun.star.pgp.SimplePGPMailer")));
 711         if (!xProvInst.is())
 712         {
 713             printf ("Error: no SimplePGPMailer service.\n");
 714             exit (2);
 715         }
 716
 717         Reference<XPGPPreferences> xPrefs (xProvInst, UNO_QUERY);
 718         if (xPrefs.is())
 719         {
 720             unsigned long nDefaults = 0;
 721
 722             if (xPrefs->getEncryptByDefault())
 723                 nDefaults |= OPTION_ENCRYPT;
 724             if (xPrefs->getSignByDefault())
 725                 nDefaults |= OPTION_SIGN;
 726             if (xPrefs->getAutoDecrypt())
 727                 nDefaults |= OPTION_DECRYPT;
 728
 729             if (nDefaults)
 730             {
 731             }
 732         }
 733
 734         static const sal_Int8 pData[] = "" /* "Hello PGP World." */;
 735         Sequence<sal_Int8> buffer (pData, sizeof (pData) - 1);
 736
 737         if (nOptions & (OPTION_ENCRYPT | OPTION_SIGN))
 738         {
 739             Reference<XPGPEncoder> xEncoder (xProvInst, UNO_QUERY);
 740             if (!xEncoder.is())
 741             {
 742                 printf ("Error: no PGPEncoder interface.\n");
 743                 exit (4);
 744             }
 745
 746             DataSource_Impl *source = new DataSource_Impl (fd);
 747             source->setBuffer (buffer);
 748
 749             DataSink_Impl *sink = new DataSink_Impl;
 750
 751             Reference<XInputStream>  xPlainText  (source);
 752             Reference<XOutputStream> xCipherText (sink);
 753
 754             if (nOptions & OPTION_ENCRYPT)
 755             {
 756                 rtl::OWString aRecipients[] =
 757                 {
 758                     S2U("er@stardiv.de"),
 759                     // L"mhu@stardivision.de",
 760                     S2U("mhu@rabbit")
 761                 };
 762
 763                 sal_Int32 nRecipients =
 764                     sizeof(aRecipients) / sizeof(aRecipients[0]);
 765
 766                 if (nOptions & OPTION_SIGN)
 767                 {
 768                     xEncoder->encryptAndSign (
 769                         Sequence<rtl::OWString>(aRecipients, nRecipients),
 770                         xPlainText,
 771                         xCipherText);
 772                     nOptions &= ~OPTION_SIGN;
 773                 }
 774                 else
 775                 {
 776                     xEncoder->encrypt (
 777                         Sequence<rtl::OWString>(aRecipients, nRecipients),
 778                         xPlainText,
 779                         xCipherText);
 780                 }
 781                 nOptions &= ~OPTION_ENCRYPT;
 782             }
 783
 784             if (nOptions & OPTION_SIGN)
 785             {
 786                 sal_Bool bDataIsAscii = (fd == 0); // stdin.
 787
 788                 xEncoder->sign (
 789                     bDataIsAscii,
 790                     xPlainText,
 791                     xCipherText);
 792                 nOptions &= ~OPTION_SIGN;
 793             }
 794
 795             buffer = sink->getBuffer();
 796         }
 797
 798         if (nOptions & OPTION_DECRYPT)
 799         {
 800             Reference<XPGPDecoder> xDecoder (xProvInst, UNO_QUERY);
 801             if (!xDecoder.is())
 802             {
 803                 printf ("Error: no PGPDecoder interface.\n");
 804                 exit (5);
 805             }
 806
 807             DataSource_Impl *source = new DataSource_Impl;
 808             source->setBuffer (buffer);
 809
 810             DataSink_Impl *sink = new DataSink_Impl;
 811
 812             Reference<XInputStream>  xCipherText (source);
 813             Reference<XOutputStream> xPlainText  (sink);
 814
 815             Reference<XPGPDecoderListener> xListener (
 816                 new DecoderListener_Impl);
 817             xDecoder->addDecoderListener (xListener);
 818
 819             xDecoder->decryptAndVerify (
 820                 xCipherText,
 821                 xPlainText);
 822             nOptions &= ~OPTION_DECRYPT;
 823
 824             xDecoder->removeDecoderListener (xListener);
 825
 826             buffer = sink->getBuffer();
 827         }
 828     }
 829
 830     if (nOptions & OPTION_UNINSTALL)
 831     {
 832 #if 0  /* OLD */
 833         XServiceActivatorRef xActivator;
 834         if (queryModuleActivator (xManager, xActivator))
 835         {
 836             if (uninstall (xActivator, "pgp"))
 837                 printf ("Module PGP uninstalled.\n");
 838             else
 839                 printf ("Error: module PGP not uninstalled.\n");
 840         }
 841         nOptions &= ~OPTION_UNINSTALL;
 842 #endif /* OLD */
 843     }
 844
 845     return 0;
 846 }
 847