libkdenetwork Library API Documentation

callbacks.cpp

00001 /* callbacks.cpp - callback targets for internal use:
00002    Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB
00003 
00004    This file is part of GPGME++.
00005  
00006    GPGME++ is free software; you can redistribute it and/or modify it
00007    under the terms of the GNU General Public License as published by
00008    the Free Software Foundation; either version 2 of the License, or
00009    (at your option) any later version.
00010  
00011    GPGME++ is distributed in the hope that it will be useful, but
00012    WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014    General Public License for more details.
00015 
00016    You should have received a copy of the GNU General Public License
00017    along with GPGME; if not, write to the Free Software Foundation,
00018    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA.
00019 */
00020 #ifdef HAVE_CONFIG_H
00021 #include <config.h>
00022 #endif
00023 
00024 #include "callbacks.h"
00025 
00026 #include <gpgmepp/interfaces/progressprovider.h>
00027 #include <gpgmepp/interfaces/passphraseprovider.h>
00028 #include <gpgmepp/interfaces/dataprovider.h>
00029 #include <gpgmepp/context.h> // for Error
00030 
00031 #include <cassert>
00032 #include <cerrno>
00033 #include <unistd.h>
00034 
00035 static inline gpg_error_t makeErrorFromErrno() {
00036   return gpg_err_make_from_errno( (gpg_err_source_t)22, errno );
00037 }
00038 static inline gpg_error_t makeError( gpg_err_code_t code ) {
00039   return gpg_err_make( (gpg_err_source_t)22, code );
00040 }
00041 
00042 using GpgME::ProgressProvider;
00043 using GpgME::PassphraseProvider;
00044 using GpgME::DataProvider;
00045 
00046 void progress_callback( void * opaque, const char * what,
00047             int type, int current, int total ) {
00048   ProgressProvider * provider = static_cast<ProgressProvider*>( opaque );
00049   if ( provider )
00050     provider->showProgress( what, type, current, total );
00051 }
00052 
00053 static void wipe( char * buf, size_t len ) {
00054   for ( size_t i = 0 ; i < len ; ++i )
00055     buf[i] = '\0';
00056 }
00057 
00058 gpgme_error_t passphrase_callback( void * opaque, const char * uid_hint, const char * desc,
00059                    int prev_was_bad, int fd ) {
00060   PassphraseProvider * provider = static_cast<PassphraseProvider*>( opaque );
00061   bool canceled = false;
00062   gpgme_error_t err = GPG_ERR_NO_ERROR;
00063   char * passphrase = provider ? provider->getPassphrase( uid_hint, desc, prev_was_bad, canceled ) : 0 ;
00064   if ( canceled )
00065     err = makeError( GPG_ERR_CANCELED );
00066   else
00067     if ( passphrase && *passphrase ) {
00068       size_t passphrase_length = strlen( passphrase );
00069       size_t written = 0;
00070       do {
00071     ssize_t now_written = write( fd, passphrase + written, passphrase_length - written );
00072     if ( now_written < 0 ) {
00073       err = makeErrorFromErrno();
00074       break;
00075     }
00076     written += now_written;
00077       } while ( written < passphrase_length );
00078     }
00079   
00080   if ( passphrase && *passphrase )
00081     wipe( passphrase, strlen( passphrase ) );
00082   free( passphrase );
00083   write( fd, "\n", 1 );
00084   return err;
00085 }
00086 
00087 
00088 
00089 static ssize_t
00090 data_read_callback( void * opaque, void * buf, size_t buflen ) {
00091   DataProvider * provider = static_cast<DataProvider*>( opaque );
00092   if ( !provider ) {
00093     errno = EINVAL;
00094     return -1;
00095   }
00096   return provider->read( buf, buflen );
00097 }
00098 
00099 static ssize_t
00100 data_write_callback( void * opaque, const void * buf, size_t buflen ) {
00101   DataProvider * provider = static_cast<DataProvider*>( opaque );
00102   if ( !provider ) {
00103     errno = EINVAL;
00104     return -1;
00105   }
00106   return provider->write( buf, buflen );
00107 }
00108 
00109 static off_t
00110 data_seek_callback( void * opaque, off_t offset, int whence ) {
00111   DataProvider * provider = static_cast<DataProvider*>( opaque );
00112   if ( !provider ) {
00113     errno = EINVAL;
00114     return -1;
00115   }
00116   if ( whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END ) {
00117     errno = EINVAL;
00118     return -1;
00119   }
00120   return provider->seek( offset, whence );
00121 }
00122 
00123 static void data_release_callback( void * opaque ) {
00124   DataProvider * provider = static_cast<DataProvider*>( opaque );
00125   if ( provider )
00126     provider->release();
00127 }
00128 
00129 gpgme_data_cbs data_provider_callbacks = {
00130   &data_read_callback,
00131   &data_write_callback,
00132   &data_seek_callback,
00133   &data_release_callback
00134 };
00135 
KDE Logo
This file is part of the documentation for libkdenetwork Library Version 3.3.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu May 3 20:16:58 2007 by doxygen 1.4.2 written by Dimitri van Heesch, © 1997-2003