gpg: Screen keyserver responses.
[gnupg.git] / g10 / armor.c
index 489f73d..efdc92e 100644 (file)
@@ -1,12 +1,12 @@
 /* armor.c - Armor flter
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
- *               2004 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+ *               2007 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -15,8 +15,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
@@ -27,9 +26,9 @@
 #include <assert.h>
 #include <ctype.h>
 
-#include "errors.h"
+#include "gpg.h"
+#include "status.h"
 #include "iobuf.h"
-#include "memory.h"
 #include "util.h"
 #include "filter.h"
 #include "packet.h"
 #include "status.h"
 #include "i18n.h"
 
-#ifdef HAVE_DOSISH_SYSTEM
-#define LF "\r\n"
-#else
-#define LF "\n"
-#endif
-
 #define MAX_LINELEN 20000
 
 #define CRCINIT 0xB704CE
@@ -119,6 +112,53 @@ static char *tail_strings[] = {
 };
 
 
+static int armor_filter ( void *opaque, int control,
+                          iobuf_t chain, byte *buf, size_t *ret_len);
+
+
+
+\f
+/* Create a new context for armor filters.  */
+armor_filter_context_t *
+new_armor_context (void)
+{
+  armor_filter_context_t *afx;
+
+  afx = xcalloc (1, sizeof *afx);
+  afx->refcount = 1;
+
+  return afx;
+}
+
+/* Release an armor filter context.  Passing NULL is explicitly
+   allowed and a no-op.  */
+void
+release_armor_context (armor_filter_context_t *afx)
+{
+  if (!afx)
+    return;
+  assert (afx->refcount);
+  if ( --afx->refcount )
+    return;
+  xfree (afx);
+}
+
+/* Push the armor filter onto the iobuf stream IOBUF.  */
+int
+push_armor_filter (armor_filter_context_t *afx, iobuf_t iobuf)
+{
+  int rc;
+
+  afx->refcount++;
+  rc = iobuf_push_filter (iobuf, armor_filter, afx);
+  if (rc)
+    afx->refcount--;
+  return rc;
+}
+
+
+
+
 
 static void
 initialize(void)
@@ -248,12 +288,14 @@ parse_hash_header( const char *line )
            found |= 2;
        else if( !strncmp( s, "MD5", s2-s ) )
            found |= 4;
-       else if( !strncmp( s, "SHA256", s2-s ) )
+       else if( !strncmp( s, "SHA224", s2-s ) )
            found |= 8;
-       else if( !strncmp( s, "SHA384", s2-s ) )
+       else if( !strncmp( s, "SHA256", s2-s ) )
            found |= 16;
-       else if( !strncmp( s, "SHA512", s2-s ) )
+       else if( !strncmp( s, "SHA384", s2-s ) )
            found |= 32;
+       else if( !strncmp( s, "SHA512", s2-s ) )
+           found |= 64;
        else
            return 0;
        for(; *s2 && (*s2==' ' || *s2 == '\t'); s2++ )
@@ -266,7 +308,19 @@ parse_hash_header( const char *line )
     return found;
 }
 
+/* Returns true if this is a valid armor tag as per RFC-2440bis-21. */
+static int
+is_armor_tag(const char *line)
+{
+  if(strncmp(line,"Version",7)==0
+     || strncmp(line,"Comment",7)==0
+     || strncmp(line,"MessageID",9)==0
+     || strncmp(line,"Hash",4)==0
+     || strncmp(line,"Charset",7)==0)
+    return 1;
 
+  return 0;
+}
 
 /****************
  * Check whether this is a armor line.
@@ -291,17 +345,25 @@ is_armor_header( byte *line, unsigned len )
     save_p = p;
     p += 5;
 
-    /* Some mail programs on Windows seem to add spaces to the end of
-       the line.  This becomes strict if --openpgp is set. */
-
-    if(!RFC2440)
-      while(*p==' ')
+    /* Some Windows environments seem to add whitespace to the end of
+       the line, so we strip it here.  This becomes strict if
+       --rfc2440 is set since 2440 reads "The header lines, therefore,
+       MUST start at the beginning of a line, and MUST NOT have text
+       following them on the same line."  It is unclear whether "text"
+       refers to all text or just non-whitespace text.  4880 clarified
+       this was only non-whitespace text. */
+
+    if(RFC2440)
+      {
+       if( *p == '\r' )
+         p++;
+       if( *p == '\n' )
+         p++;
+      }
+    else
+      while(*p==' ' || *p=='\r' || *p=='\n' || *p=='\t')
        p++;
 
