2002-01-13 Marcus Brinkmann <[email protected]>

	* 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.

3 files changed, 609 insertions, 530 deletions

diff --git a/gpgme/ChangeLog b/gpgme/ChangeLog
index 0f3928cd..8d802245 100644
--- a/gpgme/ChangeLog
+++ b/gpgme/ChangeLog
@@ -1,3 +1,21 @@
+2002-01-13  Marcus Brinkmann  <[email protected]>
+
+	* 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  <[email protected]>
 
 	* engine-gpgsm.c (_gpgme_gpgsm_new): Replace General_Error with
diff --git a/gpgme/data.c b/gpgme/data.c
index a17ea1d2..9a8cce04 100644
--- a/gpgme/data.c
+++ b/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') )
 
 
 /**
@@ -50,19 +48,22 @@
  * Return value: An error value or 0 on success
  **/
 GpgmeError
-gpgme_data_new ( GpgmeData *r_dh )
+gpgme_data_new (GpgmeData *r_dh)
 {
-    GpgmeData 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;
+  GpgmeData 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,46 +74,51 @@ 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)
-        return mk_error (Invalid_Value);
-    *r_dh = NULL;
-    err = gpgme_data_new ( &dh );
-    if (err)
-        return err;
-    dh->len = size;
-    if (copy) {
-        dh->private_buffer = xtrymalloc ( size );
-        if ( !dh->private_buffer ) {
-            gpgme_data_release (dh);
-            return mk_error (Out_Of_Core);
-        }
-        dh->private_len = size;
-        memcpy (dh->private_buffer, buffer, size );
-        dh->data = dh->private_buffer;
-        dh->writepos = size;
-    }
-    else {
-        dh->data = buffer;
+  GpgmeData dh;
+  GpgmeError err;
+
+  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)
+    dh->data = buffer;
+  else
+    {
+      dh->private_buffer = xtrymalloc (size);
+      if (!dh->private_buffer)
+	{
+	  gpgme_data_release (dh);
+	  return mk_error (Out_Of_Core);
+	}
+      dh->private_len = size;
+      memcpy (dh->private_buffer, buffer, size);
+      dh->data = dh->private_buffer;
+      dh->writepos = size;
     }
-    dh->type = GPGME_DATA_TYPE_MEM;
-    
-    *r_dh = dh;
-    return 0;
+
+  *r_dh = dh;
+  return 0;
 }
 
 
