qgpgme
dataprovider.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <qgpgme/dataprovider.h>
00024
00025 #include <stdio.h>
00026 #include <string.h>
00027 #include <errno.h>
00028 #include <assert.h>
00029
00030 using namespace QGpgME;
00031
00032
00033
00034
00035
00036
00037
00038 static bool resizeAndInit( QByteArray & ba, size_t newSize ) {
00039 const size_t oldSize = ba.size();
00040 ba.resize( newSize );
00041 const bool ok = ( newSize == static_cast<size_t>( ba.size() ) );
00042 if ( ok )
00043 memset( ba.data() + oldSize, 0, newSize - oldSize );
00044 return ok;
00045 }
00046
00047 QByteArrayDataProvider::QByteArrayDataProvider()
00048 : GpgME::DataProvider(), mOff( 0 ) {}
00049
00050 QByteArrayDataProvider::QByteArrayDataProvider( const QByteArray & initialData )
00051 : GpgME::DataProvider(), mArray( initialData ), mOff( 0 ) {}
00052
00053 QByteArrayDataProvider::~QByteArrayDataProvider() {}
00054
00055 ssize_t QByteArrayDataProvider::read( void * buffer, size_t bufSize ) {
00056 #ifndef NDEBUG
00057
00058 #endif
00059 if ( bufSize == 0 )
00060 return 0;
00061 if ( !buffer ) {
00062 errno = EINVAL;
00063 return -1;
00064 }
00065 if ( mOff >= mArray.size() )
00066 return 0;
00067 size_t amount = qMin( bufSize, static_cast<size_t>( mArray.size() - mOff ) );
00068 assert( amount > 0 );
00069 memcpy( buffer, mArray.data() + mOff, amount );
00070 mOff += amount;
00071 return amount;
00072 }
00073
00074 ssize_t QByteArrayDataProvider::write( const void * buffer, size_t bufSize ) {
00075 #ifndef NDEBUG
00076 qDebug( "QByteArrayDataProvider::write( %p, %lu )", buffer, static_cast<unsigned long>( bufSize ) );
00077 #endif
00078 if ( bufSize == 0 )
00079 return 0;
00080 if ( !buffer ) {
00081 errno = EINVAL;
00082 return -1;
00083 }
00084 if ( mOff >= mArray.size() )
00085 resizeAndInit( mArray, mOff + bufSize );
00086 if ( mOff >= mArray.size() ) {
00087 errno = EIO;
00088 return -1;
00089 }
00090 assert( bufSize <= static_cast<size_t>(mArray.size()) - mOff );
00091 memcpy( mArray.data() + mOff, buffer, bufSize );
00092 mOff += bufSize;
00093 return bufSize;
00094 }
00095
00096 off_t QByteArrayDataProvider::seek( off_t offset, int whence ) {
00097 #ifndef NDEBUG
00098 qDebug( "QByteArrayDataProvider::seek( %d, %d )", int(offset), whence );
00099 #endif
00100 int newOffset = mOff;
00101 switch ( whence ) {
00102 case SEEK_SET:
00103 newOffset = offset;
00104 break;
00105 case SEEK_CUR:
00106 newOffset += offset;
00107 break;
00108 case SEEK_END:
00109 newOffset = mArray.size() + offset;
00110 break;
00111 default:
00112 errno = EINVAL;
00113 return (off_t)-1;
00114 }
00115 return mOff = newOffset;
00116 }
00117
00118 void QByteArrayDataProvider::release() {
00119 #ifndef NDEBUG
00120 qDebug( "QByteArrayDataProvider::release()" );
00121 #endif
00122 mArray = QByteArray();
00123 }
00124
00125
00126
00127
00128
00129
00130
00131
00132 QIODeviceDataProvider::QIODeviceDataProvider( QIODevice * io )
00133 : GpgME::DataProvider(),
00134 mIO( io ), mOwnsDevice( false )
00135 {
00136 assert( mIO );
00137 }
00138
00139 QIODeviceDataProvider::~QIODeviceDataProvider() {
00140 if ( mOwnsDevice )
00141 delete mIO;
00142 }
00143
00144 void QIODeviceDataProvider::setOwnsDevice( bool ownz ) {
00145 mOwnsDevice = ownz;
00146 }
00147
00148 bool QIODeviceDataProvider::ownsDevice() const {
00149 return mOwnsDevice;
00150 }
00151
00152 bool QIODeviceDataProvider::isSupported( Operation op ) const {
00153 switch ( op ) {
00154 case Read: return mIO->isReadable();
00155 case Write: return mIO->isWritable();
00156 case Seek: return !mIO->isSequential();
00157 case Release: return true;
00158 default: return false;
00159 }
00160 }
00161
00162 ssize_t QIODeviceDataProvider::read( void * buffer, size_t bufSize ) {
00163 #ifndef NDEBUG
00164
00165 #endif
00166 if ( bufSize == 0 )
00167 return 0;
00168 if ( !buffer ) {
00169 errno = EINVAL;
00170 return -1;
00171 }
00172 return mIO->read( static_cast<char*>(buffer), bufSize );
00173 }
00174
00175 ssize_t QIODeviceDataProvider::write( const void * buffer, size_t bufSize ) {
00176 #ifndef NDEBUG
00177 qDebug( "QIODeviceDataProvider::write( %p, %lu )", buffer, static_cast<unsigned long>( bufSize ) );
00178 #endif
00179 if ( bufSize == 0 )
00180 return 0;
00181 if ( !buffer ) {
00182 errno = EINVAL;
00183 return -1;
00184 }
00185 return mIO->write( static_cast<const char*>(buffer), bufSize );
00186 }
00187
00188 off_t QIODeviceDataProvider::seek( off_t offset, int whence ) {
00189 #ifndef NDEBUG
00190 qDebug( "QIODeviceDataProvider::seek( %d, %d )", int(offset), whence );
00191 #endif
00192 if ( mIO->isSequential() ) {
00193 errno = ESPIPE;
00194 return (off_t)-1;
00195 }
00196 qint64 newOffset = mIO->pos();
00197 switch ( whence ) {
00198 case SEEK_SET:
00199 newOffset = offset;
00200 break;
00201 case SEEK_CUR:
00202 newOffset += offset;
00203 break;
00204 case SEEK_END:
00205 newOffset = mIO->size() + offset;
00206 break;
00207 default:
00208 errno = EINVAL;
00209 return (off_t)-1;
00210 }
00211 if ( !mIO->seek( newOffset ) ) {
00212 errno = EINVAL;
00213 return (off_t)-1;
00214 }
00215 return newOffset;
00216 }
00217
00218 void QIODeviceDataProvider::release() {
00219 #ifndef NDEBUG
00220 qDebug( "QIODeviceDataProvider::release()" );
00221 #endif
00222 mIO->close();
00223 }