-    if( *p == '\r' )
-       p++;
-    if( *p == '\n' )
-       p++;
     if( *p )
        return -1; /* garbage after dashes */
     save_c = *save_p; *save_p = 0;
@@ -333,38 +395,68 @@ parse_header_line( armor_filter_context_t *afx, byte *line, unsigned int len )
     int hashes=0;
     unsigned int len2;
 
-    len2 = check_trailing_ws( line, len );
+    len2 = length_sans_trailing_ws ( line, len );
     if( !len2 ) {
         afx->buffer_pos = len2;  /* (it is not the fine way to do it here) */
        return 0; /* WS only: same as empty line */
     }
-    len = len2;
-    line[len2] = 0;
+
+    /*
+      This is fussy.  The spec says that a header line is delimited
+      with a colon-space pair.  This means that a line such as
+      "Comment: " (with nothing else) is actually legal as an empty
+      string comment.  However, email and cut-and-paste being what it
+      is, that trailing space may go away.  Therefore, we accept empty
+      headers delimited with only a colon.  --rfc2440, as always,
+      makes this strict and enforces the colon-space pair. -dms
+    */
 
     p = strchr( line, ':');
-    if( !p || !p[1] ) {
-       log_error(_("invalid armor header: "));
-       print_string( stderr, line, len, 0 );
-       putc('\n', stderr);
+    if( !p || (RFC2440 && p[1]!=' ')
+       || (!RFC2440 && p[1]!=' ' && p[1]!='\n' && p[1]!='\r'))
+      {
+       log_error (_("invalid armor header: "));
+       es_write_sanitized (log_get_stream (), line, len, NULL, NULL);
+       log_printf ("\n");
        return -1;
-    }
+      }
+
+    /* Chop off the whitespace we detected before */
+    len=len2;
+    line[len2]='\0';
 
     if( opt.verbose ) {
        log_info(_("armor header: "));
-       print_string( stderr, line, len, 0 );
-       putc('\n', stderr);
+       es_write_sanitized (log_get_stream (), line, len, NULL, NULL);
+       log_printf ("\n");
     }
 
-    if( afx->in_cleartext ) {
+    if( afx->in_cleartext )
+      {
        if( (hashes=parse_hash_header( line )) )
-           afx->hashes |= hashes;
+         afx->hashes |= hashes;
        else if( strlen(line) > 15 && !memcmp( line, "NotDashEscaped:", 15 ) )
-           afx->not_dash_escaped = 1;
-       else {
+         afx->not_dash_escaped = 1;
+       else
+         {
            log_error(_("invalid clearsig header\n"));
            return -1;
-       }
-    }
+         }
+      }
+    else if(!is_armor_tag(line))
+      {
+       /* Section 6.2: "Unknown keys should be reported to the user,
+          but OpenPGP should continue to process the message."  Note
+          that in a clearsigned message this applies to the signature
+          part (i.e. "BEGIN PGP SIGNATURE") and not the signed data
+          ("BEGIN PGP SIGNED MESSAGE").  The only key allowed in the
+          signed data section is "Hash". */
+
+       log_info(_("unknown armor header: "));
+       es_write_sanitized (log_get_stream (), line, len, NULL, NULL);
+       log_printf ("\n");
+      }
+
     return 1;
 }
 
@@ -414,7 +506,7 @@ check_input( armor_filter_context_t *afx, IOBUF a )
            if( hdr_line == BEGIN_SIGNED_MSG_IDX ) {
                if( afx->in_cleartext ) {
                    log_error(_("nested clear text signatures\n"));
-                   rc = G10ERR_INVALID_ARMOR;
+                   rc = gpg_error (GPG_ERR_INV_ARMOR);
                }
                afx->in_cleartext = 1;
            }
@@ -430,9 +522,9 @@ check_input( armor_filter_context_t *afx, IOBUF a )
        } while( !maxlen );
     }
 
