← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gpgme/data-mem.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-mem.c
1
1
/* data-mem.c - A memory based data object.
2
 
   Copyright (C) 2002, 2003, 2004 g10 Code GmbH
 
2
   Copyright (C) 2002, 2003, 2004, 2007 g10 Code GmbH
3
3
 
4
4
   This file is part of GPGME.
5
5
 
30
30
 
31
31
#include "data.h"
32
32
#include "util.h"
 
33
#include "debug.h"
33
34
 
34
35
 
35
36
static ssize_t
157
158
    mem_read,
158
159
    mem_write,
159
160
    mem_seek,
160
 
    mem_release
 
161
    mem_release,
 
162
    NULL
161
163
  };
162
164
 
163
165
 
164
166
/* Create a new data buffer and return it in R_DH.  */
165
167
gpgme_error_t
166
 
gpgme_data_new (gpgme_data_t *dh)
 
168
gpgme_data_new (gpgme_data_t *r_dh)
167
169
{
168
 
  gpgme_error_t err = _gpgme_data_new (dh, &mem_cbs);
 
170
  gpgme_error_t err;
 
171
  TRACE_BEG (DEBUG_DATA, "gpgme_data_new", r_dh);
 
172
 
 
173
  err = _gpgme_data_new (r_dh, &mem_cbs);
 
174
 
169
175
  if (err)
170
 
    return err;
 
176
    return TRACE_ERR (err);
171
177
 
172
 
  return 0;
 
178
  return TRACE_SUC1 ("r_dh=%p", *r_dh);
173
179
}
174
180
 
175
181
 
177
183
   BUFFER.  If COPY is zero, copying is delayed until necessary, and
178
184
   the data is taken from the original location when needed.  */
179
185
gpgme_error_t
180
 
gpgme_data_new_from_mem (gpgme_data_t *dh, const char *buffer,
 
186
gpgme_data_new_from_mem (gpgme_data_t *r_dh, const char *buffer,
181
187
                         size_t size, int copy)
182
188
{
183
 
  gpgme_error_t err = _gpgme_data_new (dh, &mem_cbs);
 
189
  gpgme_error_t err;
 
190
  TRACE_BEG4 (DEBUG_DATA, "gpgme_data_new_from_mem", r_dh,
 
191
              "buffer=%p, size=%u, copy=%i (%s)", buffer, size,
 
192
              copy, copy ? "yes" : "no");
 
193
 
 
194
  err = _gpgme_data_new (r_dh, &mem_cbs);
184
195
  if (err)
185
 
    return err;
 
196
    return TRACE_ERR (err);
186
197
 
187
198
  if (copy)
188
199
    {
189
200
      char *bufcpy = malloc (size);
190
201
      if (!bufcpy)
191
 
        _gpgme_data_release (*dh);
 
202
        {
 
203
          int saved_errno = errno;
 
204
          _gpgme_data_release (*r_dh);
 
205
          return TRACE_ERR (gpg_error_from_errno (saved_errno));
 
206
        }
192
207
      memcpy (bufcpy, buffer, size);
193
 
      (*dh)->data.mem.buffer = bufcpy;
 
208
      (*r_dh)->data.mem.buffer = bufcpy;
194
209
    }
195
210
  else
196
 
    (*dh)->data.mem.orig_buffer = buffer;
 
211
    (*r_dh)->data.mem.orig_buffer = buffer;
197
212
  
198
 
  (*dh)->data.mem.size = size;
199
 
  (*dh)->data.mem.length = size;
200
 
  return 0;
 
213
  (*r_dh)->data.mem.size = size;
 
214
  (*r_dh)->data.mem.length = size;
 
215
  return TRACE_SUC1 ("dh=%p", *r_dh);
201
216
}
202
217
 
203
218
 
209
224
{
210
225
  char *str = NULL;
211
226
 
 
227
  TRACE_BEG1 (DEBUG_DATA, "gpgme_data_release_and_get_mem", dh,
 
228
              "r_len=%p", r_len);
 
229
 
212
230
  if (!dh || dh->cbs != &mem_cbs)
213
 
    return NULL;
 
231
    {
 
232
      gpgme_data_release (dh);
 
233
      TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
 
234
      return NULL;
 
235
    }
214
236
 
215
237
  str = dh->data.mem.buffer;
216
238
  if (!str && dh->data.mem.orig_buffer)
217
239
    {
218
240
      str = malloc (dh->data.mem.length);
219
241
      if (!str)
220
 
        return NULL;
 
242
        {
 
243
          int saved_errno = errno;
 
244
          gpgme_data_release (dh);
 
245
          TRACE_ERR (gpg_error_from_errno (saved_errno));
 
246
          return NULL;
 
247
        }
221
248
      memcpy (str, dh->data.mem.orig_buffer, dh->data.mem.length);
222
249
    }
 
250
  else
 
251
    /* Prevent mem_release from releasing the buffer memory.  We must
 
252
       not fail from this point.  */
 
253
    dh->data.mem.buffer = NULL;
223
254
 
224
255
  if (r_len)
225
256
    *r_len = dh->data.mem.length;
226
257
 
 
258
  gpgme_data_release (dh);
 
259
 
 
260
  if (r_len)
 
261
    {
 
262
      TRACE_SUC2 ("buffer=%p, len=%u", str, *r_len);
 
263
    }
 
264
  else
 
265
    {
 
266
      TRACE_SUC1 ("buffer=%p", str);
 
267
    }
227
268
  return str;
228
269
}
229
270
 
232
273
void
233
274
gpgme_free (void *buffer)
234
275
{
 
276
  TRACE (DEBUG_DATA, "gpgme_free", buffer);
 
277
 
235
278
  if (buffer)
236
279
    free (buffer);
237
280
}
238