@@ -142,28 +148,34 @@ gpgme_data_new_from_mem ( GpgmeData *r_dh,
  * Return value: An error value or 0 for success.
  **/
 GpgmeError
-gpgme_data_new_with_read_cb ( GpgmeData *r_dh,
-                              int (*read_cb)(void*,char *,size_t,size_t*),
-                              void *read_cb_value )
+gpgme_data_new_with_read_cb (GpgmeData *r_dh,
+			     int (*read_cb) (void *,char *, size_t ,size_t *),
+			     void *read_cb_value)
 {
-    GpgmeData dh;
-    GpgmeError err;
-
-    if (!r_dh || !read_cb)
-        return mk_error (Invalid_Value);
-    *r_dh = NULL;
-    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;
-    dh->read_cb_value = read_cb_value;
+  GpgmeData dh;
+  GpgmeError err;
+
+  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;
+  dh->read_cb_value = read_cb_value;
     
-    *r_dh = dh;
-    return 0;
+  *r_dh = dh;
+  return 0;
 }
 
+
 /**
  * gpgme_data_new_from_file:
  * @r_dh: returns the new data object
@@ -178,70 +190,78 @@ gpgme_data_new_with_read_cb ( GpgmeData *r_dh,
  * %GPGME_File_Error, the OS error code is held in %errno.
  **/
 GpgmeError
-gpgme_data_new_from_file ( GpgmeData *r_dh, const char *fname, int copy )
+gpgme_data_new_from_file (GpgmeData *r_dh, const char *fname, int copy)
 {
-    GpgmeData dh;
-    GpgmeError err;
-    struct stat st;
-    FILE *fp;
-
-    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);
-
-    err = gpgme_data_new ( &dh );
-    if (err)
-        return err;
-
-    fp = fopen (fname, "rb");
-    if (!fp) {
-        int save_errno = errno;
-        gpgme_data_release (dh);
-        errno = save_errno;
-        return mk_error (File_Error);
+  GpgmeData dh;
+  GpgmeError err;
+  struct stat st;
+  FILE *fp;
+
+  if (!r_dh)
+    return mk_error (Invalid_Value);
+  *r_dh = NULL;
+  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)
+    {
+      int save_errno = errno;
+      gpgme_data_release (dh);
+      errno = save_errno;
+      return mk_error (File_Error);
     }
 
-    if( fstat(fileno(fp), &st) ) {
-        int save_errno = errno;
-        fclose (fp);
-        gpgme_data_release (dh);
-        errno = save_errno;
-        return mk_error (File_Error);
+  if (fstat(fileno(fp), &st))
+    {
+      int save_errno = errno;
+      fclose (fp);
+      gpgme_data_release (dh);
+      errno = save_errno;
+      return mk_error (File_Error);
     }
 
-    /* We should check the length of the file and don't allow for to
-     * large files */
-    dh->private_buffer = xtrymalloc ( st.st_size );
-    if ( !dh->private_buffer ) {
-        fclose (fp);
-        gpgme_data_release (dh);
-        return mk_error (Out_Of_Core);
+  /* 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)
+    {
+      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 ) {
-        int save_errno = errno;
-        fclose (fp);
-        gpgme_data_release (dh);
-        errno = save_errno;
-        return mk_error (File_Error);
+  dh->private_len = st.st_size;
+
+  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);
+      errno = save_errno;
+      return mk_error (File_Error);
     }
 
-    fclose (fp);
+  fclose (fp);
 
-    dh->len = dh->private_len;
-    dh->data = dh->private_buffer;
-    dh->writepos = dh->len;
-    dh->type = GPGME_DATA_TYPE_MEM;
+  dh->type = GPGME_DATA_TYPE_MEM;
+  dh->len = dh->private_len;
+  dh->data = dh->private_buffer;
+  dh->writepos = dh->len;
     
-    *r_dh = dh;
-    return 0;
+  *r_dh = dh;
+  return 0;
 }
 
 
@@ -257,79 +277,85 @@ 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.
  **/
 GpgmeError
-gpgme_data_new_from_filepart ( GpgmeData *r_dh, const char *fname, FILE *fp,
-                               off_t offset, off_t length )
+gpgme_data_new_from_filepart (GpgmeData *r_dh, const char *fname, FILE *fp,
+			      off_t offset, off_t length)
 {
-    GpgmeData dh;
-    GpgmeError err;
-
-    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)
-        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);
-        }
-    }
+  GpgmeData dh;
+  GpgmeError err;
+  int save_errno = 0;
+
+  if (!r_dh)
+    return mk_error (Invalid_Value);
+  *r_dh = NULL;
+
+  if ((fname && fp) || (!fname && !fp))
+    return mk_error (Invalid_Value);
 
-    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);
+  err = gpgme_data_new (&dh);
+  if (err)
+    return err;
+
+  if (!length)
+    goto out;
+
+  if (fname)
+    {
+      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);
+  dh->private_buffer = xtrymalloc (length);
+  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);
+  dh->private_len = length;
+  
+  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;
     }
+      
+  dh->type = GPGME_DATA_TYPE_MEM;
+  dh->len = dh->private_len;
+  dh->data = dh->private_buffer;
+  dh->writepos = dh->len;
 
-    if (fname)
-        fclose (fp);
+ out:
+  if (err)
+    save_errno = errno;
 
