← Back to branch summary

~noskcaj/ubuntu/trusty/gpgme1.0/1.4.3

« back to all changes in this revision

Viewing changes to gpgme/data.c

  • Committer: Bazaar Package Importer
  • Author(s): Jose Carlos Garcia Sogo
  • Date: 2008-03-08 14:06:34 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080308140634-dom8okim5mdkz22o
Tags: 1.1.6-2
http://bugs.debian.org/469534
* Bump shlibs info, as this version added some new symbols (Closes: #469534)
* Urgency set to medium, as this package has yet transitioned to lenny.
* debian/control: add Vcs-Browser info 

Show diffs side-by-side

added added

removed removed

Lines of Context:
gpgme/data.c
1
1
/* data.c - An abstraction for data objects.
2
 
   Copyright (C) 2002, 2003, 2004, 2005 g10 Code GmbH
 
2
   Copyright (C) 2002, 2003, 2004, 2005, 2007 g10 Code GmbH
3
3
 
4
4
   This file is part of GPGME.
5
5
 
32
32
#include "util.h"
33
33
#include "ops.h"
34
34
#include "priv-io.h"
 
35
#include "debug.h"
35
36
 
36
37
 
37
38
gpgme_error_t
72
73
ssize_t
73
74
gpgme_data_read (gpgme_data_t dh, void *buffer, size_t size)
74
75
{
 
76
  ssize_t res;
 
77
  TRACE_BEG2 (DEBUG_DATA, "gpgme_data_read", dh,
 
78
              "buffer=%p, size=%u", buffer, size);
 
79
 
75
80
  if (!dh)
76
81
    {
77
82
      errno = EINVAL;
78
 
      return -1;
 
83
      return TRACE_SYSRES (-1);
79
84
    }
80
85
  if (!dh->cbs->read)
81
86
    {
82
87
      errno = ENOSYS;
83
 
      return -1;
 
88
      return TRACE_SYSRES (-1);
84
89
    }
85
 
  return (*dh->cbs->read) (dh, buffer, size);
 
90
  res = (*dh->cbs->read) (dh, buffer, size);
 
91
  return TRACE_SYSRES (res);
86
92
}
87
93
 
88
94
 
92
98
ssize_t
93
99
gpgme_data_write (gpgme_data_t dh, const void *buffer, size_t size)
94
100
{
 
101
  ssize_t res;
 
102
  TRACE_BEG2 (DEBUG_DATA, "gpgme_data_write", dh,
 
103
              "buffer=%p, size=%u", buffer, size);
 
104
 
95
105
  if (!dh)
96
106
    {
97
107
      errno = EINVAL;
98
 
      return -1;
 
108
      return TRACE_SYSRES (-1);
99
109
    }
100
110
  if (!dh->cbs->write)
101
111
    {
102
112
      errno = ENOSYS;
103
 
      return -1;
 
113
      return TRACE_SYSRES (-1);
104
114
    }
105
 
  return (*dh->cbs->write) (dh, buffer, size);
 
115
  res = (*dh->cbs->write) (dh, buffer, size);
 
116
  return TRACE_SYSRES (res);
106
117
}
107
118
 
108
119
 
112
123
off_t
113
124
gpgme_data_seek (gpgme_data_t dh, off_t offset, int whence)
114
125
{
 
126
  TRACE_BEG2 (DEBUG_DATA, "gpgme_data_seek", dh,
 
127
              "offset=%lli, whence=%i", offset, whence);
 
128
 
115
129
  if (!dh)
116
130
    {
117
131
      errno = EINVAL;
118
 
      return -1;
 
132
      return TRACE_SYSRES (-1);
119
133
    }
120
134
  if (!dh->cbs->seek)
121
135
    {
122
136
      errno = ENOSYS;
123
 
      return -1;
 
137
      return TRACE_SYSRES (-1);
124
138
    }
125
139
 
126
140
  /* For relative movement, we must take into account the actual
132
146
  if (offset >= 0)
133
147
    dh->pending_len = 0;
134
148
 
135
 
  return offset;
 
149
  return TRACE_SYSRES (offset);
136
150
}
137
151
 
138
152
 
140
154
void
141
155
gpgme_data_release (gpgme_data_t dh)
142
156
{
 
157
  TRACE (DEBUG_DATA, "gpgme_data_release", dh);
 
158
 
143
159
  if (!dh)
144
160
    return;
145
161
 
154
170
gpgme_data_encoding_t
155
171
gpgme_data_get_encoding (gpgme_data_t dh)
156
172
{
 
173
  TRACE1 (DEBUG_DATA, "gpgme_data_get_encoding", dh,
 
174
          "dh->encoding=%i", dh ? dh->encoding : GPGME_DATA_ENCODING_NONE);
157
175
  return dh ? dh->encoding : GPGME_DATA_ENCODING_NONE;
158
176
}
159
177
 
163
181
gpgme_error_t
164
182
gpgme_data_set_encoding (gpgme_data_t dh, gpgme_data_encoding_t enc)
165
183
{
 
184
  TRACE_BEG1 (DEBUG_DATA, "gpgme_data_set_encoding", dh,
 
185
              "encoding=%i", enc);
166
186
  if (!dh)
167
 
    return gpg_error (GPG_ERR_INV_VALUE);
 
187
    return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
168
188
  if (enc < 0 || enc > GPGME_DATA_ENCODING_ARMOR)
169
 
    return gpg_error (GPG_ERR_INV_VALUE);
 
189
    return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
170
190
  dh->encoding = enc;
171
 
  return 0;
 
191
  return TRACE_ERR (0);
172
192
}
173
193
 
174
194
 
177
197
gpgme_error_t
178
198
gpgme_data_set_file_name (gpgme_data_t dh, const char *file_name)
179
199
{
 
200
  TRACE_BEG1 (DEBUG_DATA, "gpgme_data_set_file_name", dh,
 
201
              "file_name=%s", file_name);
 
202
 
180
203
  if (!dh)
181
 
    return gpg_error (GPG_ERR_INV_VALUE);
 
204
    return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
182
205
 
183
206
  if (dh->file_name)
184
207
    free (dh->file_name);
185
208
 
186
 
  dh->file_name = strdup (file_name);
187
 
  if (!dh->file_name)
188
 
    return gpg_error_from_errno (errno);
 
209
  if (file_name)
 
210
    {
 
211
      dh->file_name = strdup (file_name);
 
212
      if (!dh->file_name)
 
213
        return TRACE_ERR (gpg_error_from_errno (errno));
 
214
    }
 
215
  else
 
216
    dh->file_name = 0;
189
217
 
190
 
  return 0;
 
218
  return TRACE_ERR (0);
191
219
}
192
220
 
 
221
 
193
222
/* Get the file name associated with the data object with handle DH,
194
223
   or NULL if there is none.  */
195
224
char *
196
225
gpgme_data_get_file_name (gpgme_data_t dh)
197
226
{
198
227
  if (!dh)
199
 
    return NULL;
 
228
    {
 
229
      TRACE (DEBUG_DATA, "gpgme_data_get_file_name", dh);
 
230
      return NULL;
 
231
    }
200
232
 
 
233
  TRACE1 (DEBUG_DATA, "gpgme_data_get_file_name", dh,
 
234
          "dh->file_name=%s", dh->file_name);
201
235
  return dh->file_name;
202
236
}
203
237
 
211
245
  char buffer[BUFFER_SIZE];
212
246
  char *bufp = buffer;
213
247
  ssize_t buflen;
 
248
  TRACE_BEG1 (DEBUG_CTX, "_gpgme_data_inbound_handler", dh,
 
249
              "fd=0x%x", fd);
214
250
 
215
251
  buflen = _gpgme_io_read (fd, buffer, BUFFER_SIZE);
216
252
  if (buflen < 0)
218
254
  if (buflen == 0)
219
255
    {
220
256
      _gpgme_io_close (fd);
221
 
      return 0;
 
257
      return TRACE_ERR (0);
222
258
    }
223
259
 
224
260
  do
225
261
    {
226
262
      ssize_t amt = gpgme_data_write (dh, bufp, buflen);
227
263
      if (amt == 0 || (amt < 0 && errno != EINTR))
228
 
        return gpg_error_from_errno (errno);
 
264
        return TRACE_ERR (gpg_error_from_errno (errno));
229
265
      bufp += amt;
230
266
      buflen -= amt;
231
267
    }
232
268
  while (buflen > 0);
233
 
  return 0;
 
269
  return TRACE_ERR (0);
234
270
}
235
271
 
