Page MenuHome GnuPG
Files F23020917

No OneTemporary
Actions

View Options

diff --git a/src/data.cpp b/src/data.cpp
index 54d156c3..cf43b5bd 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -1,287 +1,293 @@
/*
data.cpp - wraps a gpgme data object
Copyright (C) 2003 Klarälvdalens Datakonsult AB
This file is part of GPGME++.
GPGME++ is free software; you can redistribute it and/or
modify it under the terms of the GNU Library 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 Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with GPGME++; see the file COPYING.LIB. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "data_p.h"
#include "context_p.h"
#include <error.h>
#include <interfaces/dataprovider.h>
#include <gpgme.h>
#ifndef NDEBUG
#include <iostream>
#endif
GpgME::Data::Private::~Private()
{
if (data) {
gpgme_data_release(data);
}
}
const GpgME::Data::Null GpgME::Data::null;
GpgME::Data::Data()
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new(&data);
d.reset(new Private(e ? nullptr : data));
}
GpgME::Data::Data(const Null &)
: d(new Private(nullptr))
{
}
GpgME::Data::Data(gpgme_data_t data)
: d(new Private(data))
{
}
GpgME::Data::Data(const char *buffer, size_t size, bool copy)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_mem(&data, buffer, size, int(copy));
std::string sizestr = std::to_string(size);
// Ignore errors as this is optional
gpgme_data_set_flag(data, "size-hint", sizestr.c_str());
d.reset(new Private(e ? nullptr : data));
}
GpgME::Data::Data(const char *filename)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new(&data);
d.reset(new Private(e ? nullptr : data));
if (!e) {
setFileName(filename);
}
}
GpgME::Data::Data(const char *filename, off_t offset, size_t length)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_filepart(&data, filename, nullptr, offset, length);
d.reset(new Private(e ? nullptr : data));
}
GpgME::Data::Data(FILE *fp)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_stream(&data, fp);
d.reset(new Private(e ? nullptr : data));
}
GpgME::Data::Data(FILE *fp, off_t offset, size_t length)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_filepart(&data, nullptr, fp, offset, length);
d.reset(new Private(e ? nullptr : data));
}
GpgME::Data::Data(int fd)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_fd(&data, fd);
d.reset(new Private(e ? nullptr : data));
}
GpgME::Data::Data(DataProvider *dp)
{
d.reset(new Private);
if (!dp) {
return;
}
if (!dp->isSupported(DataProvider::Read)) {
d->cbs.read = nullptr;
}
if (!dp->isSupported(DataProvider::Write)) {
d->cbs.write = nullptr;
}
if (!dp->isSupported(DataProvider::Seek)) {
d->cbs.seek = nullptr;
}
if (!dp->isSupported(DataProvider::Release)) {
d->cbs.release = nullptr;
}
const gpgme_error_t e = gpgme_data_new_from_cbs(&d->data, &d->cbs, dp);
if (e) {
d->data = nullptr;
}
if (dp->isSupported(DataProvider::Seek)) {
off_t size = seek(0, SEEK_END);
seek(0, SEEK_SET);
std::string sizestr = std::to_string(size);
// Ignore errors as this is optional
gpgme_data_set_flag(d->data, "size-hint", sizestr.c_str());
}
#ifndef NDEBUG
//std::cerr << "GpgME::Data(): DataProvider supports: "
// << ( d->cbs.read ? "read" : "no read" ) << ", "
// << ( d->cbs.write ? "write" : "no write" ) << ", "
// << ( d->cbs.seek ? "seek" : "no seek" ) << ", "
// << ( d->cbs.release ? "release" : "no release" ) << std::endl;
#endif
}
bool GpgME::Data::isNull() const
{
return !d || !d->data;
}
GpgME::Data::Encoding GpgME::Data::encoding() const
{
switch (gpgme_data_get_encoding(d->data)) {
case GPGME_DATA_ENCODING_NONE: return AutoEncoding;
case GPGME_DATA_ENCODING_BINARY: return BinaryEncoding;
case GPGME_DATA_ENCODING_BASE64: return Base64Encoding;
case GPGME_DATA_ENCODING_ARMOR: return ArmorEncoding;
case GPGME_DATA_ENCODING_MIME: return MimeEncoding;
case GPGME_DATA_ENCODING_URL: return UrlEncoding;
case GPGME_DATA_ENCODING_URLESC: return UrlEscEncoding;
case GPGME_DATA_ENCODING_URL0: return Url0Encoding;
}
return AutoEncoding;
}
GpgME::Error GpgME::Data::setEncoding(Encoding enc)
{
gpgme_data_encoding_t ge = GPGME_DATA_ENCODING_NONE;
switch (enc) {
case AutoEncoding: ge = GPGME_DATA_ENCODING_NONE; break;
case BinaryEncoding: ge = GPGME_DATA_ENCODING_BINARY; break;
case Base64Encoding: ge = GPGME_DATA_ENCODING_BASE64; break;
case ArmorEncoding: ge = GPGME_DATA_ENCODING_ARMOR; break;
case MimeEncoding: ge = GPGME_DATA_ENCODING_MIME; break;
case UrlEncoding: ge = GPGME_DATA_ENCODING_URL; break;
case UrlEscEncoding: ge = GPGME_DATA_ENCODING_URLESC; break;
case Url0Encoding: ge = GPGME_DATA_ENCODING_URL0; break;
}
return Error(gpgme_data_set_encoding(d->data, ge));
}
GpgME::Data::Type GpgME::Data::type() const
{
if (isNull()) {
return Invalid;
}
switch (gpgme_data_identify(d->data, 0)) {
case GPGME_DATA_TYPE_INVALID: return Invalid;
case GPGME_DATA_TYPE_UNKNOWN: return Unknown;
case GPGME_DATA_TYPE_PGP_SIGNED: return PGPSigned;
case GPGME_DATA_TYPE_PGP_OTHER: return PGPOther;
case GPGME_DATA_TYPE_PGP_KEY: return PGPKey;
case GPGME_DATA_TYPE_CMS_SIGNED: return CMSSigned;
case GPGME_DATA_TYPE_CMS_ENCRYPTED: return CMSEncrypted;
case GPGME_DATA_TYPE_CMS_OTHER: return CMSOther;
case GPGME_DATA_TYPE_X509_CERT: return X509Cert;
case GPGME_DATA_TYPE_PKCS12: return PKCS12;
case GPGME_DATA_TYPE_PGP_ENCRYPTED: return PGPEncrypted;
case GPGME_DATA_TYPE_PGP_SIGNATURE: return PGPSignature;
}
return Invalid;
}
char *GpgME::Data::fileName() const
{
return gpgme_data_get_file_name(d->data);
}
GpgME::Error GpgME::Data::setFileName(const char *name)
{
return Error(gpgme_data_set_file_name(d->data, name));
}
GpgME::Error GpgME::Data::setFileName(const std::string &name)
{
return Error(gpgme_data_set_file_name(d->data, name.c_str()));
}
ssize_t GpgME::Data::read(void *buffer, size_t length)
{
return gpgme_data_read(d->data, buffer, length);
}
ssize_t GpgME::Data::write(const void *buffer, size_t length)
{
return gpgme_data_write(d->data, buffer, length);
}
off_t GpgME::Data::seek(off_t offset, int whence)
{
return gpgme_data_seek(d->data, offset, whence);
}
GpgME::Error GpgME::Data::rewind()
{
return Error(gpgme_data_rewind(d->data));
}
std::vector<GpgME::Key> GpgME::Data::toKeys(Protocol proto) const
{
std::vector<GpgME::Key> ret;
if (isNull()) {
return ret;
}
auto ctx = GpgME::Context::createForProtocol(proto);
if (!ctx) {
return ret;
}
if (gpgme_op_keylist_from_data_start (ctx->impl()->ctx, d->data, 0)) {
return ret;
}
gpgme_key_t key;
while (!gpgme_op_keylist_next (ctx->impl()->ctx, &key)) {
ret.push_back(GpgME::Key(key, false));
}
gpgme_data_seek (d->data, 0, SEEK_SET);
delete ctx;
return ret;
}
std::string GpgME::Data::toString()
{
std::string ret;
char buf[4096];
size_t nread;
seek (0, SEEK_SET);
while ((nread = read (buf, 4096)) > 0)
{
ret += std::string (buf, nread);
}
seek (0, SEEK_SET);
return ret;
}
GpgME::Error GpgME::Data::setFlag(const char *name, const char *value)
{
return Error(gpgme_data_set_flag(d->data, name, value));
}
+
+GpgME::Error GpgME::Data::setSizeHint(uint64_t size)
+{
+ const std::string val = std::to_string(size);
+ return Error(gpgme_data_set_flag(d->data, "size-hint", val.c_str()));
+}
diff --git a/src/data.h b/src/data.h
index ea394804..178bc309 100644
--- a/src/data.h
+++ b/src/data.h
@@ -1,145 +1,149 @@
/*
data.h - wraps a gpgme data object
Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB
This file is part of GPGME++.
GPGME++ is free software; you can redistribute it and/or
modify it under the terms of the GNU Library 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 Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with GPGME++; see the file COPYING.LIB. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef __GPGMEPP_DATA_H__
#define __GPGMEPP_DATA_H__
#include "global.h"
#include "key.h"
#include <sys/types.h> // for size_t, off_t
+#include <cstdint> // unit64_t
#include <cstdio> // FILE
#include <algorithm>
#include <memory>
namespace GpgME
{
class DataProvider;
class Error;
class GPGMEPP_EXPORT Data
{
struct Null {
Null() {}
};
public:
/* implicit */ Data(const Null &);
Data();
explicit Data(gpgme_data_t data);
// Memory-Based Data Buffers:
Data(const char *buffer, size_t size, bool copy = true);
explicit Data(const char *filename);
Data(const char *filename, off_t offset, size_t length);
Data(std::FILE *fp, off_t offset, size_t length);
// File-Based Data Buffers:
explicit Data(std::FILE *fp);
explicit Data(int fd);
// Callback-Based Data Buffers:
explicit Data(DataProvider *provider);
static const Null null;
Data(const Data &other) = default;
const Data &operator=(Data other)
{
swap(other);
return *this;
}
void swap(Data &other)
{
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
enum Encoding {
AutoEncoding,
BinaryEncoding,
Base64Encoding,
ArmorEncoding,
MimeEncoding,
UrlEncoding,
UrlEscEncoding,
Url0Encoding,
};
Encoding encoding() const;
Error setEncoding(Encoding encoding);
enum Type {
Invalid,
Unknown,
PGPSigned,
PGPOther,
PGPKey,
CMSSigned,
CMSEncrypted,
CMSOther,
X509Cert,
PKCS12,
PGPEncrypted,
PGPSignature,
};
Type type() const;
char *fileName() const;
Error setFileName(const char *name);
Error setFileName(const std::string &name);
ssize_t read(void *buffer, size_t length);
ssize_t write(const void *buffer, size_t length);
off_t seek(off_t offset, int whence);
/* Convenience function to do a seek (0, SEEK_SET). */
Error rewind();
/** Try to parse the data to a key object using the
* Protocol proto. Returns an empty list on error.*/
std::vector<Key> toKeys(const Protocol proto = Protocol::OpenPGP) const;
/** Return a copy of the data as std::string. Sets seek pos to 0 */
std::string toString();
/** See gpgme_data_set_flag */
Error setFlag(const char *name, const char *value);
+ /** Set a size hint for this data e.g. for progress calculations. */
+ Error setSizeHint(uint64_t size);
+
class Private;
Private *impl()
{
return d.get();
}
const Private *impl() const
{
return d.get();
}
private:
std::shared_ptr<Private> d;
};
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Data)
#endif // __GPGMEPP_DATA_H__

File Metadata

Mime Type
text/x-diff
Expires
Mon, May 12, 6:51 PM (13 h, 22 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
35/2e/a71a348235c29b02d3cf79222873

Event Timeline