-    dh->len = dh->private_len;
-    dh->data = dh->private_buffer;
-    dh->writepos = dh->len;
-    dh->type = GPGME_DATA_TYPE_MEM;
-    
+  if (fname && fp)
+    fclose (fp);
+
+  if (err)
+    {
+      gpgme_data_release (dh);
+      errno = save_errno;
+    }
+  else
     *r_dh = dh;
-    return 0;
+  return err;
 }
 
 
@@ -341,14 +367,16 @@ gpgme_data_new_from_filepart ( GpgmeData *r_dh, const char *fname, FILE *fp,
  * happens.
  **/
 void
-gpgme_data_release ( GpgmeData dh )
+gpgme_data_release (GpgmeData dh)
 {
-    if (dh) {
-        xfree (dh->private_buffer); 
-        xfree (dh);
+  if (dh)
+    {
+      xfree (dh->private_buffer); 
+      xfree (dh);
     }
 }
 
+
 /*
  * Release the data object @dh.  @dh may be NULL in which case nothing
  * happens.
@@ -358,26 +386,30 @@ gpgme_data_release ( GpgmeData dh )
  * safely be accessed using the string fucntions.
  **/
 char *
-_gpgme_data_release_and_return_string ( GpgmeData dh )
+_gpgme_data_release_and_return_string (GpgmeData dh)
 {
-    char *val = NULL;
-
-    if (dh) {
-        if ( _gpgme_data_append ( dh, "", 1 ) ) /* append EOS */
-            xfree (dh->private_buffer );
-        else {
-            val = dh->private_buffer;
-            if ( !val && dh->data ) {
-                val = xtrymalloc ( dh->len );
-                if ( val )
-                    memcpy ( val, dh->data, dh->len );
+  char *val = NULL;
+
+  if (dh)
+    {
+      if (_gpgme_data_append (dh, "", 1)) /* append EOS */
+	xfree (dh->private_buffer );
+      else
+	{
+	  val = dh->private_buffer;
+	  if (!val && dh->data)
+	    {
+	      val = xtrymalloc (dh->len);
+	      if (val)
+		memcpy (val, dh->data, dh->len);
             }
         }
-        xfree (dh);
+      xfree (dh);
     }
-    return val;
+  return val;
 }
 
+
 /**
  * gpgme_data_release_and_get_mem:
  * @dh: the data object
@@ -392,25 +424,27 @@ _gpgme_data_release_and_return_string ( GpgmeData dh )
  * Return value: a pointer to an allocated buffer of length @r_len.
  **/
 char *
-gpgme_data_release_and_get_mem ( GpgmeData dh, size_t *r_len )
+gpgme_data_release_and_get_mem (GpgmeData dh, size_t *r_len)
 {
-    char *val = NULL;
-
-    if (r_len)
-        *r_len = 0;
-    if (dh) {
-        size_t len = dh->len;
-        val = dh->private_buffer;
-        if ( !val && dh->data ) {
-            val = xtrymalloc ( len );
-            if ( val )
-                memcpy ( val, dh->data, len );
+  char *val = NULL;
+
+  if (r_len)
+    *r_len = 0;
+  if (dh)
+    {
+      size_t len = dh->len;
+      val = dh->private_buffer;
+      if (!val && dh->data)
+	{
+	  val = xtrymalloc (len);
+	  if (val)
+	    memcpy (val, dh->data, len);
         }
-        xfree (dh);
-        if (val && r_len )
-            *r_len = len;
+      xfree (dh);
+      if (val && r_len)
+	*r_len = len;
     }
-    return val;
+  return val;
 }
 
 
@@ -424,29 +458,31 @@ gpgme_data_release_and_get_mem ( GpgmeData dh, size_t *r_len )
  * Return value: the data type
  **/
 GpgmeDataType
-gpgme_data_get_type ( GpgmeData dh )
+gpgme_data_get_type (GpgmeData dh)
 {
-    if ( !dh || (!dh->data && !dh->read_cb))
-        return GPGME_DATA_TYPE_NONE;
-            
-    return dh->type;
+  if (!dh || (!dh->data && !dh->read_cb))
+    return GPGME_DATA_TYPE_NONE;
+
+  return dh->type;
 }
 
+
 void 
-_gpgme_data_set_mode ( GpgmeData dh, GpgmeDataMode mode )
+_gpgme_data_set_mode (GpgmeData dh, GpgmeDataMode mode)
 {
-    assert (dh);
-    dh->mode = mode;
+  assert (dh);
+  dh->mode = mode;
 }
 
 
 GpgmeDataMode
-_gpgme_data_get_mode ( GpgmeData dh )
+_gpgme_data_get_mode (GpgmeData dh)
 {
-    assert (dh);
-    return dh->mode;
+  assert (dh);
+  return dh->mode;
 }
 
+
 /**
  * gpgme_data_rewind:
  * @dh: the data object 
@@ -458,24 +494,28 @@ _gpgme_data_get_mode ( GpgmeData dh )
  * Return value: An error code or 0 on success
  **/
 GpgmeError
-gpgme_data_rewind ( GpgmeData dh )
+gpgme_data_rewind (GpgmeData dh)
 {
-    if ( !dh )
-        return mk_error (Invalid_Value);
+  if (!dh)
+    return mk_error (Invalid_Value);
 
-    if ( dh->type == GPGME_DATA_TYPE_NONE 
-         || dh->type == GPGME_DATA_TYPE_MEM ) {
-        dh->readpos = 0;
-    }
-    else if (dh->type == 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);
+  switch (dh->type)
+    {
+    case GPGME_DATA_TYPE_NONE:
+    case GPGME_DATA_TYPE_MEM:
+      dh->readpos = 0;
+      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);
+      return 0;
+
+    default:
+      return mk_error (General_Error);
     }
-    else
-        return mk_error (General_Error);
-    return 0;
 }
 
 /**
@@ -500,76 +540,90 @@ gpgme_data_rewind ( GpgmeData dh )
  * error code GPGME_EOF.
  **/
 GpgmeError
-gpgme_data_read ( GpgmeData dh, char *buffer, size_t length, size_t *nread )
+gpgme_data_read (GpgmeData dh, char *buffer, size_t length, size_t *nread)
 {
-    size_t nbytes;
-
-    if ( !dh )
-        return mk_error (Invalid_Value);
-    if (dh->type == GPGME_DATA_TYPE_MEM ) {
-        nbytes = dh->len - dh->readpos;
-        if ( !nbytes ) {
-            *nread = 0;
-            return mk_error(EOF);
-        }
-        if (!buffer) {
-            *nread = nbytes;
+  size_t nbytes;
+
+  if (!dh)
+    return mk_error (Invalid_Value);
+  
+  switch (dh->type)
+    {
+    case GPGME_DATA_TYPE_MEM:
+      nbytes = dh->len - dh->readpos;
+      if (!nbytes)
+	{
+	  *nread = 0;
+	  return mk_error(EOF);
         }
-        else {
-            if (nbytes > length)
-                nbytes = length;
-            memcpy ( buffer, dh->data + dh->readpos, nbytes );
-            *nread = nbytes;
-            dh->readpos += nbytes;
+
+      if (!buffer)
+	*nread = nbytes;
+      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) {
-            *nread = 0;
-            return mk_error (Invalid_Type);
+      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 > length)
-                nbytes = length;
-            memcpy ( buffer, dh->data + dh->readpos, nbytes );
-            *nread = nbytes;
-            dh->readpos += nbytes;
+      nbytes = dh->len - dh->readpos;
+      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) { 
-                *nread = 0;
-                return mk_error (EOF);
-            }
-            if (dh->read_cb (dh->read_cb_value, buffer, length, nread )) {
-                *nread = 0;
-                dh->read_cb_eof = 1;
-                return mk_error (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))
+	    {
+	      *nread = 0;
+	      dh->read_cb_eof = 1;
+	      return mk_error (EOF);
+	    }
         }
+      return 0;
+      
+    default:
+      return mk_error (General_Error);
     }
-    else
-        return mk_error (General_Error);
-    return 0;
 } 
 
+
 GpgmeError
-_gpgme_data_unread (GpgmeData dh, const char *buffer, size_t length )
+_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->readpos < length )
-           return mk_error (Invalid_Value);
-       /* No need to use the buffer for this data type */
+   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->readpos < length)
+	 return mk_error (Invalid_Value);
+       /* No need to use the buffer for this data type.  */
        dh->readpos -= length;
-   }
-   else {
-       return mk_error (General_Error);
-   }
+     }
+   else
+     return mk_error (General_Error);
 
    return 0;
 }
@@ -579,18 +633,20 @@ _gpgme_data_unread (GpgmeData dh, const char *buffer, size_t length )
  * This function does make sense when we know that it contains no nil chars.
  */
 char *
-_gpgme_data_get_as_string ( GpgmeData dh )
+_gpgme_data_get_as_string (GpgmeData dh)
 {
-    char *val = NULL;
+  char *val = NULL;
 
-    if (dh) {
-        val = xtrymalloc ( dh->len+1 );
-        if ( val ) {
-            memcpy ( val, dh->data, dh->len );
-            val[dh->len] = 0;
+  if (dh)
+    {
+      val = xtrymalloc (dh->len+1);
+      if (val)
+	{
+	  memcpy (val, dh->data, dh->len);
+	  val[dh->len] = 0;
         }
     }
-    return val;
+  return val;
 }
 
 
@@ -606,119 +662,132 @@ _gpgme_data_get_as_string ( GpgmeData dh )
  * Return value: 0 on success or an error code
  **/
 GpgmeError
-gpgme_data_write ( GpgmeData dh, const char *buffer, size_t length )
+gpgme_data_write (GpgmeData dh, const char *buffer, size_t length)
 {
-    if (!dh || !buffer)
-        return mk_error (Invalid_Value);
+  if (!dh || !buffer)
+    return mk_error (Invalid_Value);
       
-    return _gpgme_data_append (dh, buffer, length );
+  return _gpgme_data_append (dh, buffer, length );
 }
 
 
 GpgmeError
-_gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
+_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 */
-        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) {
-            dh->private_len = 0;
-            return mk_error (Out_Of_Core);
+  assert (dh);
+
+  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)
+	{
+	  dh->private_len = 0;
+	  return mk_error (Out_Of_Core);
         }
-        dh->writepos = 0;
-        dh->data = dh->private_buffer;
+      dh->writepos = 0;
+      dh->data = dh->private_buffer;
     }
-    else if ( dh->type != GPGME_DATA_TYPE_MEM ) 
-        return mk_error (Invalid_Type);
+  else if (dh->type != GPGME_DATA_TYPE_MEM)
+    return mk_error (Invalid_Type);
     
-    if ( dh->mode != GPGME_DATA_MODE_INOUT 
-         && dh->mode != GPGME_DATA_MODE_IN  )
-        return mk_error (Invalid_Mode);
-
-    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) {
-            dh->private_len = 0;
-            return mk_error (Out_Of_Core);
+  if (dh->mode != GPGME_DATA_MODE_INOUT 
+      && dh->mode != GPGME_DATA_MODE_IN)
+    return mk_error (Invalid_Mode);
+
+  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)
+	{
+	  dh->private_len = 0;
+	  return mk_error (Out_Of_Core);
         }