236
272
 
239
275
{
240
276
  gpgme_data_t dh = (gpgme_data_t) opaque;
241
277
  ssize_t nwritten;
 
278
  TRACE_BEG1 (DEBUG_CTX, "_gpgme_data_outbound_handler", dh,
 
279
              "fd=0x%x", fd);
242
280
 
243
281
  if (!dh->pending_len)
244
282
    {
245
283
      ssize_t amt = gpgme_data_read (dh, dh->pending, BUFFER_SIZE);
246
284
      if (amt < 0)
247
 
        return gpg_error_from_errno (errno);
 
285
        return TRACE_ERR (gpg_error_from_errno (errno));
248
286
      if (amt == 0)
249
287
        {
250
288
          _gpgme_io_close (fd);
251
 
          return 0;
 
289
          return TRACE_ERR (0);
252
290
        }
253
291
      dh->pending_len = amt;
254
292
    }
255
293
 
256
294
  nwritten = _gpgme_io_write (fd, dh->pending, dh->pending_len);
257
295
  if (nwritten == -1 && errno == EAGAIN)
258
 
    return 0;
 
296
    return TRACE_ERR (0);
259
297
 
260
298
  if (nwritten == -1 && errno == EPIPE)
261
299
    {
264
302
         end is going to tell us what happened on some other channel.
265
303
         Silently close our end.  */
266
304
      _gpgme_io_close (fd);
267
 
      return 0;
 
305
      return TRACE_ERR (0);
268
306
    }
269
307
 
270
308
  if (nwritten <= 0)
271
 
    return gpg_error_from_errno (errno);
 
309
    return TRACE_ERR (gpg_error_from_errno (errno));
272
310
 
273
311
  if (nwritten < dh->pending_len)
274
312
    memmove (dh->pending, dh->pending + nwritten, dh->pending_len - nwritten);
275
313
  dh->pending_len -= nwritten;
276
 
  return 0;
 
314
  return TRACE_ERR (0);
 
315
}
 
316
 
 
317
 
 
318
/* Get the file descriptor associated with DH, if possible.  Otherwise
 
319
   return -1.  */
 
320
int
 
321
_gpgme_data_get_fd (gpgme_data_t dh)
 
322
{
 
323
  if (!dh || !dh->cbs->get_fd)
 
324
    return -1;
 
325
  return (*dh->cbs->get_fd) (dh);
277
326
}