GpgFrontend/gpgme
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2002-01-13 Marcus Brinkmann <marcus@g10code.de>

Browse Source 
* 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 2002-01-15 19:58:41 +00:00
parent 6d275b5d07
commit d83e746a07
3 changed files with 595 additions and 516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
gpgme/ChangeLog
View File

@ -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> 2001-12-21 Marcus Brinkmann <marcus@g10code.de>
* engine-gpgsm.c (_gpgme_gpgsm_new): Replace General_Error with * engine-gpgsm.c (_gpgme_gpgsm_new): Replace General_Error with

319
gpgme/data.c
View File

@ -1,6 +1,6 @@
/* data.c /* data.c
* Copyright (C) 2000 Werner Koch (dd9jn) * 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. * This file is part of GPGME.
* *
@ -34,11 +34,9 @@
#include "ops.h" #include "ops.h"
#include "io.h" #include "io.h"
/* When expanding an internal buffer, always extend it by ALLOC_CHUNK
bytes at a time. */
#define ALLOC_CHUNK 1024 #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) if (!r_dh)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
*r_dh = NULL; *r_dh = NULL;
dh = xtrycalloc (1, sizeof *dh); dh = xtrycalloc (1, sizeof *dh);
if (!dh) if (!dh)
return mk_error (Out_Of_Core); return mk_error (Out_Of_Core);
dh->mode = GPGME_DATA_MODE_INOUT; dh->mode = GPGME_DATA_MODE_INOUT;
*r_dh = dh; *r_dh = dh;
return 0; return 0;
} }
@ -73,31 +74,40 @@ gpgme_data_new ( GpgmeData *r_dh )
* @size: Size of the buffer * @size: Size of the buffer
* @copy: Flag wether a copy of the buffer should be used. * @copy: Flag wether a copy of the buffer should be used.
* *
* Create a new data object and initialize with data * Create a new data object and initialize with data from the memory.
* from the memory. A @copy with value %TRUE creates a copy of the * A @copy with value %TRUE creates a copy of the memory, a value of
* memory, a value of %FALSE uses the original memory of @buffer and the * %FALSE uses the original memory of @buffer and the caller has to
* caller has to make sure that this buffer is valid until gpgme_release_data() * make sure that this buffer is valid until gpgme_data_release() is
* is called. * called.
* *
* Return value: An error value or 0 for success. * Return value: An error value or 0 for success.
**/ **/
GpgmeError GpgmeError
gpgme_data_new_from_mem ( GpgmeData *r_dh, gpgme_data_new_from_mem (GpgmeData *r_dh, const char *buffer, size_t size,
const char *buffer, size_t size, int copy ) int copy)
{ {
GpgmeData dh; GpgmeData dh;
GpgmeError err; GpgmeError err;
if (!r_dh || !buffer) if (!r_dh)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
*r_dh = NULL; *r_dh = NULL;
if (!buffer)
return mk_error (Invalid_Value);
err = gpgme_data_new (&dh); err = gpgme_data_new (&dh);
if (err) if (err)
return err; return err;
dh->type = GPGME_DATA_TYPE_MEM;
dh->len = size; dh->len = size;
if (copy) { if (!copy)
dh->data = buffer;
else
{
dh->private_buffer = xtrymalloc (size); dh->private_buffer = xtrymalloc (size);
if ( !dh->private_buffer ) { if (!dh->private_buffer)
{
gpgme_data_release (dh); gpgme_data_release (dh);
return mk_error (Out_Of_Core); return mk_error (Out_Of_Core);
} }
@ -106,10 +116,6 @@ gpgme_data_new_from_mem ( GpgmeData *r_dh,
dh->data = dh->private_buffer; dh->data = dh->private_buffer;
dh->writepos = size; dh->writepos = size;
} }
else {
dh->data = buffer;
}
dh->type = GPGME_DATA_TYPE_MEM;
*r_dh = dh; *r_dh = dh;
return 0; return 0;
@ -149,12 +155,17 @@ gpgme_data_new_with_read_cb ( GpgmeData *r_dh,
GpgmeData dh; GpgmeData dh;
GpgmeError err; GpgmeError err;
if (!r_dh || !read_cb) if (!r_dh)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
*r_dh = NULL; *r_dh = NULL;
if (!read_cb)
return mk_error (Invalid_Value);
err = gpgme_data_new (&dh); err = gpgme_data_new (&dh);
if (err) if (err)
return err; return err;
dh->type = GPGME_DATA_TYPE_CB; dh->type = GPGME_DATA_TYPE_CB;
dh->mode = GPGME_DATA_MODE_OUT; dh->mode = GPGME_DATA_MODE_OUT;
dh->read_cb = read_cb; dh->read_cb = read_cb;
@ -164,6 +175,7 @@ gpgme_data_new_with_read_cb ( GpgmeData *r_dh,
return 0; return 0;
} }
/** /**
* gpgme_data_new_from_file: * gpgme_data_new_from_file:
* @r_dh: returns the new data object * @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) if (!r_dh)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
*r_dh = NULL; *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) if (!fname)
return mk_error (Invalid_Value); 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); err = gpgme_data_new (&dh);
if (err) if (err)
return err; return err;
fp = fopen (fname, "rb"); fp = fopen (fname, "rb");
if (!fp) { if (!fp)
{
int save_errno = errno; int save_errno = errno;
gpgme_data_release (dh); gpgme_data_release (dh);
errno = save_errno; errno = save_errno;
return mk_error (File_Error); return mk_error (File_Error);
} }
if( fstat(fileno(fp), &st) ) { if (fstat(fileno(fp), &st))
{
int save_errno = errno; int save_errno = errno;
fclose (fp); fclose (fp);
gpgme_data_release (dh); 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); return mk_error (File_Error);
} }
/* We should check the length of the file and don't allow for to /* We should check the length of the file and don't allow for too
* large files */ large files. */
dh->private_buffer = xtrymalloc (st.st_size); dh->private_buffer = xtrymalloc (st.st_size);
if ( !dh->private_buffer ) { if (!dh->private_buffer)
{
fclose (fp); fclose (fp);
gpgme_data_release (dh); gpgme_data_release (dh);
return mk_error (Out_Of_Core); return mk_error (Out_Of_Core);
} }
dh->private_len = st.st_size; 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; int save_errno = errno;
fclose (fp); fclose (fp);
gpgme_data_release (dh); gpgme_data_release (dh);
@ -235,10 +255,10 @@ gpgme_data_new_from_file ( GpgmeData *r_dh, const char *fname, int copy )
fclose (fp); fclose (fp);
dh->type = GPGME_DATA_TYPE_MEM;
dh->len = dh->private_len; dh->len = dh->private_len;
dh->data = dh->private_buffer; dh->data = dh->private_buffer;
dh->writepos = dh->len; dh->writepos = dh->len;
dh->type = GPGME_DATA_TYPE_MEM;
*r_dh = dh; *r_dh = dh;
return 0; 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 * starting at @offset of @file or @fp. Either a filename or an open
* filepointer may be given. * filepointer may be given.
* *
*
* Return value: An error code or 0 on success. If the error code is * 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. * %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; GpgmeData dh;
GpgmeError err; GpgmeError err;
int save_errno = 0;
if (!r_dh) if (!r_dh)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
*r_dh = NULL; *r_dh = NULL;
if ( fname && fp ) /* these are mutual exclusive */
return mk_error (Invalid_Value); if ((fname && fp) || (!fname && !fp))
if (!fname && !fp)
return mk_error (Invalid_Value);
if (!length)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
err = gpgme_data_new (&dh); err = gpgme_data_new (&dh);
if (err) if (err)
return err; return err;
if (!fp) { if (!length)
fp = fopen (fname, "rb"); goto out;
if (!fp) {
int save_errno = errno;
gpgme_data_release (dh);
errno = save_errno;
return mk_error (File_Error);
}
}
if ( fseek ( fp, (long)offset, SEEK_SET) ) {
int save_errno = errno;
if (fname) if (fname)
fclose (fp); {
gpgme_data_release (dh); fp = fopen (fname, "rb");
errno = save_errno; if (!fp)
return mk_error (File_Error); {
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); dh->private_buffer = xtrymalloc (length);
if ( !dh->private_buffer ) { if (!dh->private_buffer)
if (fname) {
fclose (fp); err = mk_error (Out_Of_Core);
gpgme_data_release (dh); goto out;
return mk_error (Out_Of_Core);
} }
dh->private_len = length; dh->private_len = length;
if ( fread ( dh->private_buffer, dh->private_len, 1, fp ) != 1 ) { while (fread (dh->private_buffer, dh->private_len, 1, fp) < 1
int save_errno = errno; && ferror (fp) && errno == EINTR);
if (fname)
fclose (fp); if (ferror (fp))
gpgme_data_release (dh); {
errno = save_errno; err = mk_error (File_Error);
return mk_error (File_Error); goto out;
} }
if (fname) dh->type = GPGME_DATA_TYPE_MEM;
fclose (fp);
dh->len = dh->private_len; dh->len = dh->private_len;
dh->data = dh->private_buffer; dh->data = dh->private_buffer;
dh->writepos = dh->len; 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; *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 void
gpgme_data_release (GpgmeData dh) gpgme_data_release (GpgmeData dh)
{ {
if (dh) { if (dh)
{
xfree (dh->private_buffer); xfree (dh->private_buffer);
xfree (dh); xfree (dh);
} }
} }
/* /*
* Release the data object @dh. @dh may be NULL in which case nothing * Release the data object @dh. @dh may be NULL in which case nothing
* happens. * happens.
@ -362,12 +390,15 @@ _gpgme_data_release_and_return_string ( GpgmeData dh )
{ {
char *val = NULL; char *val = NULL;
if (dh) { if (dh)
{
if (_gpgme_data_append (dh, "", 1)) /* append EOS */ if (_gpgme_data_append (dh, "", 1)) /* append EOS */
xfree (dh->private_buffer ); xfree (dh->private_buffer );
else { else
{
val = dh->private_buffer; val = dh->private_buffer;
if ( !val && dh->data ) { if (!val && dh->data)
{
val = xtrymalloc (dh->len); val = xtrymalloc (dh->len);
if (val) if (val)
memcpy (val, dh->data, dh->len); memcpy (val, dh->data, dh->len);
@ -378,6 +409,7 @@ _gpgme_data_release_and_return_string ( GpgmeData dh )
return val; return val;
} }
/** /**
* gpgme_data_release_and_get_mem: * gpgme_data_release_and_get_mem:
* @dh: the data object * @dh: the data object
@ -398,10 +430,12 @@ gpgme_data_release_and_get_mem ( GpgmeData dh, size_t *r_len )
if (r_len) if (r_len)
*r_len = 0; *r_len = 0;
if (dh) { if (dh)
{
size_t len = dh->len; size_t len = dh->len;
val = dh->private_buffer; val = dh->private_buffer;
if ( !val && dh->data ) { if (!val && dh->data)
{
val = xtrymalloc (len); val = xtrymalloc (len);
if (val) if (val)
memcpy (val, dh->data, len); memcpy (val, dh->data, len);
@ -432,6 +466,7 @@ gpgme_data_get_type ( GpgmeData dh )
return dh->type; return dh->type;
} }
void void
_gpgme_data_set_mode (GpgmeData dh, GpgmeDataMode mode) _gpgme_data_set_mode (GpgmeData dh, GpgmeDataMode mode)
{ {
@ -447,6 +482,7 @@ _gpgme_data_get_mode ( GpgmeData dh )
return dh->mode; return dh->mode;
} }
/** /**
* gpgme_data_rewind: * gpgme_data_rewind:
* @dh: the data object * @dh: the data object
@ -463,19 +499,23 @@ gpgme_data_rewind ( GpgmeData dh )
if (!dh) if (!dh)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
if ( dh->type == GPGME_DATA_TYPE_NONE switch (dh->type)
|| dh->type == GPGME_DATA_TYPE_MEM ) { {
case GPGME_DATA_TYPE_NONE:
case GPGME_DATA_TYPE_MEM:
dh->readpos = 0; dh->readpos = 0;
} return 0;
else if (dh->type == GPGME_DATA_TYPE_CB) {
case GPGME_DATA_TYPE_CB:
dh->len = dh->readpos = 0; dh->len = dh->readpos = 0;
dh->read_cb_eof = 0; dh->read_cb_eof = 0;
if (dh->read_cb (dh->read_cb_value, NULL, 0, NULL)) if (dh->read_cb (dh->read_cb_value, NULL, 0, NULL))
return mk_error (Not_Implemented); return mk_error (Not_Implemented);
}
else
return mk_error (General_Error);
return 0; 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) if (!dh)
return mk_error (Invalid_Value); 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; nbytes = dh->len - dh->readpos;
if ( !nbytes ) { if (!nbytes)
{
*nread = 0; *nread = 0;
return mk_error(EOF); return mk_error(EOF);
} }
if (!buffer) {
if (!buffer)
*nread = nbytes; *nread = nbytes;
} else
else { {
if (nbytes > length) if (nbytes > length)
nbytes = length; nbytes = length;
memcpy (buffer, dh->data + dh->readpos, nbytes); memcpy (buffer, dh->data + dh->readpos, nbytes);
*nread = nbytes; *nread = nbytes;
dh->readpos += nbytes; dh->readpos += nbytes;
} }
} return 0;
else if (dh->type == GPGME_DATA_TYPE_CB) {
if (!buffer) { case GPGME_DATA_TYPE_CB:
if (!buffer)
{
*nread = 0; *nread = 0;
return mk_error (Invalid_Type); return mk_error (Invalid_Type);
} }
nbytes = dh->len - dh->readpos; nbytes = dh->len - dh->readpos;
if ( nbytes ) { if (nbytes)
/* we have unread data - return this */ {
/* We have unread data - return this. */
if (nbytes > length) if (nbytes > length)
nbytes = length; nbytes = length;
memcpy (buffer, dh->data + dh->readpos, nbytes); memcpy (buffer, dh->data + dh->readpos, nbytes);
*nread = nbytes; *nread = nbytes;
dh->readpos += nbytes; dh->readpos += nbytes;
} }
else { /* get the data from the callback */ else
if (!dh->read_cb || dh->read_cb_eof) { {
/* Get the data from the callback. */
if (!dh->read_cb || dh->read_cb_eof)
{
*nread = 0; *nread = 0;
return mk_error (EOF); 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; *nread = 0;
dh->read_cb_eof = 1; dh->read_cb_eof = 1;
return mk_error (EOF); return mk_error (EOF);
} }
} }
}
else
return mk_error (General_Error);
return 0; return 0;
default:
return mk_error (General_Error);
} }
}
GpgmeError GpgmeError
_gpgme_data_unread (GpgmeData dh, const char *buffer, size_t length) _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) if (!dh)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
if (dh->type == GPGME_DATA_TYPE_MEM ) { if (dh->type == GPGME_DATA_TYPE_MEM)
/* check that we don't unread more than we have yet read */ {
/* Check that we don't unread more than we have yet read. */
if (dh->readpos < length) if (dh->readpos < length)
return mk_error (Invalid_Value); 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; dh->readpos -= length;
} }
else { else
return mk_error (General_Error); return mk_error (General_Error);
}
return 0; return 0;
} }
@ -583,9 +637,11 @@ _gpgme_data_get_as_string ( GpgmeData dh )
{ {
char *val = NULL; char *val = NULL;
if (dh) { if (dh)
{
val = xtrymalloc (dh->len+1); val = xtrymalloc (dh->len+1);
if ( val ) { if (val)
{
memcpy (val, dh->data, dh->len); memcpy (val, dh->data, dh->len);
val[dh->len] = 0; val[dh->len] = 0;
} }
@ -620,13 +676,15 @@ _gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
{ {
assert (dh); assert (dh);
if ( dh->type == GPGME_DATA_TYPE_NONE ) { if (dh->type == GPGME_DATA_TYPE_NONE)
/* convert it to a mem data type */ {
/* Convert it to a mem data type. */
assert (!dh->private_buffer); assert (!dh->private_buffer);
dh->type = GPGME_DATA_TYPE_MEM; dh->type = GPGME_DATA_TYPE_MEM;
dh->private_len = length < ALLOC_CHUNK? ALLOC_CHUNK : length; dh->private_len = length < ALLOC_CHUNK? ALLOC_CHUNK : length;
dh->private_buffer = xtrymalloc (dh->private_len); dh->private_buffer = xtrymalloc (dh->private_len);
if (!dh->private_buffer) { if (!dh->private_buffer)
{
dh->private_len = 0; dh->private_len = 0;
return mk_error (Out_Of_Core); 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) && dh->mode != GPGME_DATA_MODE_IN)
return mk_error (Invalid_Mode); return mk_error (Invalid_Mode);
if ( !dh->private_buffer ) { if (!dh->private_buffer)
/* we have to copy it now */ {
/* We have to copy it now. */
assert (dh->data); assert (dh->data);
dh->private_len = dh->len+length; dh->private_len = dh->len+length;
if (dh->private_len < ALLOC_CHUNK) if (dh->private_len < ALLOC_CHUNK)
dh->private_len = ALLOC_CHUNK; dh->private_len = ALLOC_CHUNK;
dh->private_buffer = xtrymalloc (dh->private_len); dh->private_buffer = xtrymalloc (dh->private_len);
if (!dh->private_buffer) { if (!dh->private_buffer)
{
dh->private_len = 0; dh->private_len = 0;
return mk_error (Out_Of_Core); 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; dh->data = dh->private_buffer;
} }
/* allocate more memory if needed */ /* Allocate more memory if needed. */
if ( dh->writepos + length > dh->private_len ) { if (dh->writepos + length > dh->private_len)
{
char *p; char *p;
size_t newlen = dh->private_len size_t newlen = dh->private_len
+ (length < ALLOC_CHUNK? ALLOC_CHUNK : length); + (length < ALLOC_CHUNK? ALLOC_CHUNK : length);
@ -677,6 +738,7 @@ _gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
return 0; return 0;
} }
GpgmeError GpgmeError
_gpgme_data_append_string (GpgmeData dh, const char *s) _gpgme_data_append_string (GpgmeData dh, const char *s)
{ {
@ -695,29 +757,36 @@ _gpgme_data_append_for_xml ( GpgmeData dh,
if (!dh || !buffer) if (!dh || !buffer)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
do { do
for (text=NULL, s=buffer, n=len; n && !text; s++, n-- ) { {
for (text=NULL, s = buffer, n = len; n && !text; s++, n--)
{
if (*s == '<') if (*s == '<')
text = "&lt;"; text = "&lt;";
else if (*s == '>') else if (*s == '>')
text = "&gt;"; /* not sure whether this is really needed */ text = "&gt;"; /* Not sure whether this is really needed. */
else if (*s == '&') else if (*s == '&')
text = "&amp;"; text = "&amp;";
else if (!*s) else if (!*s)
text = "&#00;"; text = "&#00;";
} }
if (text) { if (text)
s--; n++; {
s--;
n++;
} }
if (s != buffer) if (s != buffer)
rc = _gpgme_data_append (dh, buffer, s-buffer); rc = _gpgme_data_append (dh, buffer, s-buffer);
if ( !rc && text) { if (!rc && text)
{
rc = _gpgme_data_append_string (dh, text); rc = _gpgme_data_append_string (dh, text);
s++; n--; s++;
n--;
} }
buffer = s; buffer = s;
len = n; len = n;
} while ( !rc && len ); }
while (!rc && len);
return rc; 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 GpgmeError
_gpgme_data_append_percentstring_for_xml (GpgmeData dh, const char *string) _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; GpgmeError err;
d = buf = xtrymalloc (strlen (string)); d = buf = xtrymalloc (strlen (string));
for (s=string; *s; s++ ) { for (s = string; *s; s++)
if ( *s == '%' && (val=hextobyte (s+1)) != -1 ) { {
if (*s == '%' && (val = hextobyte (s+1)) != -1)
{
*d++ = val; *d++ = val;
s += 2; s += 2;
} }

176
gpgme/gpgme.c
View File

@ -1,6 +1,6 @@
/* gpgme.c - GnuPG Made Easy /* gpgme.c - GnuPG Made Easy
* Copyright (C) 2000 Werner Koch (dd9jn) * 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. * This file is part of GPGME.
* *
@ -29,11 +29,6 @@
#include "context.h" #include "context.h"
#include "ops.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: * gpgme_new:
* @r_ctx: Returns the new context * @r_ctx: Returns the new context
@ -46,13 +41,16 @@
GpgmeError GpgmeError
gpgme_new (GpgmeCtx *r_ctx) gpgme_new (GpgmeCtx *r_ctx)
{ {
GpgmeCtx c; GpgmeCtx ctx;
c = xtrycalloc ( 1, sizeof *c ); if (!r_ctx)
if (!c) return mk_error (Invalid_Value);
*r_ctx = 0;
ctx = xtrycalloc (1, sizeof *ctx);
if (!ctx)
return mk_error (Out_Of_Core); return mk_error (Out_Of_Core);
c->verbosity = 1; ctx->verbosity = 1;
*r_ctx = c; *r_ctx = ctx;
return 0; return 0;
} }
@ -64,32 +62,32 @@ gpgme_new (GpgmeCtx *r_ctx)
* Release all resources associated with the given context. * Release all resources associated with the given context.
**/ **/
void void
gpgme_release (GpgmeCtx c) gpgme_release (GpgmeCtx ctx)
{ {
if (!c) if (!ctx)
return; return;
_gpgme_engine_release (c->engine); _gpgme_engine_release (ctx->engine);
_gpgme_release_result (c); _gpgme_release_result (ctx);
gpgme_key_release (c->tmp_key); gpgme_key_release (ctx->tmp_key);
gpgme_data_release (c->help_data_1); gpgme_data_release (ctx->help_data_1);
gpgme_data_release (c->notation); gpgme_data_release (ctx->notation);
gpgme_signers_clear (c); gpgme_signers_clear (ctx);
if (c->signers) if (ctx->signers)
xfree (c->signers); xfree (ctx->signers);
/* FIXME: Release the key_queue. */ /* FIXME: Release the key_queue. */
xfree (c); xfree (ctx);
} }
void void
_gpgme_release_result (GpgmeCtx c) _gpgme_release_result (GpgmeCtx ctx)
{ {
_gpgme_release_verify_result (c->result.verify); _gpgme_release_verify_result (ctx->result.verify);
_gpgme_release_decrypt_result (c->result.decrypt); _gpgme_release_decrypt_result (ctx->result.decrypt);
_gpgme_release_sign_result (c->result.sign); _gpgme_release_sign_result (ctx->result.sign);
_gpgme_release_encrypt_result (c->result.encrypt); _gpgme_release_encrypt_result (ctx->result.encrypt);
_gpgme_release_passphrase_result (c->result.passphrase); _gpgme_release_passphrase_result (ctx->result.passphrase);
memset (&c->result, 0, sizeof (c->result)); memset (&ctx->result, 0, sizeof (ctx->result));
_gpgme_set_op_info (c, NULL); _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 * all kinds of operations. It is especially useful in a passphrase callback
* to stop the system from asking another time for the passphrase. * to stop the system from asking another time for the passphrase.
**/ **/
void 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. * Return value: An XML string or NULL if no notation data is available.
**/ **/
char * char *
gpgme_get_notation ( GpgmeCtx c ) gpgme_get_notation (GpgmeCtx ctx)
{ {
if ( !c->notation ) if (!ctx->notation)
return NULL; 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 * Return value: NULL for no info available or an XML string
**/ **/
char * char *
gpgme_get_op_info ( GpgmeCtx c, int reserved ) gpgme_get_op_info (GpgmeCtx ctx, int reserved)
{ {
if (!c || reserved) if (!ctx || reserved)
return NULL; /*invalid value */ 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 * Store the data object with the operation info in the
* context. Caller should not use that object anymore. * context. Caller should not use that object anymore.
*/ */
void 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); gpgme_data_release (ctx->op_info);
c->op_info = NULL; ctx->op_info = NULL;
if (info) if (info)
c->op_info = info; ctx->op_info = info;
} }
GpgmeError GpgmeError
gpgme_set_protocol (GpgmeCtx c, GpgmeProtocol prot) gpgme_set_protocol (GpgmeCtx ctx, GpgmeProtocol protocol)
{ {
if (!c) if (!ctx)
return mk_error (Invalid_Value); return mk_error (Invalid_Value);
switch (prot) switch (protocol)
{ {
case GPGME_PROTOCOL_OpenPGP: case GPGME_PROTOCOL_OpenPGP:
c->use_cms = 0; ctx->use_cms = 0;
break; break;
case GPGME_PROTOCOL_CMS: case GPGME_PROTOCOL_CMS:
c->use_cms = 1; ctx->use_cms = 1;
break; break;
case GPGME_PROTOCOL_AUTO: case GPGME_PROTOCOL_AUTO:
return mk_error (Not_Implemented); return mk_error (Not_Implemented);
@ -205,25 +204,26 @@ gpgme_set_protocol (GpgmeCtx c, GpgmeProtocol prot)
return 0; return 0;
} }
/** /**
* gpgme_set_armor: * gpgme_set_armor:
* @c: the contect * @ctx: the context
* @yes: boolean value to set or clear that flag * @yes: boolean value to set or clear that flag
* *
* Enable or disable the use of an ascii armor for all output. * Enable or disable the use of an ascii armor for all output.
**/ **/
void void
gpgme_set_armor ( GpgmeCtx c, int yes ) gpgme_set_armor (GpgmeCtx ctx, int yes)
{ {
if ( !c ) if (!ctx)
return; /* oops */ return;
c->use_armor = yes; ctx->use_armor = yes;
} }
/** /**
* gpgme_get_armor: * gpgme_get_armor:
* @c: the context * @ctx: the context
* *
* Return the state of the armor flag which can be changed using * Return the state of the armor flag which can be changed using
* gpgme_set_armor(). * gpgme_set_armor().
@ -231,32 +231,32 @@ gpgme_set_armor ( GpgmeCtx c, int yes )
* Return value: Boolean whether armor mode is to be used. * Return value: Boolean whether armor mode is to be used.
**/ **/
int int
gpgme_get_armor (GpgmeCtx c) gpgme_get_armor (GpgmeCtx ctx)
{ {
return c && c->use_armor; return ctx && ctx->use_armor;
} }
/** /**
* gpgme_set_textmode: * gpgme_set_textmode:
* @c: the context * @ctx: the context
* @yes: boolean flag whether textmode should be enabled * @yes: boolean flag whether textmode should be enabled
* *
* Enable or disable the use of the special textmode. Textmode is for example * 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 * 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 void
gpgme_set_textmode ( GpgmeCtx c, int yes ) gpgme_set_textmode (GpgmeCtx ctx, int yes)
{ {
if ( !c ) if (!ctx)
return; /* oops */ return;
c->use_textmode = yes; ctx->use_textmode = yes;
} }
/** /**
* gpgme_get_textmode: * gpgme_get_textmode:
* @c: the context * @ctx: the context
* *
* Return the state of the textmode flag which can be changed using * Return the state of the textmode flag which can be changed using
* gpgme_set_textmode(). * gpgme_set_textmode().
@ -264,16 +264,15 @@ gpgme_set_textmode ( GpgmeCtx c, int yes )
* Return value: Boolean whether textmode is to be used. * Return value: Boolean whether textmode is to be used.
**/ **/
int 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: * gpgme_set_keylist_mode:
* @c: the context * @ctx: the context
* @mode: listing mode * @mode: listing mode
* *
* This function changes the default behaviour of the keylisting functions. * This function changes the default behaviour of the keylisting functions.
@ -281,17 +280,17 @@ gpgme_get_textmode (GpgmeCtx c)
* information about key validity. * information about key validity.
**/ **/
void void
gpgme_set_keylist_mode ( GpgmeCtx c, int mode ) gpgme_set_keylist_mode (GpgmeCtx ctx, int mode)
{ {
if (!c) if (!ctx)
return; return;
c->keylist_mode = mode; ctx->keylist_mode = mode;
} }
/** /**
* gpgme_set_passphrase_cb: * gpgme_set_passphrase_cb:
* @c: the context * @ctx: the context
* @cb: A callback function * @cb: A callback function
* @cb_value: The value passed to the callback function * @cb_value: The value passed to the callback function
* *
@ -308,7 +307,7 @@ gpgme_set_keylist_mode ( GpgmeCtx c, int mode )
* </literal> * </literal>
* and called whenever gpgme needs a passphrase. DESC will have a nice * 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 * 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 * string, the callback might want to know when it can release resources
* assocated with that returned string; gpgme helps here by calling this * 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 * 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 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; ctx->passphrase_cb = cb;
c->passphrase_cb_value = cb_value; ctx->passphrase_cb_value = cb_value;
} }
} }
/** /**
* gpgme_set_progress_cb: * gpgme_set_progress_cb:
* @c: the context * @ctx: the context
* @cb: A callback function * @cb: A callback function
* @cb_value: The value passed to the 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. * status in the file doc/DETAILS of the GnuPG distribution.
**/ **/
void 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; ctx->progress_cb = cb;
c->progress_cb_value = cb_value; ctx->progress_cb_value = cb_value;
} }
} }