-        memcpy ( dh->private_buffer, dh->data, dh->len );
-        dh->writepos = dh->len;
-        dh->data = dh->private_buffer;
+      memcpy (dh->private_buffer, dh->data, dh->len);
+      dh->writepos = dh->len;
+      dh->data = dh->private_buffer;
     }
 
-    /* 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);
-        p = xtryrealloc ( dh->private_buffer, newlen );
-        if ( !p ) 
-            return mk_error (Out_Of_Core);
-        dh->private_buffer = p;
-        dh->private_len = newlen;
-        dh->data = dh->private_buffer;
-        assert ( !(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);
+      p = xtryrealloc (dh->private_buffer, newlen);
+      if (!p) 
+	return mk_error (Out_Of_Core);
+      dh->private_buffer = p;
+      dh->private_len = newlen;
+      dh->data = dh->private_buffer;
+      assert (!(dh->writepos + length > dh->private_len));
     }
 
-    memcpy ( dh->private_buffer + dh->writepos, buffer, length );
-    dh->writepos += length;
-    dh->len += length;
+  memcpy (dh->private_buffer + dh->writepos, buffer, length);
+  dh->writepos += length;
+  dh->len += length;
 
-    return 0;
+  return 0;
 }
 
+
 GpgmeError
-_gpgme_data_append_string ( GpgmeData dh, const char *s )
+_gpgme_data_append_string (GpgmeData dh, const char *s)
 {
-    return _gpgme_data_append ( dh, s, s? strlen(s):0 );
+  return _gpgme_data_append (dh, s, s ? strlen(s) : 0);
 }
 
 
 GpgmeError
-_gpgme_data_append_for_xml ( GpgmeData dh,
-                             const char *buffer, size_t len )
+_gpgme_data_append_for_xml (GpgmeData dh,
+			    const char *buffer, size_t len)
 {
-    const char *text, *s;
-    size_t n;
-    int rc = 0; 
+  const char *text, *s;
+  size_t n;
+  int rc = 0; 
        
-    if ( !dh || !buffer )
-        return mk_error (Invalid_Value);
-
-    do {
-        for (text=NULL, s=buffer, n=len; n && !text; s++, n-- ) {
-            if ( *s == '<' ) 
-                text = "&lt;";
-            else if ( *s == '>' ) 
-                text = "&gt;";  /* not sure whether this is really needed */
-            else if ( *s == '&' ) 
-                text = "&amp;";
-            else if ( !*s )
-                text = "&#00;";
+  if (!dh || !buffer)
+    return mk_error (Invalid_Value);
+
+  do
+    {
+      for (text=NULL, s = buffer, n = len; n && !text; s++, n--)
+	{
+	  if (*s == '<') 
+	    text = "&lt;";
+	  else if (*s == '>')
+	    text = "&gt;";  /* Not sure whether this is really needed.  */
+	  else if (*s == '&')
+	    text = "&amp;";
+	  else if (!*s)
+	    text = "&#00;";
         }
-        if (text) {
-            s--; n++;
+      if (text)
+	{
+	  s--;
+	  n++;
         }
-        if (s != buffer) 
-            rc = _gpgme_data_append ( dh, buffer, s-buffer );
-        if ( !rc && text) {
-            rc = _gpgme_data_append_string ( dh, text );
-            s++; n--;
+      if (s != buffer) 
+	rc = _gpgme_data_append (dh, buffer, s-buffer);
+      if (!rc && text)
+	{
+	  rc = _gpgme_data_append_string (dh, text);
+	  s++;
+	  n--;
         }
-        buffer = s;
-        len = n;
-    } while ( !rc && len );
-    return rc;
+      buffer = s;
+      len = n;
+    }
+  while (!rc && len);
+  return rc;
 }
 
 