-    /* parse the header lines */
+    /* Parse the header lines.  */
     while(len) {
-       /* read the next line (skip all truncated lines) */
+       /* Read the next line (skip all truncated lines). */
        do {
            maxlen = MAX_LINELEN;
            afx->buffer_len = iobuf_read_line( a, &afx->buffer,
@@ -443,7 +535,7 @@ check_input( armor_filter_context_t *afx, IOBUF a )
 
        i = parse_header_line( afx, line, len );
        if( i <= 0 ) {
-           if( i )
+           if (i && RFC2440)
                rc = G10ERR_INVALID_ARMOR;
            break;
        }
@@ -518,15 +610,65 @@ fake_packet( armor_filter_context_t *afx, IOBUF a,
        }
        if( !maxlen )
            afx->truncated++;
-       if( !afx->not_dash_escaped ) {
-           int crlf;
-           p = afx->buffer;
-           n = afx->buffer_len;
-           crlf = n > 1 && p[n-2] == '\r' && p[n-1]=='\n';
+
+       p = afx->buffer;
+       n = afx->buffer_len;
+
+       /* Armor header or dash-escaped line? */
+       if(p[0]=='-')
+         {
+           /* 2440bis-10: When reversing dash-escaping, an
+              implementation MUST strip the string "- " if it occurs
+              at the beginning of a line, and SHOULD warn on "-" and
+              any character other than a space at the beginning of a
+              line.  */
+
+           if(p[1]==' ' && !afx->not_dash_escaped)
+             {
+               /* It's a dash-escaped line, so skip over the
+                  escape. */
+               afx->buffer_pos = 2;
+             }
+           else if(p[1]=='-' && p[2]=='-' && p[3]=='-' && p[4]=='-')
+             {
+               /* Five dashes in a row mean it's probably armor
+                  header. */
+               int type = is_armor_header( p, n );
+               if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
+                 ; /* this is okay */
+               else
+                 {
+                   if( type != BEGIN_SIGNATURE )
+                     {
+                       log_info(_("unexpected armor: "));
+                       es_write_sanitized (log_get_stream (), p, n,
+                                            NULL, NULL);
+                       log_printf ("\n");
+                     }
+
+                   lastline = 1;
+                   rc = -1;
+                 }
+             }
+           else if(!afx->not_dash_escaped)
+             {
+               /* Bad dash-escaping. */
+               log_info (_("invalid dash escaped line: "));
+               es_write_sanitized (log_get_stream (), p, n, NULL, NULL);
+               log_printf ("\n");
+             }
+         }
+
+       /* Now handle the end-of-line canonicalization */
+       if( !afx->not_dash_escaped )
+         {
+           int crlf = n > 1 && p[n-2] == '\r' && p[n-1]=='\n';
 
            /* PGP2 does not treat a tab as white space character */
-           afx->buffer_len = trim_trailing_chars( p, n,
-                                        afx->pgp2mode ? " \r\n" : " \t\r\n");
+           afx->buffer_len=
+             trim_trailing_chars( &p[afx->buffer_pos], n-afx->buffer_pos,
+                                  afx->pgp2mode ? " \r\n" : " \t\r\n");
+           afx->buffer_len+=afx->buffer_pos;
            /* the buffer is always allocated with enough space to append
             * the removed [CR], LF and a Nul
             * The reason for this complicated procedure is to keep at least
@@ -538,37 +680,9 @@ fake_packet( armor_filter_context_t *afx, IOBUF a,
             * faked packet could do the job).
             */
            if( crlf )
-               afx->buffer[afx->buffer_len++] = '\r';
+             afx->buffer[afx->buffer_len++] = '\r';
            afx->buffer[afx->buffer_len++] = '\n';
-           afx->buffer[afx->buffer_len] = 0;
-       }
-       p = afx->buffer;
-       n = afx->buffer_len;
-
-       if( n > 2 && *p == '-' )
-         {
-           /* check for dash escaped or armor header */
-           if( p[1] == ' ' && !afx->not_dash_escaped )
-             {
-               /* It's a dash-escaped line */
-               afx->buffer_pos = 2; /* skip */
-             }
-           else if( n >= 15 &&  p[1] == '-' && p[2] == '-' && p[3] == '-' )
-             {
-               /* It's armor header */
-               int type = is_armor_header( p, n );
-               if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
-                 ; /* this is okay */
-               else {
-                 if( type != BEGIN_SIGNATURE ) {
-                   log_info(_("unexpected armor: "));
-                   print_string( stderr, p, n, 0 );
-                   putc('\n', stderr);
-                 }
-                 lastline = 1;
-                 rc = -1;
-               }
-             }
+           afx->buffer[afx->buffer_len] = '\0';
          }
     }
 
@@ -624,10 +738,10 @@ fake_packet( armor_filter_context_t *afx, IOBUF a,
 static int
 invalid_crc(void)
 {
-    if ( opt.ignore_crc_error )
-        return 0;
-    log_inc_errorcount();
-    return G10ERR_INVALID_ARMOR;
+  if ( opt.ignore_crc_error )
+    return 0;
+  log_inc_errorcount();
+  return gpg_error (GPG_ERR_INV_ARMOR);
 }
 
 
@@ -640,7 +754,7 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
     int checkcrc=0;
     int rc = 0;
     size_t n = 0;
-    int  idx, i;
+    int  idx, i, onlypad=0;
     u32 crc;
 
     crc = afx->crc;
@@ -685,6 +799,9 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
                }
            }
 
+           if (!n)
+             onlypad = 1;
+
            if( idx == 1 )
                buf[n++] = val;
            checkcrc++;
@@ -812,7 +929,7 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
        }
     }
 
