cpp, qt: Include config.h
[gpgme.git] / lang / cpp / src / data.cpp
1 /*
2   data.cpp - wraps a gpgme data object
3   Copyright (C) 2003 Klarälvdalens Datakonsult AB
4
5   This file is part of GPGME++.
6
7   GPGME++ is free software; you can redistribute it and/or
8   modify it under the terms of the GNU Library General Public
9   License as published by the Free Software Foundation; either
10   version 2 of the License, or (at your option) any later version.
11
12   GPGME++ is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU Library General Public License for more details.
16
17   You should have received a copy of the GNU Library General Public License
18   along with GPGME++; see the file COPYING.LIB.  If not, write to the
19   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20   Boston, MA 02110-1301, USA.
21 */
22
23 #ifdef HAVE_CONFIG_H
24  #include "config.h"
25 #endif
26
27 #include "data_p.h"
28 #include <error.h>
29 #include <interfaces/dataprovider.h>
30
31 #include <gpgme.h>
32
33 #ifndef NDEBUG
34 #include <iostream>
35 #endif
36
37 GpgME::Data::Private::~Private()
38 {
39     if (data) {
40         gpgme_data_release(data);
41     }
42 }
43
44 const GpgME::Data::Null GpgME::Data::null;
45
46 GpgME::Data::Data()
47 {
48     gpgme_data_t data;
49     const gpgme_error_t e = gpgme_data_new(&data);
50     d.reset(new Private(e ? 0 : data));
51 }
52
53 GpgME::Data::Data(const Null &)
54     : d(new Private(0))
55 {
56
57 }
58
59 GpgME::Data::Data(gpgme_data_t data)
60     : d(new Private(data))
61 {
62
63 }
64
65 GpgME::Data::Data(const char *buffer, size_t size, bool copy)
66 {
67     gpgme_data_t data;
68     const gpgme_error_t e = gpgme_data_new_from_mem(&data, buffer, size, int(copy));
69     std::string sizestr = std::to_string(size);
70     // Ignore errors as this is optional
71     gpgme_data_set_flag(data, "size-hint", sizestr.c_str());
72     d.reset(new Private(e ? 0 : data));
73 }
74
75 GpgME::Data::Data(const char *filename)
76 {
77     gpgme_data_t data;
78     const gpgme_error_t e = gpgme_data_new(&data);
79     d.reset(new Private(e ? 0 : data));
80     if (!e) {
81         setFileName(filename);
82     }
83 }
84
85 GpgME::Data::Data(const char *filename, off_t offset, size_t length)
86 {
87     gpgme_data_t data;
88     const gpgme_error_t e = gpgme_data_new_from_filepart(&data, filename, 0, offset, length);
89     d.reset(new Private(e ? 0 : data));
90 }
91
92 GpgME::Data::Data(FILE *fp)
93 {
94     gpgme_data_t data;
95     const gpgme_error_t e = gpgme_data_new_from_stream(&data, fp);
96     d.reset(new Private(e ? 0 : data));
97 }
98
99 GpgME::Data::Data(FILE *fp, off_t offset, size_t length)
100 {
101     gpgme_data_t data;
102     const gpgme_error_t e = gpgme_data_new_from_filepart(&data, 0, fp, offset, length);
103     d.reset(new Private(e ? 0 : data));
104 }
105
106 GpgME::Data::Data(int fd)
107 {
108     gpgme_data_t data;
109     const gpgme_error_t e = gpgme_data_new_from_fd(&data, fd);
110     d.reset(new Private(e ? 0 : data));
111 }
112
113 GpgME::Data::Data(DataProvider *dp)
114 {
115     d.reset(new Private);
116     if (!dp) {
117         return;
118     }
119     if (!dp->isSupported(DataProvider::Read)) {
120         d->cbs.read = 0;
121     }
122     if (!dp->isSupported(DataProvider::Write)) {
123         d->cbs.write = 0;
124     }
125     if (!dp->isSupported(DataProvider::Seek)) {
126         d->cbs.seek = 0;
127     }
128     if (!dp->isSupported(DataProvider::Release)) {
129         d->cbs.release = 0;
130     }
131     const gpgme_error_t e = gpgme_data_new_from_cbs(&d->data, &d->cbs, dp);
132     if (e) {
133         d->data = 0;
134     }
135     if (dp->isSupported(DataProvider::Seek)) {
136         off_t size = seek(0, SEEK_END);
137         seek(0, SEEK_SET);
138         std::string sizestr = std::to_string(size);
139         // Ignore errors as this is optional
140         gpgme_data_set_flag(d->data, "size-hint", sizestr.c_str());
141     }
142 #ifndef NDEBUG
143     //std::cerr << "GpgME::Data(): DataProvider supports: "
144     //    << ( d->cbs.read ? "read" : "no read" ) << ", "
145     //    << ( d->cbs.write ? "write" : "no write" ) << ", "
146     //    << ( d->cbs.seek ? "seek" : "no seek" ) << ", "
147     //    << ( d->cbs.release ? "release" : "no release" ) << std::endl;
148 #endif
149 }
150
151 bool GpgME::Data::isNull() const
152 {
153     return !d || !d->data;
154 }
155
156 GpgME::Data::Encoding GpgME::Data::encoding() const
157 {
158     switch (gpgme_data_get_encoding(d->data)) {
159     case GPGME_DATA_ENCODING_NONE:   return AutoEncoding;
160     case GPGME_DATA_ENCODING_BINARY: return BinaryEncoding;
161     case GPGME_DATA_ENCODING_BASE64: return Base64Encoding;
162     case GPGME_DATA_ENCODING_ARMOR:  return ArmorEncoding;
163     case GPGME_DATA_ENCODING_MIME:   return MimeEncoding;
164     }
165     return AutoEncoding;
166 }
167
168 GpgME::Error GpgME::Data::setEncoding(Encoding enc)
169 {
170     gpgme_data_encoding_t ge = GPGME_DATA_ENCODING_NONE;
171     switch (enc) {
172     case AutoEncoding:   ge = GPGME_DATA_ENCODING_NONE;   break;
173     case BinaryEncoding: ge = GPGME_DATA_ENCODING_BINARY; break;
174     case Base64Encoding: ge = GPGME_DATA_ENCODING_BASE64; break;
175     case ArmorEncoding:  ge = GPGME_DATA_ENCODING_ARMOR;  break;
176     case MimeEncoding:   ge = GPGME_DATA_ENCODING_MIME;  break;
177     }
178     return Error(gpgme_data_set_encoding(d->data, ge));
179 }
180
181 GpgME::Data::Type GpgME::Data::type() const
182 {
183     if (isNull()) {
184         return Invalid;
185     }
186     switch (gpgme_data_identify(d->data, 0)) {
187     case GPGME_DATA_TYPE_INVALID:       return Invalid;
188     case GPGME_DATA_TYPE_UNKNOWN:       return Unknown;
189     case GPGME_DATA_TYPE_PGP_SIGNED:    return PGPSigned;
190     case GPGME_DATA_TYPE_PGP_OTHER:     return PGPOther;
191     case GPGME_DATA_TYPE_PGP_KEY:       return PGPKey;
192     case GPGME_DATA_TYPE_CMS_SIGNED:    return CMSSigned;
193     case GPGME_DATA_TYPE_CMS_ENCRYPTED: return CMSEncrypted;
194     case GPGME_DATA_TYPE_CMS_OTHER:     return CMSOther;
195     case GPGME_DATA_TYPE_X509_CERT:     return X509Cert;
196     case GPGME_DATA_TYPE_PKCS12:        return PKCS12;
197     case GPGME_DATA_TYPE_PGP_ENCRYPTED: return PGPEncrypted;
198     case GPGME_DATA_TYPE_PGP_SIGNATURE: return PGPSignature;
199     }
200     return Invalid;
201 }
202
203 char *GpgME::Data::fileName() const
204 {
205     return gpgme_data_get_file_name(d->data);
206 }
207
208 GpgME::Error GpgME::Data::setFileName(const char *name)
209 {
210     return Error(gpgme_data_set_file_name(d->data, name));
211 }
212
213 ssize_t GpgME::Data::read(void *buffer, size_t length)
214 {
215     return gpgme_data_read(d->data, buffer, length);
216 }
217
218 ssize_t GpgME::Data::write(const void *buffer, size_t length)
219 {
220     return gpgme_data_write(d->data, buffer, length);
221 }
222
223 off_t GpgME::Data::seek(off_t offset, int whence)
224 {
225     return gpgme_data_seek(d->data, offset, whence);
226 }