2002-01-13 Marcus Brinkmann <marcus@g10code.de>
* gpgme.c: Various source clean ups, like renaming C to CTX where appropriate. (gpgme_new): Clear R_CTX before starting the work. (my_isdigit): Removed. (my_isxdigit): Likewise. * data.c: Various source clean ups. (gpgme_data_new_from_mem): Check BUFFER after clearing R_DH. (gpgme_data_new_with_read_cb): Similar for READ_CB. (gpgme_data_new_from_file): Loop over fread while EINTR. (gpgme_data_new_from_filepart): Rediddled a bit. Allow LENGTH to be zero. Loop over fread while EINTR. (my_isdigit): Removed. (my_isxdigit): Likewise.
This commit is contained in:
Marcus Brinkmann
parent
6d275b5d07
commit
d83e746a07
@ -1,3 +1,21 @@
|
||||
2002-01-13 Marcus Brinkmann <marcus@g10code.de>
|
||||
|
||||
* gpgme.c: Various source clean ups, like renaming C to CTX where
|
||||
appropriate.
|
||||
(gpgme_new): Clear R_CTX before starting the work.
|
||||
(my_isdigit): Removed.
|
||||
(my_isxdigit): Likewise.
|
||||
|
||||
* data.c: Various source clean ups.
|
||||
(gpgme_data_new_from_mem): Check BUFFER after clearing R_DH.
|
||||
(gpgme_data_new_with_read_cb): Similar for READ_CB.
|
||||
(gpgme_data_new_from_file): Loop over fread while EINTR.
|
||||
(gpgme_data_new_from_filepart): Rediddled a bit. Allow LENGTH to
|
||||
be zero. Loop over fread while EINTR.
|
||||
|
||||
(my_isdigit): Removed.
|
||||
(my_isxdigit): Likewise.
|
||||
|
||||
2001-12-21 Marcus Brinkmann <marcus@g10code.de>
|
||||
|
||||
* engine-gpgsm.c (_gpgme_gpgsm_new): Replace General_Error with
|
||||
|
||||
319
gpgme/data.c
319
gpgme/data.c
@ -1,6 +1,6 @@
|
||||
/* data.c
|
||||
* Copyright (C) 2000 Werner Koch (dd9jn)
|
||||
* Copyright (C) 2001 g10 Code GmbH
|
||||
* Copyright (C) 2001, 2002 g10 Code GmbH
|
||||
*
|
||||
* This file is part of GPGME.
|
||||
*
|
||||
@ -34,11 +34,9 @@
|
||||
#include "ops.h"
|
||||
#include "io.h"
|
||||
|
||||
/* When expanding an internal buffer, always extend it by ALLOC_CHUNK
|
||||
bytes at a time. */
|
||||
#define ALLOC_CHUNK 1024
|
||||
#define my_isdigit(a) ( (a) >='0' && (a) <= '9' )
|
||||
#define my_isxdigit(a) ( my_isdigit((a)) \
|
||||
|| ((a) >= 'A' && (a) <= 'F') \
|
||||
|| ((a) >= 'f' && (a) <= 'f') )
|
||||
|
||||
|
||||
/**
|
||||
@ -57,10 +55,13 @@ gpgme_data_new ( GpgmeData *r_dh )
|
||||
if (!r_dh)
|
||||
return mk_error (Invalid_Value);
|
||||
*r_dh = NULL;
|
||||
|
||||
dh = xtrycalloc (1, sizeof *dh);
|
||||
if (!dh)
|
||||
return mk_error (Out_Of_Core);
|
||||
|
||||
dh->mode = GPGME_DATA_MODE_INOUT;
|
||||
|
||||
*r_dh = dh;
|
||||
return 0;
|
||||
}
|
||||
@ -73,31 +74,40 @@ gpgme_data_new ( GpgmeData *r_dh )
|
||||
* @size: Size of the buffer
|
||||
* @copy: Flag wether a copy of the buffer should be used.
|
||||
*
|
||||
* Create a new data object and initialize with data
|
||||
* from the memory. A @copy with value %TRUE creates a copy of the
|
||||
* memory, a value of %FALSE uses the original memory of @buffer and the
|
||||
* caller has to make sure that this buffer is valid until gpgme_release_data()
|
||||
* is called.
|
||||
* Create a new data object and initialize with data from the memory.
|
||||
* A @copy with value %TRUE creates a copy of the memory, a value of
|
||||
* %FALSE uses the original memory of @buffer and the caller has to
|
||||
* make sure that this buffer is valid until gpgme_data_release() is
|
||||
* called.
|
||||
*
|
||||
* Return value: An error value or 0 for success.
|
||||
**/
|
||||
GpgmeError
|
||||
gpgme_data_new_from_mem ( GpgmeData *r_dh,
|
||||
const char *buffer, size_t size, int copy )
|
||||
gpgme_data_new_from_mem (GpgmeData *r_dh, const char *buffer, size_t size,
|
||||
int copy)
|
||||
{
|
||||
GpgmeData dh;
|
||||
GpgmeError err;
|
||||
|
||||
if (!r_dh || !buffer)
|
||||
if (!r_dh)
|
||||
return mk_error (Invalid_Value);
|
||||
*r_dh = NULL;
|
||||
if (!buffer)
|
||||
return mk_error (Invalid_Value);
|
||||
|
||||
err = gpgme_data_new (&dh);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
dh->type = GPGME_DATA_TYPE_MEM;
|
||||
dh->len = size;
|
||||
if (copy) {
|
||||
if (!copy)
|
||||
dh->data = buffer;
|
||||
else
|
||||
{
|
||||
dh->private_buffer = xtrymalloc (size);
|
||||
if ( !dh->private_buffer ) {
|
||||
if (!dh->private_buffer)
|
||||
{
|
||||
gpgme_data_release (dh);
|
||||
return mk_error (Out_Of_Core);
|
||||
}
|
||||
@ -106,10 +116,6 @@ gpgme_data_new_from_mem ( GpgmeData *r_dh,
|
||||
dh->data = dh->private_buffer;
|
||||
dh->writepos = size;
|
||||
}
|
||||
else {
|
||||
dh->data = buffer;
|
||||
}
|
||||
dh->type = GPGME_DATA_TYPE_MEM;
|
||||
|
||||
*r_dh = dh;
|
||||
return 0;
|
||||
@ -149,12 +155,17 @@ gpgme_data_new_with_read_cb ( GpgmeData *r_dh,
|
||||
GpgmeData dh;
|
||||
GpgmeError err;
|
||||
|
||||
if (!r_dh || !read_cb)
|
||||
if (!r_dh)
|
||||
return mk_error (Invalid_Value);
|
||||
*r_dh = NULL;
|
||||
|
||||
if (!read_cb)
|
||||
return mk_error (Invalid_Value);
|
||||
|
||||
err = gpgme_data_new (&dh);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
dh->type = GPGME_DATA_TYPE_CB;
|
||||
dh->mode = GPGME_DATA_MODE_OUT;
|
||||
dh->read_cb = read_cb;
|
||||
@ -164,6 +175,7 @@ gpgme_data_new_with_read_cb ( GpgmeData *r_dh,
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* gpgme_data_new_from_file:
|
||||
* @r_dh: returns the new data object
|
||||
@ -188,26 +200,29 @@ gpgme_data_new_from_file ( GpgmeData *r_dh, const char *fname, int copy )
|
||||
if (!r_dh)
|
||||
return mk_error (Invalid_Value);
|
||||
*r_dh = NULL;
|
||||
/* We only support copy for now - in future we might want to honor the
|
||||
* copy flag and just store a file pointer */
|
||||
if (!copy)
|
||||
return mk_error (Not_Implemented);
|
||||
if (!fname)
|
||||
return mk_error (Invalid_Value);
|
||||
|
||||
/* We only support copy for now. In future we might want to honor
|
||||
the copy flag and just store a file pointer. */
|
||||
if (!copy)
|
||||
return mk_error (Not_Implemented);
|
||||
|
||||
err = gpgme_data_new (&dh);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
fp = fopen (fname, "rb");
|
||||
if (!fp) {
|
||||
if (!fp)
|
||||
{
|
||||
int save_errno = errno;
|
||||
gpgme_data_release (dh);
|
||||
errno = save_errno;
|
||||
return mk_error (File_Error);
|
||||
}
|
||||
|
||||
if( fstat(fileno(fp), &st) ) {
|
||||
if (fstat(fileno(fp), &st))
|
||||
{
|
||||
int save_errno = errno;
|
||||
fclose (fp);
|
||||
gpgme_data_release (dh);
|
||||
@ -215,17 +230,22 @@ gpgme_data_new_from_file ( GpgmeData *r_dh, const char *fname, int copy )
|
||||
return mk_error (File_Error);
|
||||
}
|
||||
|
||||
/* We should check the length of the file and don't allow for to
|
||||
* large files */
|
||||
/* We should check the length of the file and don't allow for too
|
||||
large files. */
|
||||
dh->private_buffer = xtrymalloc (st.st_size);
|
||||
if ( !dh->private_buffer ) {
|
||||
if (!dh->private_buffer)
|
||||
{
|
||||
fclose (fp);
|
||||
gpgme_data_release (dh);
|
||||
return mk_error (Out_Of_Core);
|
||||
}
|
||||
dh->private_len = st.st_size;
|
||||
|
||||
if ( fread ( dh->private_buffer, dh->private_len, 1, fp ) != 1 ) {
|
||||
while (fread (dh->private_buffer, dh->private_len, 1, fp) < 1
|
||||
&& ferror (fp) && errno == EINTR);
|
||||
|
||||
if (ferror (fp))
|
||||
{
|
||||
int save_errno = errno;
|
||||
fclose (fp);
|
||||
gpgme_data_release (dh);
|
||||
@ -235,10 +255,10 @@ gpgme_data_new_from_file ( GpgmeData *r_dh, const char *fname, int copy )
|
||||
|
||||
fclose (fp);
|
||||
|
||||
dh->type = GPGME_DATA_TYPE_MEM;
|
||||
dh->len = dh->private_len;
|
||||
dh->data = dh->private_buffer;
|
||||
dh->writepos = dh->len;
|
||||
dh->type = GPGME_DATA_TYPE_MEM;
|
||||
|
||||
*r_dh = dh;
|
||||
return 0;
|
||||
@ -257,7 +277,7 @@ gpgme_data_new_from_file ( GpgmeData *r_dh, const char *fname, int copy )
|
||||
* starting at @offset of @file or @fp. Either a filename or an open
|
||||
* filepointer may be given.
|
||||
*
|
||||
|
||||
*
|
||||
* Return value: An error code or 0 on success. If the error code is
|
||||
* %GPGME_File_Error, the OS error code is held in %errno.
|
||||
**/
|
||||
@ -267,69 +287,75 @@ gpgme_data_new_from_filepart ( GpgmeData *r_dh, const char *fname, FILE *fp,
|
||||
{
|
||||
GpgmeData dh;
|
||||
GpgmeError err;
|
||||
int save_errno = 0;
|
||||
|
||||
if (!r_dh)
|
||||
return mk_error (Invalid_Value);
|
||||
*r_dh = NULL;
|
||||
if ( fname && fp ) /* these are mutual exclusive */
|
||||
return mk_error (Invalid_Value);
|
||||
if (!fname && !fp)
|
||||
return mk_error (Invalid_Value);
|
||||
if (!length)
|
||||
|
||||
if ((fname && fp) || (!fname && !fp))
|
||||
return mk_error (Invalid_Value);
|
||||
|
||||
err = gpgme_data_new (&dh);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
if (!fp) {
|
||||
fp = fopen (fname, "rb");
|
||||
if (!fp) {
|
||||
int save_errno = errno;
|
||||
gpgme_data_release (dh);
|
||||
errno = save_errno;
|
||||
return mk_error (File_Error);
|
||||
}
|
||||
}
|
||||
if (!length)
|
||||
goto out;
|
||||
|
||||
if ( fseek ( fp, (long)offset, SEEK_SET) ) {
|
||||
int save_errno = errno;
|
||||
if (fname)
|
||||
fclose (fp);
|
||||
gpgme_data_release (dh);
|
||||
errno = save_errno;
|
||||
return mk_error (File_Error);
|
||||
{
|
||||
fp = fopen (fname, "rb");
|
||||
if (!fp)
|
||||
{
|
||||
err = mk_error (File_Error);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
if (fseek (fp, (long) offset, SEEK_SET))
|
||||
{
|
||||
err = mk_error (File_Error);
|
||||
goto out;
|
||||
}
|
||||
|
||||
dh->private_buffer = xtrymalloc (length);
|
||||
if ( !dh->private_buffer ) {
|
||||
if (fname)
|
||||
fclose (fp);
|
||||
gpgme_data_release (dh);
|
||||
return mk_error (Out_Of_Core);
|
||||
if (!dh->private_buffer)
|
||||
{
|
||||
err = mk_error (Out_Of_Core);
|
||||
goto out;
|
||||
}
|
||||
dh->private_len = length;
|
||||
|
||||
if ( fread ( dh->private_buffer, dh->private_len, 1, fp ) != 1 ) {
|
||||
int save_errno = errno;
|
||||
if (fname)
|
||||
fclose (fp);
|
||||
gpgme_data_release (dh);
|
||||
errno = save_errno;
|
||||
return mk_error (File_Error);
|
||||
while (fread (dh->private_buffer, dh->private_len, 1, fp) < 1
|
||||
&& ferror (fp) && errno == EINTR);
|
||||
|
||||
if (ferror (fp))
|
||||
{
|
||||
err = mk_error (File_Error);
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (fname)
|
||||
fclose (fp);
|
||||
|
||||
dh->type = GPGME_DATA_TYPE_MEM;
|
||||
dh->len = dh->private_len;
|
||||
dh->data = dh->private_buffer;
|
||||
dh->writepos = dh->len;
|
||||
dh->type = GPGME_DATA_TYPE_MEM;
|
||||
|
||||
out:
|
||||
if (err)
|
||||
save_errno = errno;
|
||||
|
||||
if (fname && fp)
|
||||
fclose (fp);
|
||||
|
||||
if (err)
|
||||
{
|
||||
gpgme_data_release (dh);
|
||||
errno = save_errno;
|
||||
}
|
||||
else
|
||||
*r_dh = dh;
|
||||
return 0;
|
||||
return err;
|
||||
}
|
||||
|
||||
|
||||
@ -343,12 +369,14 @@ gpgme_data_new_from_filepart ( GpgmeData *r_dh, const char *fname, FILE *fp,
|
||||
void
|
||||
gpgme_data_release (GpgmeData dh)
|
||||
{
|
||||
if (dh) {
|
||||
if (dh)
|
||||
{
|
||||
xfree (dh->private_buffer);
|
||||
xfree (dh);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Release the data object @dh. @dh may be NULL in which case nothing
|
||||
* happens.
|
||||
@ -362,12 +390,15 @@ _gpgme_data_release_and_return_string ( GpgmeData dh )
|
||||
{
|
||||
char *val = NULL;
|
||||
|
||||
if (dh) {
|
||||
if (dh)
|
||||
{
|
||||
if (_gpgme_data_append (dh, "", 1)) /* append EOS */
|
||||
xfree (dh->private_buffer );
|
||||
else {
|
||||
else
|
||||
{
|
||||
val = dh->private_buffer;
|
||||
if ( !val && dh->data ) {
|
||||
if (!val && dh->data)
|
||||
{
|
||||
val = xtrymalloc (dh->len);
|
||||
if (val)
|
||||
memcpy (val, dh->data, dh->len);
|
||||
@ -378,6 +409,7 @@ _gpgme_data_release_and_return_string ( GpgmeData dh )
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* gpgme_data_release_and_get_mem:
|
||||
* @dh: the data object
|
||||
@ -398,10 +430,12 @@ gpgme_data_release_and_get_mem ( GpgmeData dh, size_t *r_len )
|
||||
|
||||
if (r_len)
|
||||
*r_len = 0;
|
||||
if (dh) {
|
||||
if (dh)
|
||||
{
|
||||
size_t len = dh->len;
|
||||
val = dh->private_buffer;
|
||||
if ( !val && dh->data ) {
|
||||
if (!val && dh->data)
|
||||
{
|
||||
val = xtrymalloc (len);
|
||||
if (val)
|
||||
memcpy (val, dh->data, len);
|
||||
@ -432,6 +466,7 @@ gpgme_data_get_type ( GpgmeData dh )
|
||||
return dh->type;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
_gpgme_data_set_mode (GpgmeData dh, GpgmeDataMode mode)
|
||||
{
|
||||
@ -447,6 +482,7 @@ _gpgme_data_get_mode ( GpgmeData dh )
|
||||
return dh->mode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* gpgme_data_rewind:
|
||||
* @dh: the data object
|
||||
@ -463,19 +499,23 @@ gpgme_data_rewind ( GpgmeData dh )
|
||||
if (!dh)
|
||||
return mk_error (Invalid_Value);
|
||||
|
||||
if ( dh->type == GPGME_DATA_TYPE_NONE
|
||||
|| dh->type == GPGME_DATA_TYPE_MEM ) {
|
||||
switch (dh->type)
|
||||
{
|
||||
case GPGME_DATA_TYPE_NONE:
|
||||
case GPGME_DATA_TYPE_MEM:
|
||||
dh->readpos = 0;
|
||||
}
|
||||
else if (dh->type == GPGME_DATA_TYPE_CB) {
|
||||
return 0;
|
||||
|
||||
case GPGME_DATA_TYPE_CB:
|
||||
dh->len = dh->readpos = 0;
|
||||
dh->read_cb_eof = 0;
|
||||
if (dh->read_cb (dh->read_cb_value, NULL, 0, NULL))
|
||||
return mk_error (Not_Implemented);
|
||||
}
|
||||
else
|
||||
return mk_error (General_Error);
|
||||
return 0;
|
||||
|
||||
default:
|
||||
return mk_error (General_Error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@ -506,53 +546,67 @@ gpgme_data_read ( GpgmeData dh, char *buffer, size_t length, size_t *nread )
|
||||
|
||||
if (!dh)
|
||||
return mk_error (Invalid_Value);
|
||||
if (dh->type == GPGME_DATA_TYPE_MEM ) {
|
||||
|
||||
switch (dh->type)
|
||||
{
|
||||
case GPGME_DATA_TYPE_MEM:
|
||||
nbytes = dh->len - dh->readpos;
|
||||
if ( !nbytes ) {
|
||||
if (!nbytes)
|
||||
{
|
||||
*nread = 0;
|
||||
return mk_error(EOF);
|
||||
}
|
||||
if (!buffer) {
|
||||
|
||||
if (!buffer)
|
||||
*nread = nbytes;
|
||||
}
|
||||
else {
|
||||
else
|
||||
{
|
||||
if (nbytes > length)
|
||||
nbytes = length;
|
||||
memcpy (buffer, dh->data + dh->readpos, nbytes);
|
||||
*nread = nbytes;
|
||||
dh->readpos += nbytes;
|
||||
}
|
||||
}
|
||||
else if (dh->type == GPGME_DATA_TYPE_CB) {
|
||||
if (!buffer) {
|
||||
return 0;
|
||||
|
||||
case GPGME_DATA_TYPE_CB:
|
||||
if (!buffer)
|
||||
{
|
||||
*nread = 0;
|
||||
return mk_error (Invalid_Type);
|
||||
}
|
||||
nbytes = dh->len - dh->readpos;
|
||||
if ( nbytes ) {
|
||||
/* we have unread data - return this */
|
||||
if (nbytes)
|
||||
{
|
||||
/* We have unread data - return this. */
|
||||
if (nbytes > length)
|
||||
nbytes = length;
|
||||
memcpy (buffer, dh->data + dh->readpos, nbytes);
|
||||
*nread = nbytes;
|
||||
dh->readpos += nbytes;
|
||||
}
|
||||
else { /* get the data from the callback */
|
||||
if (!dh->read_cb || dh->read_cb_eof) {
|
||||
else
|
||||
{
|
||||
/* Get the data from the callback. */
|
||||
if (!dh->read_cb || dh->read_cb_eof)
|
||||
{
|
||||
*nread = 0;
|
||||
return mk_error (EOF);
|
||||
}
|
||||
if (dh->read_cb (dh->read_cb_value, buffer, length, nread )) {
|
||||
if (dh->read_cb (dh->read_cb_value, buffer, length, nread))
|
||||
{
|
||||
*nread = 0;
|
||||
dh->read_cb_eof = 1;
|
||||
return mk_error (EOF);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
return mk_error (General_Error);
|
||||
return 0;
|
||||
|
||||
default:
|
||||
return mk_error (General_Error);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
GpgmeError
|
||||
_gpgme_data_unread (GpgmeData dh, const char *buffer, size_t length)
|
||||
@ -560,16 +614,16 @@ _gpgme_data_unread (GpgmeData dh, const char *buffer, size_t length )
|
||||
if (!dh)
|
||||
return mk_error (Invalid_Value);
|
||||
|
||||
if (dh->type == GPGME_DATA_TYPE_MEM ) {
|
||||
/* check that we don't unread more than we have yet read */
|
||||
if (dh->type == GPGME_DATA_TYPE_MEM)
|
||||
{
|
||||
/* Check that we don't unread more than we have yet read. */
|
||||
if (dh->readpos < length)
|
||||
return mk_error (Invalid_Value);
|
||||
/* No need to use the buffer for this data type */
|
||||
/* No need to use the buffer for this data type. */
|
||||
dh->readpos -= length;
|
||||
}
|
||||
else {
|
||||
else
|
||||
return mk_error (General_Error);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -583,9 +637,11 @@ _gpgme_data_get_as_string ( GpgmeData dh )
|
||||
{
|
||||
char *val = NULL;
|
||||
|
||||
if (dh) {
|
||||
if (dh)
|
||||
{
|
||||
val = xtrymalloc (dh->len+1);
|
||||
if ( val ) {
|
||||
if (val)
|
||||
{
|
||||
memcpy (val, dh->data, dh->len);
|
||||
val[dh->len] = 0;
|
||||
}
|
||||
@ -620,13 +676,15 @@ _gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
|
||||
{
|
||||
assert (dh);
|
||||
|
||||
if ( dh->type == GPGME_DATA_TYPE_NONE ) {
|
||||
/* convert it to a mem data type */
|
||||
if (dh->type == GPGME_DATA_TYPE_NONE)
|
||||
{
|
||||
/* Convert it to a mem data type. */
|
||||
assert (!dh->private_buffer);
|
||||
dh->type = GPGME_DATA_TYPE_MEM;
|
||||
dh->private_len = length < ALLOC_CHUNK? ALLOC_CHUNK : length;
|
||||
dh->private_buffer = xtrymalloc (dh->private_len);
|
||||
if (!dh->private_buffer) {
|
||||
if (!dh->private_buffer)
|
||||
{
|
||||
dh->private_len = 0;
|
||||
return mk_error (Out_Of_Core);
|
||||
}
|
||||
@ -640,14 +698,16 @@ _gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
|
||||
&& dh->mode != GPGME_DATA_MODE_IN)
|
||||
return mk_error (Invalid_Mode);
|
||||
|
||||
if ( !dh->private_buffer ) {
|
||||
/* we have to copy it now */
|
||||
if (!dh->private_buffer)
|
||||
{
|
||||
/* We have to copy it now. */
|
||||
assert (dh->data);
|
||||
dh->private_len = dh->len+length;
|
||||
if (dh->private_len < ALLOC_CHUNK)
|
||||
dh->private_len = ALLOC_CHUNK;
|
||||
dh->private_buffer = xtrymalloc (dh->private_len);
|
||||
if (!dh->private_buffer) {
|
||||
if (!dh->private_buffer)
|
||||
{
|
||||
dh->private_len = 0;
|
||||
return mk_error (Out_Of_Core);
|
||||
}
|
||||
@ -656,8 +716,9 @@ _gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
|
||||
dh->data = dh->private_buffer;
|
||||
}
|
||||
|
||||
/* allocate more memory if needed */
|
||||
if ( dh->writepos + length > dh->private_len ) {
|
||||
/* Allocate more memory if needed. */
|
||||
if (dh->writepos + length > dh->private_len)
|
||||
{
|
||||
char *p;
|
||||
size_t newlen = dh->private_len
|
||||
+ (length < ALLOC_CHUNK? ALLOC_CHUNK : length);
|
||||
@ -677,6 +738,7 @@ _gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
GpgmeError
|
||||
_gpgme_data_append_string (GpgmeData dh, const char *s)
|
||||
{
|
||||
@ -695,29 +757,36 @@ _gpgme_data_append_for_xml ( GpgmeData dh,
|
||||
if (!dh || !buffer)
|
||||
return mk_error (Invalid_Value);
|
||||
|
||||
do {
|
||||
for (text=NULL, s=buffer, n=len; n && !text; s++, n-- ) {
|
||||
do
|
||||
{
|
||||
for (text=NULL, s = buffer, n = len; n && !text; s++, n--)
|
||||
{
|
||||
if (*s == '<')
|
||||
text = "<";
|
||||
else if (*s == '>')
|
||||
text = ">"; /* not sure whether this is really needed */
|
||||
text = ">"; /* Not sure whether this is really needed. */
|
||||
else if (*s == '&')
|
||||
text = "&";
|
||||
else if (!*s)
|
||||
text = "�";
|
||||
}
|
||||
if (text) {
|
||||
s--; n++;
|
||||
if (text)
|
||||
{
|
||||
s--;
|
||||
n++;
|
||||
}
|
||||
if (s != buffer)
|
||||
rc = _gpgme_data_append (dh, buffer, s-buffer);
|
||||
if ( !rc && text) {
|
||||
if (!rc && text)
|
||||
{
|
||||
rc = _gpgme_data_append_string (dh, text);
|
||||
s++; n--;
|
||||
s++;
|
||||
n--;
|
||||
}
|
||||
buffer = s;
|
||||
len = n;
|
||||
} while ( !rc && len );
|
||||
}
|
||||
while (!rc && len);
|
||||
return rc;
|
||||
}
|
||||
|
||||
@ -759,7 +828,7 @@ hextobyte( const byte *s )
|
||||
}
|
||||
|
||||
/*
|
||||
* Append a string with percent style (%XX) escape characters as XML
|
||||
* Append a string with percent style (%XX) escape characters as XML.
|
||||
*/
|
||||
GpgmeError
|
||||
_gpgme_data_append_percentstring_for_xml (GpgmeData dh, const char *string)
|
||||
@ -770,8 +839,10 @@ _gpgme_data_append_percentstring_for_xml ( GpgmeData dh, const char *string )
|
||||
GpgmeError err;
|
||||
|
||||
d = buf = xtrymalloc (strlen (string));
|
||||
for (s=string; *s; s++ ) {
|
||||
if ( *s == '%' && (val=hextobyte (s+1)) != -1 ) {
|
||||
for (s = string; *s; s++)
|
||||
{
|
||||
if (*s == '%' && (val = hextobyte (s+1)) != -1)
|
||||
{
|
||||
*d++ = val;
|
||||
s += 2;
|
||||
}
|
||||
|
||||
176
gpgme/gpgme.c
176
gpgme/gpgme.c
@ -1,6 +1,6 @@
|
||||
/* gpgme.c - GnuPG Made Easy
|
||||
* Copyright (C) 2000 Werner Koch (dd9jn)
|
||||
* Copyright (C) 2001 g10 Code GmbH
|
||||
* Copyright (C) 2001, 2002 g10 Code GmbH
|
||||
*
|
||||
* This file is part of GPGME.
|
||||
*
|
||||
@ -29,11 +29,6 @@
|
||||
#include "context.h"
|
||||
#include "ops.h"
|
||||
|
||||
#define my_isdigit(a) ( (a) >='0' && (a) <= '9' )
|
||||
#define my_isxdigit(a) ( my_isdigit((a)) \
|
||||
|| ((a) >= 'A' && (a) <= 'F') \
|
||||
|| ((a) >= 'f' && (a) <= 'f') )
|
||||
|
||||
/**
|
||||
* gpgme_new:
|
||||
* @r_ctx: Returns the new context
|
||||
@ -46,13 +41,16 @@
|
||||
GpgmeError
|
||||
gpgme_new (GpgmeCtx *r_ctx)
|
||||
{
|
||||
GpgmeCtx c;
|
||||
GpgmeCtx ctx;
|
||||
|
||||
c = xtrycalloc ( 1, sizeof *c );
|
||||
if (!c)
|
||||
if (!r_ctx)
|
||||
return mk_error (Invalid_Value);
|
||||
*r_ctx = 0;
|
||||
ctx = xtrycalloc (1, sizeof *ctx);
|
||||
if (!ctx)
|
||||
return mk_error (Out_Of_Core);
|
||||
c->verbosity = 1;
|
||||
*r_ctx = c;
|
||||
ctx->verbosity = 1;
|
||||
*r_ctx = ctx;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -64,32 +62,32 @@ gpgme_new (GpgmeCtx *r_ctx)
|
||||
* Release all resources associated with the given context.
|
||||
**/
|
||||
void
|
||||
gpgme_release (GpgmeCtx c)
|
||||
gpgme_release (GpgmeCtx ctx)
|
||||
{
|
||||
if (!c)
|
||||
if (!ctx)
|
||||
return;
|
||||
_gpgme_engine_release (c->engine);
|
||||
_gpgme_release_result (c);
|
||||
gpgme_key_release (c->tmp_key);
|
||||
gpgme_data_release (c->help_data_1);
|
||||
gpgme_data_release (c->notation);
|
||||
gpgme_signers_clear (c);
|
||||
if (c->signers)
|
||||
xfree (c->signers);
|
||||
_gpgme_engine_release (ctx->engine);
|
||||
_gpgme_release_result (ctx);
|
||||
gpgme_key_release (ctx->tmp_key);
|
||||
gpgme_data_release (ctx->help_data_1);
|
||||
gpgme_data_release (ctx->notation);
|
||||
gpgme_signers_clear (ctx);
|
||||
if (ctx->signers)
|
||||
xfree (ctx->signers);
|
||||
/* FIXME: Release the key_queue. */
|
||||
xfree (c);
|
||||
xfree (ctx);
|
||||
}
|
||||
|
||||
void
|
||||
_gpgme_release_result (GpgmeCtx c)
|
||||
_gpgme_release_result (GpgmeCtx ctx)
|
||||
{
|
||||
_gpgme_release_verify_result (c->result.verify);
|
||||
_gpgme_release_decrypt_result (c->result.decrypt);
|
||||
_gpgme_release_sign_result (c->result.sign);
|
||||
_gpgme_release_encrypt_result (c->result.encrypt);
|
||||
_gpgme_release_passphrase_result (c->result.passphrase);
|
||||
memset (&c->result, 0, sizeof (c->result));
|
||||
_gpgme_set_op_info (c, NULL);
|
||||
_gpgme_release_verify_result (ctx->result.verify);
|
||||
_gpgme_release_decrypt_result (ctx->result.decrypt);
|
||||
_gpgme_release_sign_result (ctx->result.sign);
|
||||
_gpgme_release_encrypt_result (ctx->result.encrypt);
|
||||
_gpgme_release_passphrase_result (ctx->result.passphrase);
|
||||
memset (&ctx->result, 0, sizeof (ctx->result));
|
||||
_gpgme_set_op_info (ctx, NULL);
|
||||
}
|
||||
|
||||
|
||||
@ -101,13 +99,12 @@ _gpgme_release_result (GpgmeCtx c)
|
||||
* all kinds of operations. It is especially useful in a passphrase callback
|
||||
* to stop the system from asking another time for the passphrase.
|
||||
**/
|
||||
|
||||
void
|
||||
gpgme_cancel (GpgmeCtx c)
|
||||
gpgme_cancel (GpgmeCtx ctx)
|
||||
{
|
||||
return_if_fail (c);
|
||||
return_if_fail (ctx);
|
||||
|
||||
c->cancel = 1;
|
||||
ctx->cancel = 1;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -122,11 +119,11 @@ gpgme_cancel (GpgmeCtx c)
|
||||
* Return value: An XML string or NULL if no notation data is available.
|
||||
**/
|
||||
char *
|
||||
gpgme_get_notation ( GpgmeCtx c )
|
||||
gpgme_get_notation (GpgmeCtx ctx)
|
||||
{
|
||||
if ( !c->notation )
|
||||
if (!ctx->notation)
|
||||
return NULL;
|
||||
return _gpgme_data_get_as_string ( c->notation );
|
||||
return _gpgme_data_get_as_string (ctx->notation);
|
||||
}
|
||||
|
||||
|
||||
@ -158,43 +155,45 @@ gpgme_get_notation ( GpgmeCtx c )
|
||||
* Return value: NULL for no info available or an XML string
|
||||
**/
|
||||
char *
|
||||
gpgme_get_op_info ( GpgmeCtx c, int reserved )
|
||||
gpgme_get_op_info (GpgmeCtx ctx, int reserved)
|
||||
{
|
||||
if (!c || reserved)
|
||||
return NULL; /*invalid value */
|
||||
if (!ctx || reserved)
|
||||
return NULL; /* Invalid value. */
|
||||
|
||||
return _gpgme_data_get_as_string (c->op_info);
|
||||
return _gpgme_data_get_as_string (ctx->op_info);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Store the data object with the operation info in the
|
||||
* context. Caller should not use that object anymore.
|
||||
*/
|
||||
void
|
||||
_gpgme_set_op_info (GpgmeCtx c, GpgmeData info)
|
||||
_gpgme_set_op_info (GpgmeCtx ctx, GpgmeData info)
|
||||
{
|
||||
assert (c);
|
||||
assert (ctx);
|
||||
|
||||
gpgme_data_release (c->op_info);
|
||||
c->op_info = NULL;
|
||||
gpgme_data_release (ctx->op_info);
|
||||
ctx->op_info = NULL;
|
||||
|
||||
if (info)
|
||||
c->op_info = info;
|
||||
ctx->op_info = info;
|
||||
}
|
||||
|
||||
|
||||
GpgmeError
|
||||
gpgme_set_protocol (GpgmeCtx c, GpgmeProtocol prot)
|
||||
gpgme_set_protocol (GpgmeCtx ctx, GpgmeProtocol protocol)
|
||||
{
|
||||
if (!c)
|
||||
if (!ctx)
|
||||
return mk_error (Invalid_Value);
|
||||
|
||||
switch (prot)
|
||||
switch (protocol)
|
||||
{
|
||||
case GPGME_PROTOCOL_OpenPGP:
|
||||
c->use_cms = 0;
|
||||
ctx->use_cms = 0;
|
||||
break;
|
||||
case GPGME_PROTOCOL_CMS:
|
||||
c->use_cms = 1;
|
||||
ctx->use_cms = 1;
|
||||
break;
|
||||
case GPGME_PROTOCOL_AUTO:
|
||||
return mk_error (Not_Implemented);
|
||||
@ -205,25 +204,26 @@ gpgme_set_protocol (GpgmeCtx c, GpgmeProtocol prot)
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* gpgme_set_armor:
|
||||
* @c: the contect
|
||||
* @ctx: the context
|
||||
* @yes: boolean value to set or clear that flag
|
||||
*
|
||||
* Enable or disable the use of an ascii armor for all output.
|
||||
**/
|
||||
void
|
||||
gpgme_set_armor ( GpgmeCtx c, int yes )
|
||||
gpgme_set_armor (GpgmeCtx ctx, int yes)
|
||||
{
|
||||
if ( !c )
|
||||
return; /* oops */
|
||||
c->use_armor = yes;
|
||||
if (!ctx)
|
||||
return;
|
||||
ctx->use_armor = yes;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* gpgme_get_armor:
|
||||
* @c: the context
|
||||
* @ctx: the context
|
||||
*
|
||||
* Return the state of the armor flag which can be changed using
|
||||
* gpgme_set_armor().
|
||||
@ -231,32 +231,32 @@ gpgme_set_armor ( GpgmeCtx c, int yes )
|
||||
* Return value: Boolean whether armor mode is to be used.
|
||||
**/
|
||||
int
|
||||
gpgme_get_armor (GpgmeCtx c)
|
||||
gpgme_get_armor (GpgmeCtx ctx)
|
||||
{
|
||||
return c && c->use_armor;
|
||||
return ctx && ctx->use_armor;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* gpgme_set_textmode:
|
||||
* @c: the context
|
||||
* @ctx: the context
|
||||
* @yes: boolean flag whether textmode should be enabled
|
||||
*
|
||||
* Enable or disable the use of the special textmode. Textmode is for example
|
||||
* used for the RFC2015 signatures; note that the updated RFC 3156 mandates
|
||||
* that the MUA does some preparations so that textmode is not anymore needed.
|
||||
* that the MUA does some preparations so that textmode is not needed anymore.
|
||||
**/
|
||||
void
|
||||
gpgme_set_textmode ( GpgmeCtx c, int yes )
|
||||
gpgme_set_textmode (GpgmeCtx ctx, int yes)
|
||||
{
|
||||
if ( !c )
|
||||
return; /* oops */
|
||||
c->use_textmode = yes;
|
||||
if (!ctx)
|
||||
return;
|
||||
ctx->use_textmode = yes;
|
||||
}
|
||||
|
||||
/**
|
||||
* gpgme_get_textmode:
|
||||
* @c: the context
|
||||
* @ctx: the context
|
||||
*
|
||||
* Return the state of the textmode flag which can be changed using
|
||||
* gpgme_set_textmode().
|
||||
@ -264,16 +264,15 @@ gpgme_set_textmode ( GpgmeCtx c, int yes )
|
||||
* Return value: Boolean whether textmode is to be used.
|
||||
**/
|
||||
int
|
||||
gpgme_get_textmode (GpgmeCtx c)
|
||||
gpgme_get_textmode (GpgmeCtx ctx)
|
||||
{
|
||||
return c && c->use_textmode;
|
||||
return ctx && ctx->use_textmode;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* gpgme_set_keylist_mode:
|
||||
* @c: the context
|
||||
* @ctx: the context
|
||||
* @mode: listing mode
|
||||
*
|
||||
* This function changes the default behaviour of the keylisting functions.
|
||||
@ -281,17 +280,17 @@ gpgme_get_textmode (GpgmeCtx c)
|
||||
* information about key validity.
|
||||
**/
|
||||
void
|
||||
gpgme_set_keylist_mode ( GpgmeCtx c, int mode )
|
||||
gpgme_set_keylist_mode (GpgmeCtx ctx, int mode)
|
||||
{
|
||||
if (!c)
|
||||
if (!ctx)
|
||||
return;
|
||||
c->keylist_mode = mode;
|
||||
ctx->keylist_mode = mode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* gpgme_set_passphrase_cb:
|
||||
* @c: the context
|
||||
* @ctx: the context
|
||||
* @cb: A callback function
|
||||
* @cb_value: The value passed to the callback function
|
||||
*
|
||||
@ -308,7 +307,7 @@ gpgme_set_keylist_mode ( GpgmeCtx c, int mode )
|
||||
* </literal>
|
||||
* and called whenever gpgme needs a passphrase. DESC will have a nice
|
||||
* text, to be used to prompt for the passphrase and R_HD is just a parameter
|
||||
* to be used by the callback it self. Becuase the callback returns a const
|
||||
* to be used by the callback it self. Because the callback returns a const
|
||||
* string, the callback might want to know when it can release resources
|
||||
* assocated with that returned string; gpgme helps here by calling this
|
||||
* passphrase callback with an DESC of %NULL as soon as it does not need
|
||||
@ -317,18 +316,18 @@ gpgme_set_keylist_mode ( GpgmeCtx c, int mode )
|
||||
*
|
||||
**/
|
||||
void
|
||||
gpgme_set_passphrase_cb ( GpgmeCtx c, GpgmePassphraseCb cb, void *cb_value )
|
||||
gpgme_set_passphrase_cb (GpgmeCtx ctx, GpgmePassphraseCb cb, void *cb_value)
|
||||
{
|
||||
if (c)
|
||||
if (ctx)
|
||||
{
|
||||
c->passphrase_cb = cb;
|
||||
c->passphrase_cb_value = cb_value;
|
||||
ctx->passphrase_cb = cb;
|
||||
ctx->passphrase_cb_value = cb_value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* gpgme_set_progress_cb:
|
||||
* @c: the context
|
||||
* @ctx: the context
|
||||
* @cb: A callback function
|
||||
* @cb_value: The value passed to the callback function
|
||||
*
|
||||
@ -344,20 +343,11 @@ gpgme_set_passphrase_cb ( GpgmeCtx c, GpgmePassphraseCb cb, void *cb_value )
|
||||
* status in the file doc/DETAILS of the GnuPG distribution.
|
||||
**/
|
||||
void
|
||||
gpgme_set_progress_cb ( GpgmeCtx c, GpgmeProgressCb cb, void *cb_value )
|
||||
gpgme_set_progress_cb (GpgmeCtx ctx, GpgmeProgressCb cb, void *cb_value)
|
||||
{
|
||||
if (c)
|
||||
if (ctx)
|
||||
{
|
||||
c->progress_cb = cb;
|
||||
c->progress_cb_value = cb_value;
|
||||
ctx->progress_cb = cb;
|
||||
ctx->progress_cb_value = cb_value;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user