@@ -727,61 +796,63 @@ _gpgme_data_append_for_xml ( GpgmeData dh,
  * valid XML. 
  */
 GpgmeError
-_gpgme_data_append_string_for_xml ( GpgmeData dh, const char *string )
+_gpgme_data_append_string_for_xml (GpgmeData dh, const char *string)
 {
-    return _gpgme_data_append_for_xml ( dh, string, strlen (string) );
+  return _gpgme_data_append_for_xml (dh, string, strlen (string));
 }
 
 
 static int
-hextobyte( const byte *s )
+hextobyte(const byte *s)
 {
-    int c;
-
-    if( *s >= '0' && *s <= '9' )
-	c = 16 * (*s - '0');
-    else if( *s >= 'A' && *s <= 'F' )
-	c = 16 * (10 + *s - 'A');
-    else if( *s >= 'a' && *s <= 'f' )
-	c = 16 * (10 + *s - 'a');
-    else
-	return -1;
-    s++;
-    if( *s >= '0' && *s <= '9' )
-	c += *s - '0';
-    else if( *s >= 'A' && *s <= 'F' )
-	c += 10 + *s - 'A';
-    else if( *s >= 'a' && *s <= 'f' )
-	c += 10 + *s - 'a';
-    else
-	return -1;
-    return c;
+  int c;
+
+  if (*s >= '0' && *s <= '9')
+    c = 16 * (*s - '0');
+  else if (*s >= 'A' && *s <= 'F')
+    c = 16 * (10 + *s - 'A');
+  else if (*s >= 'a' && *s <= 'f')
+    c = 16 * (10 + *s - 'a');
+  else
+    return -1;
+  s++;
+  if (*s >= '0' && *s <= '9')
+    c += *s - '0';
+  else if (*s >= 'A' && *s <= 'F')
+    c += 10 + *s - 'A';
+  else if (*s >= 'a' && *s <= 'f')
+    c += 10 + *s - 'a';
+  else
+    return -1;
+  return c;
 }
 
 /* 
- * 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 )
+_gpgme_data_append_percentstring_for_xml (GpgmeData dh, const char *string)
 {
-    const byte *s;
-    byte *buf, *d;
-    int val;
-    GpgmeError err;
-
-    d = buf = xtrymalloc ( strlen (string) );
-    for (s=string; *s; s++ ) {
-        if ( *s == '%' && (val=hextobyte (s+1)) != -1 ) {
-            *d++ = val;
-            s += 2;
+  const byte *s;
+  byte *buf, *d;
+  int val;
+  GpgmeError err;
+
+  d = buf = xtrymalloc (strlen (string));
+  for (s = string; *s; s++)
+    {
+      if (*s == '%' && (val = hextobyte (s+1)) != -1)
+	{
+	  *d++ = val;
+	  s += 2;
         }
-        else
-            *d++ = *s;
+      else
+	*d++ = *s;
     }
 
-    err = _gpgme_data_append_for_xml ( dh, buf, d - buf );
-    xfree (buf);
-    return err;
+  err = _gpgme_data_append_for_xml (dh, buf, d - buf);
+  xfree (buf);
+  return err;
 }
 
 /* Functions to support the wait interface.  */
diff --git a/gpgme/gpgme.c b/gpgme/gpgme.c
index 917f150e..7e4bee39 100644
--- a/gpgme/gpgme.c
+++ b/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,15 +41,18 @@
 GpgmeError
 gpgme_new (GpgmeCtx *r_ctx)
 {
-    GpgmeCtx c;
+  GpgmeCtx ctx;
 
-    c = xtrycalloc ( 1, sizeof *c );
-    if (!c)
-        return mk_error (Out_Of_Core);
-    c->verbosity = 1;
-    *r_ctx = 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);
+  ctx->verbosity = 1;
+  *r_ctx = ctx;
 
-    return 0;
+  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 )
-        return NULL;
-    return _gpgme_data_get_as_string ( c->notation );
+  if (!ctx->notation)
+    return NULL;
+  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;
+  if (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)
-        return;
-    c->keylist_mode = mode;
+  if (!ctx)
+    return;
+  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
  * 
@@ -336,7 +335,7 @@ gpgme_set_passphrase_cb ( GpgmeCtx c, GpgmePassphraseCb cb, void *cb_value )
  *
  * The callback function is defined as:
  * <literal>
- * typedef void (*GpgmeProgressCb) (void*cb_value,
+ * typedef void (*GpgmeProgressCb) (void *cb_value,
  *                                  const char *what, int type,
  *                                  int curretn, int total);
  * </literal>
@@ -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;
     }
 }
-
-
-
-
-
-
-
-
-