-    if( !n )
+    if( !n && !onlypad )
        rc = -1;
 
     *retn = n;
@@ -822,7 +939,7 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
 /****************
  * This filter is used to handle the armor stuff
  */
-int
+static int
 armor_filter( void *opaque, int control,
             IOBUF a, byte *buf, size_t *ret_len)
 {
@@ -865,7 +982,7 @@ armor_filter( void *opaque, int control,
         /* We need some space for the faked packet.  The minmum
          * required size is the PARTIAL_CHUNK size plus a byte for the
          * length itself */
-       if( size < PARTIAL_CHUNK+1 ) 
+       if( size < PARTIAL_CHUNK+1 )
            BUG(); /* supplied buffer too short */
 
        if( afx->faked )
@@ -884,7 +1001,7 @@ armor_filter( void *opaque, int control,
                unsigned int hashes = afx->hashes;
                 const byte *sesmark;
                 size_t sesmarklen;
-                
+
                 sesmark = get_session_marker( &sesmarklen );
                 if ( sesmarklen > 20 )
                     BUG();
@@ -906,7 +1023,7 @@ armor_filter( void *opaque, int control,
                 buf[n++] = 0xff; /* new format, type 63, 1 length byte */
                 n++;   /* see below */
                 memcpy(buf+n, sesmark, sesmarklen ); n+= sesmarklen;
-                buf[n++] = CTRLPKT_CLEARSIGN_START; 
+                buf[n++] = CTRLPKT_CLEARSIGN_START;
                 buf[n++] = afx->not_dash_escaped? 0:1; /* sigclass */
                 if( hashes & 1 )
                     buf[n++] = DIGEST_ALGO_RMD160;
@@ -915,10 +1032,12 @@ armor_filter( void *opaque, int control,
                 if( hashes & 4 )
                     buf[n++] = DIGEST_ALGO_MD5;
                 if( hashes & 8 )
-                    buf[n++] = DIGEST_ALGO_SHA256;
+                    buf[n++] = DIGEST_ALGO_SHA224;
                 if( hashes & 16 )
-                    buf[n++] = DIGEST_ALGO_SHA384;
+                    buf[n++] = DIGEST_ALGO_SHA256;
                 if( hashes & 32 )
+                    buf[n++] = DIGEST_ALGO_SHA384;
+                if( hashes & 64 )
                     buf[n++] = DIGEST_ALGO_SHA512;
                 buf[1] = n - 2;
 
@@ -950,16 +1069,34 @@ armor_filter( void *opaque, int control,
     else if( control == IOBUFCTRL_FLUSH && !afx->cancel ) {
        if( !afx->status ) { /* write the header line */
            const char *s;
-           STRLIST comment=opt.comments;
+           strlist_t comment=opt.comments;
 
            if( afx->what >= DIM(head_strings) )
                log_bug("afx->what=%d", afx->what);
            iobuf_writestr(a, "-----");
            iobuf_writestr(a, head_strings[afx->what] );
-           iobuf_writestr(a, "-----" LF );
-           if( !opt.no_version )
-               iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
-                                             PRINTABLE_OS_NAME ")" LF );
+           iobuf_writestr(a, "-----" );
+           iobuf_writestr(a,afx->eol);
+           if (opt.emit_version)
+             {
+               iobuf_writestr (a, "Version: "GNUPG_NAME" v");
+                for (s=VERSION; *s && *s != '.'; s++)
+                  iobuf_writebyte (a, *s);
+                if (opt.emit_version > 1 && *s)
+                  {
+                    iobuf_writebyte (a, *s++);
+                    for (; *s && *s != '.'; s++)
+                      iobuf_writebyte (a, *s);
+                    if (opt.emit_version > 2)
+                      {
+                        for (; *s && *s != '-' && !spacep (s); s++)
+                          iobuf_writebyte (a, *s);
+                        if (opt.emit_version > 3)
+                          iobuf_writestr (a, " (" PRINTABLE_OS_NAME ")");
+                      }
+                  }
+               iobuf_writestr(a,afx->eol);
+             }
 
            /* write the comment strings */
            for(s=comment->d;comment;comment=comment->next,s=comment->d)
@@ -976,7 +1113,8 @@ armor_filter( void *opaque, int control,
                    else
                      iobuf_put(a, *s );
                  }
-               iobuf_writestr(a, LF );
+
+               iobuf_writestr(a,afx->eol);
              }
 
            if ( afx->hdrlines ) {
@@ -988,7 +1126,8 @@ armor_filter( void *opaque, int control,
                     iobuf_put(a, *s );
                 }
             }
-           iobuf_writestr(a, LF );
+
+           iobuf_writestr(a,afx->eol);
            afx->status++;
            afx->idx = 0;
            afx->idx2 = 0;
@@ -1017,10 +1156,11 @@ armor_filter( void *opaque, int control,
                iobuf_put(a, c);
                c = bintoasc[radbuf[2]&077];
                iobuf_put(a, c);
-               if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
-                   iobuf_writestr(a, LF );
+               if( ++idx2 >= (64/4) )
+                 { /* pgp doesn't like 72 here */
+                   iobuf_writestr(a,afx->eol);
                    idx2=0;
-               }
+                 }
            }
        }
        for(i=0; i < idx; i++ )
@@ -1029,10 +1169,23 @@ armor_filter( void *opaque, int control,
        afx->idx2 = idx2;
        afx->crc  = crc;
     }
-    else if( control == IOBUFCTRL_INIT ) {
+    else if( control == IOBUFCTRL_INIT )
+      {
        if( !is_initialized )
-           initialize();
-    }
+         initialize();
+
+       /* Figure out what we're using for line endings if the caller
+          didn't specify. */
+       if(afx->eol[0]==0)
+         {
+#ifdef HAVE_DOSISH_SYSTEM
+           afx->eol[0]='\r';
+           afx->eol[1]='\n';
+#else
+           afx->eol[0]='\n';
+#endif
+         }
+      }
     else if( control == IOBUFCTRL_CANCEL ) {
        afx->cancel = 1;
     }
@@ -1043,32 +1196,32 @@ armor_filter( void *opaque, int control,
            crc = afx->crc;
            idx = afx->idx;
            idx2 = afx->idx2;
-           for(i=0; i < idx; i++ )
-               radbuf[i] = afx->radbuf[i];
            if( idx ) {
-               c = bintoasc[(*radbuf>>2)&077];
+               c = bintoasc[(afx->radbuf[0]>>2)&077];
                iobuf_put(a, c);
                if( idx == 1 ) {
-                   c = bintoasc[((*radbuf << 4) & 060) & 077];
+                   c = bintoasc[((afx->radbuf[0] << 4) & 060) & 077];
                    iobuf_put(a, c);
                    iobuf_put(a, '=');
                    iobuf_put(a, '=');
                }
                else { /* 2 */
-                   c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
+                   c = bintoasc[(((afx->radbuf[0]<<4)&060)
+                                  |((afx->radbuf[1]>>4)&017))&077];
                    iobuf_put(a, c);
-                   c = bintoasc[((radbuf[1] << 2) & 074) & 077];
+                   c = bintoasc[((afx->radbuf[1] << 2) & 074) & 077];
                    iobuf_put(a, c);
                    iobuf_put(a, '=');
                }
-               if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
-                   iobuf_writestr(a, LF );
+               if( ++idx2 >= (64/4) )
+                 { /* pgp doesn't like 72 here */
+                   iobuf_writestr(a,afx->eol);
                    idx2=0;
-               }
+                 }
            }
            /* may need a linefeed */
            if( idx2 )
-               iobuf_writestr(a, LF );
+             iobuf_writestr(a,afx->eol);
            /* write the CRC */
            iobuf_put(a, '=');
            radbuf[0] = crc >>16;
@@ -1082,13 +1235,14 @@ armor_filter( void *opaque, int control,
            iobuf_put(a, c);
            c = bintoasc[radbuf[2]&077];
            iobuf_put(a, c);
-           iobuf_writestr(a, LF );
+           iobuf_writestr(a,afx->eol);
            /* and the the trailer */
            if( afx->what >= DIM(tail_strings) )
                log_bug("afx->what=%d", afx->what);
            iobuf_writestr(a, "-----");
            iobuf_writestr(a, tail_strings[afx->what] );
-           iobuf_writestr(a, "-----" LF );
+           iobuf_writestr(a, "-----" );
+           iobuf_writestr(a,afx->eol);
        }
        else if( !afx->any_data && !afx->inp_bypass ) {
            log_error(_("no valid OpenPGP data found.\n"));
@@ -1102,8 +1256,9 @@ armor_filter( void *opaque, int control,
        if( afx->qp_detected )
            log_error(_("quoted printable character in armor - "
                        "probably a buggy MTA has been used\n") );
-       m_free( afx->buffer );
+       xfree( afx->buffer );
        afx->buffer = NULL;
+        release_armor_context (afx);
     }
     else if( control == IOBUFCTRL_DESC )
        *(char**)buf = "armor_filter";
@@ -1119,7 +1274,7 @@ make_radix64_string( const byte *data, size_t len )
 {
     char *buffer, *p;
 
-    buffer = p = m_alloc( (len+2)/3*4 + 1 );
+    buffer = p = xmalloc( (len+2)/3*4 + 1 );
     for( ; len >= 3 ; len -= 3, data += 3 ) {
        *p++ = bintoasc[(data[0] >> 2) & 077];
        *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
@@ -1142,7 +1297,7 @@ make_radix64_string( const byte *data, size_t len )
 
 /***********************************************
  *  For the pipemode command we can't use the armor filter for various
- *  reasons, so we use this new unarmor_pump stuff to remove the armor 
+ *  reasons, so we use this new unarmor_pump stuff to remove the armor
  */
 
 enum unarmor_state_e {
@@ -1150,7 +1305,7 @@ enum unarmor_state_e {
     STA_bypass,
     STA_wait_newline,
     STA_wait_dash,
-    STA_first_dash, 
+    STA_first_dash,
     STA_compare_header,
     STA_found_header_wait_newline,
     STA_skip_header_lines,
@@ -1179,22 +1334,22 @@ unarmor_pump_new (void)
 
     if( !is_initialized )
         initialize();
-    x = m_alloc_clear (sizeof *x);
+    x = xmalloc_clear (sizeof *x);
     return x;
 }
 
 void
 unarmor_pump_release (UnarmorPump x)
 {
-    m_free (x);
+    xfree (x);
 }
 
-/* 
+/*
  * Get the next character from the ascii armor taken from the IOBUF
  * created earlier by unarmor_pump_new().
  * Return:  c = Character
  *        256 = ignore this value
- *         -1 = End of current armor 
+ *         -1 = End of current armor
  *         -2 = Premature EOF (not used)
  *         -3 = Invalid armor
  */
@@ -1205,9 +1360,9 @@ unarmor_pump (UnarmorPump x, int c)
 
     switch (x->state) {
       case STA_init:
-        { 
+        {
             byte tmp[1];
-            tmp[0] = c; 
+            tmp[0] = c;
             if ( is_armored (tmp) )
                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
             else {
@@ -1230,10 +1385,10 @@ unarmor_pump (UnarmorPump x, int c)
         x->state = STA_compare_header;
       case STA_compare_header:
         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
-            if ( x->pos == 28 ) 
+            if ( x->pos == 28 )
                 x->state = STA_found_header_wait_newline;
         }
-        else 
+        else
             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
         break;
       case STA_found_header_wait_newline:
@@ -1280,7 +1435,7 @@ unarmor_pump (UnarmorPump x, int c)
                 break;
             }
         }
-        
+
         switch(x->pos) {
           case 0:
             x->val = c << 2;
@@ -1321,7 +1476,7 @@ unarmor_pump (UnarmorPump x, int c)
             x->state = STA_ready; /* not sure whether this is correct */
             break;
         }
-        
+
         switch(x->pos) {
           case 0:
             x->val = c << 2;