2007-07-17 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / data-compat.c
1 /* data-compat.c - Compatibility interfaces for data objects.
2    Copyright (C) 2002, 2003, 2004, 2007 g10 Code GmbH
3  
4    This file is part of GPGME.
5  
6    GPGME is free software; you can redistribute it and/or modify it
7    under the terms of the GNU Lesser General Public License as
8    published by the Free Software Foundation; either version 2.1 of
9    the License, or (at your option) any later version.
10    
11    GPGME is distributed in the hope that it will be useful, but
12    WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15    
16    You should have received a copy of the GNU Lesser General Public
17    License along with this program; if not, write to the Free Software
18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19    02111-1307, USA.  */
20
21 #if HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <errno.h>
26 #include <sys/time.h>
27 #include <sys/stat.h>
28 #include <stdlib.h>
29
30 #include "data.h"
31 #include "util.h"
32 #include "debug.h"
33
34 \f
35 /* Create a new data buffer filled with LENGTH bytes starting from
36    OFFSET within the file FNAME or stream STREAM (exactly one must be
37    non-zero).  */
38 gpgme_error_t
39 gpgme_data_new_from_filepart (gpgme_data_t *r_dh, const char *fname,
40                               FILE *stream, off_t offset, size_t length)
41 {
42   gpgme_error_t err;
43   char *buf = NULL;
44   int res;
45
46   TRACE_BEG4 (DEBUG_DATA, "gpgme_data_new_from_filepart", r_dh,
47               "file_name=%s, stream=%p, offset=%lli, length=%u",
48               fname, stream, offset, length);
49
50   if (stream && fname)
51     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
52
53   if (fname)
54     stream = fopen (fname, "rb");
55   if (!stream)
56     return TRACE_ERR (gpg_error_from_errno (errno));
57
58 #ifdef HAVE_FSEEKO
59   res = fseeko (stream, offset, SEEK_SET);
60 #else
61   /* FIXME: Check for overflow, or at least bail at compilation.  */
62   res = fseek (stream, offset, SEEK_SET);
63 #endif
64
65   if (res)
66     {
67       int saved_errno = errno;
68       if (fname)
69         fclose (stream);
70       return TRACE_ERR (gpg_error_from_errno (saved_errno));
71     }
72
73   buf = malloc (length);
74   if (!buf)
75     {
76       int saved_errno = errno;
77       if (fname)
78         fclose (stream);
79       return TRACE_ERR (gpg_error_from_errno (saved_errno));
80     }
81
82   while (fread (buf, length, 1, stream) < 1
83          && ferror (stream) && errno == EINTR);
84   if (ferror (stream))
85     {
86       int saved_errno = errno;
87       if (buf)
88         free (buf);
89       if (fname)
90         fclose (stream);
91       return TRACE_ERR (gpg_error_from_errno (saved_errno));
92     }
93
94   if (fname)
95     fclose (stream);
96
97   err = gpgme_data_new (r_dh);
98   if (err)
99     {
100       if (buf)
101         free (buf);
102       return err;
103     }
104
105   (*r_dh)->data.mem.buffer = buf;
106   (*r_dh)->data.mem.size = length;
107   (*r_dh)->data.mem.length = length;
108
109   return TRACE_SUC1 ("r_dh=%p", *r_dh);
110 }
111
112 \f
113 /* Create a new data buffer filled with the content of file FNAME.
114    COPY must be non-zero (delayed reads are not supported yet).  */
115 gpgme_error_t
116 gpgme_data_new_from_file (gpgme_data_t *r_dh, const char *fname, int copy)
117 {
118   gpgme_error_t err;
119   struct stat statbuf;
120   TRACE_BEG3 (DEBUG_DATA, "gpgme_data_new_from_filepart", r_dh,
121               "file_name=%s, copy=%i (%s)", fname, copy, copy ? "yes" : "no");
122
123   if (!fname || !copy)
124     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
125
126   if (stat (fname, &statbuf) < 0)
127     return TRACE_ERR (gpg_error_from_errno (errno));
128
129   err = gpgme_data_new_from_filepart (r_dh, fname, NULL, 0, statbuf.st_size);
130   return TRACE_ERR (err);
131 }
132
133 \f
134 static int
135 gpgme_error_to_errno (gpgme_error_t err)
136 {
137   int res = gpg_err_code_to_errno (err);
138
139   if (!err)
140     {
141       switch (gpg_err_code (err))
142         {
143         case GPG_ERR_EOF:
144           res = 0;
145           break;
146         case GPG_ERR_INV_VALUE:
147           res = EINVAL;
148           break;
149         case GPG_ERR_NOT_SUPPORTED:
150           res = ENOSYS;
151           break;
152         default:
153           /* FIXME: Yeah, well.  */
154           res = EINVAL;
155           break;
156         }
157     }
158   TRACE3 (DEBUG_DATA, "gpgme:gpgme_error_to_errno", 0,
159           "mapping %s <%s> to: %s", gpgme_strerror (err),
160           gpgme_strsource (err), strerror (res));
161   errno = res;
162   return res ? -1 : 0;
163 }
164
165
166 static ssize_t
167 old_user_read (gpgme_data_t dh, void *buffer, size_t size)
168 {
169   gpgme_error_t err;
170   size_t amt;
171   TRACE_BEG2 (DEBUG_DATA, "gpgme:old_user_read", dh,
172               "buffer=%p, size=%u", buffer, size);
173
174   err = (*dh->data.old_user.cb) (dh->data.old_user.handle,
175                                  buffer, size, &amt);
176   if (err)
177     return TRACE_SYSRES (gpgme_error_to_errno (err));
178   return TRACE_SYSRES (amt);
179 }
180
181
182 static off_t
183 old_user_seek (gpgme_data_t dh, off_t offset, int whence)
184 {
185   gpgme_error_t err;
186   TRACE_BEG2 (DEBUG_DATA, "gpgme:old_user_seek", dh,
187               "offset=%llu, whence=%i", offset, whence);
188
189   if (whence != SEEK_SET || offset)
190     {
191       errno = EINVAL;
192       return TRACE_SYSRES (-1);
193     }
194   err = (*dh->data.old_user.cb) (dh->data.old_user.handle, NULL, 0, NULL);
195   if (err)
196     return TRACE_SYSRES (gpgme_error_to_errno (err));
197   return TRACE_SYSRES (0);
198 }
199
200
201 static struct _gpgme_data_cbs old_user_cbs =
202   {
203     old_user_read,
204     NULL,
205     old_user_seek,
206     NULL
207   };
208
209
210 /* Create a new data buffer which retrieves the data from the callback
211    function READ_CB.  */
212 gpgme_error_t
213 gpgme_data_new_with_read_cb (gpgme_data_t *r_dh,
214                              int (*read_cb) (void *, char *, size_t, size_t *),
215                              void *read_cb_value)
216 {
217   gpgme_error_t err;
218   TRACE_BEG2 (DEBUG_DATA, "gpgme_data_new_with_read_cb", r_dh,
219               "read_cb=%p/%p", read_cb, read_cb_value);
220
221   err = _gpgme_data_new (r_dh, &old_user_cbs);
222
223   if (err)
224     return TRACE_ERR (err);
225
226   (*r_dh)->data.old_user.cb = read_cb;
227   (*r_dh)->data.old_user.handle = read_cb_value;
228   return TRACE_ERR (0);
229 }
230
231 \f
232 gpgme_error_t
233 gpgme_data_rewind (gpgme_data_t dh)
234 {
235   gpgme_error_t err;
236   TRACE_BEG (DEBUG_DATA, "gpgme_data_rewind", dh);
237
238   err = (gpgme_data_seek (dh, 0, SEEK_SET) == -1)
239     ? gpg_error_from_errno (errno) : 0;
240
241   return TRACE_ERR (err);
242 }