1a9f82e89c1ddcd1a66fe542006f486764847f16
[gnupg.git] / g10 / armor.c
1 /* armor.c - Armor flter
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <ctype.h>
28
29 #include "gpg.h"
30 #include "errors.h"
31 #include "iobuf.h"
32 #include "util.h"
33 #include "filter.h"
34 #include "packet.h"
35 #include "options.h"
36 #include "main.h"
37 #include "status.h"
38 #include "i18n.h"
39
40 #define MAX_LINELEN 20000
41
42 #define CRCINIT 0xB704CE
43 #define CRCPOLY 0X864CFB
44 #define CRCUPDATE(a,c) do {                                                 \
45                         a = ((a) << 8) ^ crc_table[((a)&0xff >> 16) ^ (c)]; \
46                         a &= 0x00ffffff;                                    \
47                     } while(0)
48 static u32 crc_table[256];
49 static byte bintoasc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
50                          "abcdefghijklmnopqrstuvwxyz"
51                          "0123456789+/";
52 static byte asctobin[256]; /* runtime initialized */
53 static int is_initialized;
54
55
56 typedef enum {
57     fhdrHASArmor = 0,
58     fhdrNOArmor,
59     fhdrINIT,
60     fhdrINITCont,
61     fhdrINITSkip,
62     fhdrCHECKBegin,
63     fhdrWAITHeader,
64     fhdrWAITClearsig,
65     fhdrSKIPHeader,
66     fhdrCLEARSIG,
67     fhdrREADClearsig,
68     fhdrNullClearsig,
69     fhdrEMPTYClearsig,
70     fhdrCHECKClearsig,
71     fhdrCHECKClearsig2,
72     fhdrCHECKDashEscaped,
73     fhdrCHECKDashEscaped2,
74     fhdrCHECKDashEscaped3,
75     fhdrREADClearsigNext,
76     fhdrENDClearsig,
77     fhdrENDClearsigHelp,
78     fhdrTESTSpaces,
79     fhdrCLEARSIGSimple,
80     fhdrCLEARSIGSimpleNext,
81     fhdrTEXT,
82     fhdrTEXTSimple,
83     fhdrERROR,
84     fhdrERRORShow,
85     fhdrEOF
86 } fhdr_state_t;
87
88
89 /* if we encounter this armor string with this index, go
90  * into a mode which fakes packets and wait for the next armor */
91 #define BEGIN_SIGNATURE 2
92 #define BEGIN_SIGNED_MSG_IDX 3
93 static char *head_strings[] = {
94     "BEGIN PGP MESSAGE",
95     "BEGIN PGP PUBLIC KEY BLOCK",
96     "BEGIN PGP SIGNATURE",
97     "BEGIN PGP SIGNED MESSAGE",
98     "BEGIN PGP ARMORED FILE",       /* gnupg extension */
99     "BEGIN PGP PRIVATE KEY BLOCK",
100     "BEGIN PGP SECRET KEY BLOCK",   /* only used by pgp2 */
101     NULL
102 };
103 static char *tail_strings[] = {
104     "END PGP MESSAGE",
105     "END PGP PUBLIC KEY BLOCK",
106     "END PGP SIGNATURE",
107     "END dummy",
108     "END PGP ARMORED FILE",
109     "END PGP PRIVATE KEY BLOCK",
110     "END PGP SECRET KEY BLOCK",
111     NULL
112 };
113
114
115 static int armor_filter ( void *opaque, int control,
116                           iobuf_t chain, byte *buf, size_t *ret_len);
117
118
119
120 \f
121 /* Create a new context for armor filters.  */
122 armor_filter_context_t *
123 new_armor_context (void)
124 {
125   armor_filter_context_t *afx;
126
127   afx = xcalloc (1, sizeof *afx);
128   afx->refcount = 1;
129
130   return afx;
131 }
132
133 /* Release an armor filter context.  Passing NULL is explicitly
134    allowed and a no-op.  */
135 void
136 release_armor_context (armor_filter_context_t *afx)
137 {
138   if (!afx)
139     return;
140   assert (afx->refcount);
141   if ( --afx->refcount )
142     return;
143   xfree (afx);
144 }
145
146 /* Push the armor filter onto the iobuf stream IOBUF.  */
147 int
148 push_armor_filter (armor_filter_context_t *afx, iobuf_t iobuf)
149 {
150   int rc; 
151
152   afx->refcount++;
153   rc = iobuf_push_filter (iobuf, armor_filter, afx);
154   if (rc)
155     afx->refcount--;
156   return rc;
157 }
158
159
160
161
162
163 static void
164 initialize(void)
165 {
166     int i, j;
167     u32 t;
168     byte *s;
169
170     /* init the crc lookup table */
171     crc_table[0] = 0;
172     for(i=j=0; j < 128; j++ ) {
173         t = crc_table[j];
174         if( t & 0x00800000 ) {
175             t <<= 1;
176             crc_table[i++] = t ^ CRCPOLY;
177             crc_table[i++] = t;
178         }
179         else {
180             t <<= 1;
181             crc_table[i++] = t;
182             crc_table[i++] = t ^ CRCPOLY;
183         }
184     }
185     /* build the helptable for radix64 to bin conversion */
186     for(i=0; i < 256; i++ )
187         asctobin[i] = 255; /* used to detect invalid characters */
188     for(s=bintoasc,i=0; *s; s++,i++ )
189         asctobin[*s] = i;
190
191     is_initialized=1;
192 }
193
194 /****************
195  * Check whether this is an armored file or not See also
196  * parse-packet.c for details on this code For unknown historic
197  * reasons we use a string here but only the first byte will be used.
198  * Returns: True if it seems to be armored
199  */
200 static int
201 is_armored( const byte *buf )
202 {
203     int ctb, pkttype;
204
205     ctb = *buf;
206     if( !(ctb & 0x80) )
207         return 1; /* invalid packet: assume it is armored */
208     pkttype =  ctb & 0x40 ? (ctb & 0x3f) : ((ctb>>2)&0xf);
209     switch( pkttype ) {
210       case PKT_MARKER:
211       case PKT_SYMKEY_ENC:
212       case PKT_ONEPASS_SIG:
213       case PKT_PUBLIC_KEY:
214       case PKT_SECRET_KEY:
215       case PKT_PUBKEY_ENC:
216       case PKT_SIGNATURE:
217       case PKT_COMMENT:
218       case PKT_OLD_COMMENT:
219       case PKT_PLAINTEXT:
220       case PKT_COMPRESSED:
221       case PKT_ENCRYPTED:
222         return 0; /* seems to be a regular packet: not armored */
223     }
224
225     return 1;
226 }
227
228
229 /****************
230  * Try to check whether the iobuf is armored
231  * Returns true if this may be the case; the caller should use the
232  *         filter to do further processing.
233  */
234 int
235 use_armor_filter( IOBUF a )
236 {
237     byte buf[1];
238     int n;
239
240     /* fixme: there might be a problem with iobuf_peek */
241     n = iobuf_peek(a, buf, 1 );
242     if( n == -1 )
243         return 0; /* EOF, doesn't matter whether armored or not */
244     if( !n )
245         return 1; /* can't check it: try armored */
246     return is_armored(buf);
247 }
248
249
250
251
252 static void
253 invalid_armor(void)
254 {
255     write_status(STATUS_BADARMOR);
256     g10_exit(1); /* stop here */
257 }
258
259
260 /****************
261  * check whether the armor header is valid on a signed message.
262  * this is for security reasons: the header lines are not included in the
263  * hash and by using some creative formatting rules, Mallory could fake
264  * any text at the beginning of a document; assuming it is read with
265  * a simple viewer. We only allow the Hash Header.
266  */
267 static int
268 parse_hash_header( const char *line )
269 {
270     const char *s, *s2;
271     unsigned found = 0;
272
273     if( strlen(line) < 6  || strlen(line) > 60 )
274         return 0; /* too short or too long */
275     if( memcmp( line, "Hash:", 5 ) )
276         return 0; /* invalid header */
277     s = line+5;
278     for(s=line+5;;s=s2) {
279         for(; *s && (*s==' ' || *s == '\t'); s++ )
280             ;
281         if( !*s )
282             break;
283         for(s2=s+1; *s2 && *s2!=' ' && *s2 != '\t' && *s2 != ','; s2++ )
284             ;
285         if( !strncmp( s, "RIPEMD160", s2-s ) )
286             found |= 1;
287         else if( !strncmp( s, "SHA1", s2-s ) )
288             found |= 2;
289         else if( !strncmp( s, "MD5", s2-s ) )
290             found |= 4;
291         else if( !strncmp( s, "SHA224", s2-s ) )
292             found |= 8;
293         else if( !strncmp( s, "SHA256", s2-s ) )
294             found |= 16;
295         else if( !strncmp( s, "SHA384", s2-s ) )
296             found |= 32;
297         else if( !strncmp( s, "SHA512", s2-s ) )
298             found |= 64;
299         else
300             return 0;
301         for(; *s2 && (*s2==' ' || *s2 == '\t'); s2++ )
302             ;
303         if( *s2 && *s2 != ',' )
304             return 0;
305         if( *s2 )
306             s2++;
307     }
308     return found;
309 }
310
311
312
313 /****************
314  * Check whether this is a armor line.
315  * returns: -1 if it is not a armor header or the index number of the
316  * armor header.
317  */
318 static int
319 is_armor_header( byte *line, unsigned len )
320 {
321     const char *s;
322     byte *save_p, *p;
323     int save_c;
324     int i;
325
326     if( len < 15 )
327         return -1; /* too short */
328     if( memcmp( line, "-----", 5 ) )
329         return -1; /* no */
330     p = strstr( line+5, "-----");
331     if( !p )
332         return -1;
333     save_p = p;
334     p += 5;
335
336     /* Some Windows environments seem to add whitespace to the end of
337        the line, so we strip it here.  This becomes strict if
338        --rfc2440 is set since 2440 reads "The header lines, therefore,
339        MUST start at the beginning of a line, and MUST NOT have text
340        following them on the same line."  It is unclear whether "text"
341        refers to all text or just non-whitespace text. */
342
343     if(RFC2440)
344       {
345         if( *p == '\r' )
346           p++;
347         if( *p == '\n' )
348           p++;
349       }
350     else
351       while(*p==' ' || *p=='\r' || *p=='\n' || *p=='\t')
352         p++;
353
354     if( *p )
355         return -1; /* garbage after dashes */
356     save_c = *save_p; *save_p = 0;
357     p = line+5;
358     for(i=0; (s=head_strings[i]); i++ )
359         if( !strcmp(s, p) )
360             break;
361     *save_p = save_c;
362     if( !s )
363         return -1; /* unknown armor line */
364
365     if( opt.verbose > 1 )
366         log_info(_("armor: %s\n"), head_strings[i]);
367     return i;
368 }
369
370
371
372 /****************
373  * Parse a header lines
374  * Return 0: Empty line (end of header lines)
375  *       -1: invalid header line
376  *       >0: Good header line
377  */
378 static int
379 parse_header_line( armor_filter_context_t *afx, byte *line, unsigned int len )
380 {
381     byte *p;
382     int hashes=0;
383     unsigned int len2;
384
385     len2 = length_sans_trailing_ws ( line, len );
386     if( !len2 ) {
387         afx->buffer_pos = len2;  /* (it is not the fine way to do it here) */
388         return 0; /* WS only: same as empty line */
389     }
390
391     /*
392       This is fussy.  The spec says that a header line is delimited
393       with a colon-space pair.  This means that a line such as
394       "Comment: " (with nothing else) is actually legal as an empty
395       string comment.  However, email and cut-and-paste being what it
396       is, that trailing space may go away.  Therefore, we accept empty
397       headers delimited with only a colon.  --rfc2440, as always,
398       makes this strict and enforces the colon-space pair. -dms
399     */
400
401     p = strchr( line, ':');
402     if( !p || (RFC2440 && p[1]!=' ')
403         || (!RFC2440 && p[1]!=' ' && p[1]!='\n' && p[1]!='\r'))
404       {
405         log_error(_("invalid armor header: "));
406         print_string( stderr, line, len, 0 );
407         putc('\n', stderr);
408         return -1;
409       }
410
411     /* Chop off the whitespace we detected before */
412     len=len2;
413     line[len2]='\0';
414
415     if( opt.verbose ) {
416         log_info(_("armor header: "));
417         print_string( stderr, line, len, 0 );
418         putc('\n', stderr);
419     }
420
421     if( afx->in_cleartext ) {
422         if( (hashes=parse_hash_header( line )) )
423             afx->hashes |= hashes;
424         else if( strlen(line) > 15 && !memcmp( line, "NotDashEscaped:", 15 ) )
425             afx->not_dash_escaped = 1;
426         else {
427             log_error(_("invalid clearsig header\n"));
428             return -1;
429         }
430     }
431     return 1;
432 }
433
434
435
436 /* figure out whether the data is armored or not */
437 static int
438 check_input( armor_filter_context_t *afx, IOBUF a )
439 {
440     int rc = 0;
441     int i;
442     byte *line;
443     unsigned len;
444     unsigned maxlen;
445     int hdr_line = -1;
446
447     /* read the first line to see whether this is armored data */
448     maxlen = MAX_LINELEN;
449     len = afx->buffer_len = iobuf_read_line( a, &afx->buffer,
450                                              &afx->buffer_size, &maxlen );
451     line = afx->buffer;
452     if( !maxlen ) {
453         /* line has been truncated: assume not armored */
454         afx->inp_checked = 1;
455         afx->inp_bypass = 1;
456         return 0;
457     }
458
459     if( !len ) {
460         return -1; /* eof */
461     }
462
463     /* (the line is always a C string but maybe longer) */
464     if( *line == '\n' || ( len && (*line == '\r' && line[1]=='\n') ) )
465         ;
466     else if( !is_armored( line ) ) {
467         afx->inp_checked = 1;
468         afx->inp_bypass = 1;
469         return 0;
470     }
471
472     /* find the armor header */
473     while(len) {
474         i = is_armor_header( line, len );
475         if( i >= 0 && !(afx->only_keyblocks && i != 1 && i != 5 && i != 6 )) {
476             hdr_line = i;
477             if( hdr_line == BEGIN_SIGNED_MSG_IDX ) {
478                 if( afx->in_cleartext ) {
479                     log_error(_("nested clear text signatures\n"));
480                     rc = gpg_error (GPG_ERR_INV_ARMOR);
481                 }
482                 afx->in_cleartext = 1;
483             }
484             break;
485         }
486         /* read the next line (skip all truncated lines) */
487         do {
488             maxlen = MAX_LINELEN;
489             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
490                                                &afx->buffer_size, &maxlen );
491             line = afx->buffer;
492             len = afx->buffer_len;
493         } while( !maxlen );
494     }
495
496     /* Parse the header lines.  */
497     while(len) {
498         /* Read the next line (skip all truncated lines). */
499         do {
500             maxlen = MAX_LINELEN;
501             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
502                                                &afx->buffer_size, &maxlen );
503             line = afx->buffer;
504             len = afx->buffer_len;
505         } while( !maxlen );
506
507         i = parse_header_line( afx, line, len );
508         if( i <= 0 ) {
509             if (i && RFC2440)
510                 rc = G10ERR_INVALID_ARMOR;
511             break;
512         }
513     }
514
515
516     if( rc )
517         invalid_armor();
518     else if( afx->in_cleartext )
519         afx->faked = 1;
520     else {
521         afx->inp_checked = 1;
522         afx->crc = CRCINIT;
523         afx->idx = 0;
524         afx->radbuf[0] = 0;
525     }
526
527     return rc;
528 }
529
530 #define PARTIAL_CHUNK 512
531 #define PARTIAL_POW   9
532
533 /****************
534  * Fake a literal data packet and wait for the next armor line
535  * fixme: empty line handling and null length clear text signature are
536  *        not implemented/checked.
537  */
538 static int
539 fake_packet( armor_filter_context_t *afx, IOBUF a,
540              size_t *retn, byte *buf, size_t size  )
541 {
542     int rc = 0;
543     size_t len = 0;
544     int lastline = 0;
545     unsigned maxlen, n;
546     byte *p;
547     byte tempbuf[PARTIAL_CHUNK];
548     size_t tempbuf_len=0;
549
550     while( !rc && size-len>=(PARTIAL_CHUNK+1)) {
551         /* copy what we have in the line buffer */
552         if( afx->faked == 1 )
553             afx->faked++; /* skip the first (empty) line */
554         else
555           {
556             /* It's full, so write this partial chunk */
557             if(tempbuf_len==PARTIAL_CHUNK)
558               {
559                 buf[len++]=0xE0+PARTIAL_POW;
560                 memcpy(&buf[len],tempbuf,PARTIAL_CHUNK);
561                 len+=PARTIAL_CHUNK;
562                 tempbuf_len=0;
563                 continue;
564               }
565
566             while( tempbuf_len < PARTIAL_CHUNK
567                    && afx->buffer_pos < afx->buffer_len )
568               tempbuf[tempbuf_len++] = afx->buffer[afx->buffer_pos++];
569             if( tempbuf_len==PARTIAL_CHUNK )
570               continue;
571           }
572
573         /* read the next line */
574         maxlen = MAX_LINELEN;
575         afx->buffer_pos = 0;
576         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
577                                            &afx->buffer_size, &maxlen );
578         if( !afx->buffer_len ) {
579             rc = -1; /* eof (should not happen) */
580             continue;
581         }
582         if( !maxlen )
583             afx->truncated++;
584
585         p = afx->buffer;
586         n = afx->buffer_len;
587
588         /* Armor header or dash-escaped line? */
589         if(p[0]=='-')
590           {
591             /* 2440bis-10: When reversing dash-escaping, an
592                implementation MUST strip the string "- " if it occurs
593                at the beginning of a line, and SHOULD warn on "-" and
594                any character other than a space at the beginning of a
595                line.  */
596
597             if(p[1]==' ' && !afx->not_dash_escaped)
598               {
599                 /* It's a dash-escaped line, so skip over the
600                    escape. */
601                 afx->buffer_pos = 2;
602               }
603             else if(p[1]=='-' && p[2]=='-' && p[3]=='-' && p[4]=='-')
604               {
605                 /* Five dashes in a row mean it's probably armor
606                    header. */
607                 int type = is_armor_header( p, n );
608                 if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
609                   ; /* this is okay */
610                 else
611                   {
612                     if( type != BEGIN_SIGNATURE )
613                       {
614                         log_info(_("unexpected armor: "));
615                         print_string( stderr, p, n, 0 );
616                         putc('\n', stderr);
617                       }
618
619                     lastline = 1;
620                     rc = -1;
621                   }
622               }
623             else if(!afx->not_dash_escaped)
624               {
625                 /* Bad dash-escaping. */
626                 log_info(_("invalid dash escaped line: "));
627                 print_string( stderr, p, n, 0 );
628                 putc('\n', stderr);
629               }
630           }
631
632         /* Now handle the end-of-line canonicalization */
633         if( !afx->not_dash_escaped )
634           {
635             int crlf = n > 1 && p[n-2] == '\r' && p[n-1]=='\n';
636
637             /* PGP2 does not treat a tab as white space character */
638             afx->buffer_len=
639               trim_trailing_chars( &p[afx->buffer_pos], n-afx->buffer_pos,
640                                    afx->pgp2mode ? " \r\n" : " \t\r\n");
641             afx->buffer_len+=afx->buffer_pos;
642             /* the buffer is always allocated with enough space to append
643              * the removed [CR], LF and a Nul
644              * The reason for this complicated procedure is to keep at least
645              * the original type of lineending - handling of the removed
646              * trailing spaces seems to be impossible in our method
647              * of faking a packet; either we have to use a temporary file
648              * or calculate the hash here in this module and somehow find
649              * a way to send the hash down the processing line (well, a special
650              * faked packet could do the job).
651              */
652             if( crlf )
653               afx->buffer[afx->buffer_len++] = '\r';
654             afx->buffer[afx->buffer_len++] = '\n';
655             afx->buffer[afx->buffer_len] = '\0';
656           }
657     }
658
659     if( lastline ) { /* write last (ending) length header */
660         if(tempbuf_len<192)
661           buf[len++]=tempbuf_len;
662         else
663           {
664             buf[len++]=((tempbuf_len-192)/256) + 192;
665             buf[len++]=(tempbuf_len-192) % 256;
666           }
667         memcpy(&buf[len],tempbuf,tempbuf_len);
668         len+=tempbuf_len;
669
670         rc = 0;
671         afx->faked = 0;
672         afx->in_cleartext = 0;
673         /* and now read the header lines */
674         afx->buffer_pos = 0;
675         for(;;) {
676             int i;
677
678             /* read the next line (skip all truncated lines) */
679             do {
680                 maxlen = MAX_LINELEN;
681                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
682                                                  &afx->buffer_size, &maxlen );
683             } while( !maxlen );
684             p = afx->buffer;
685             n = afx->buffer_len;
686             if( !n ) {
687                 rc = -1;
688                 break; /* eof */
689             }
690             i = parse_header_line( afx, p , n );
691             if( i <= 0 ) {
692                 if( i )
693                     invalid_armor();
694                 break;
695             }
696         }
697         afx->inp_checked = 1;
698         afx->crc = CRCINIT;
699         afx->idx = 0;
700         afx->radbuf[0] = 0;
701     }
702
703     *retn = len;
704     return rc;
705 }
706
707
708 static int
709 invalid_crc(void)
710 {
711   if ( opt.ignore_crc_error )
712     return 0;
713   log_inc_errorcount();
714   return gpg_error (GPG_ERR_INV_ARMOR);
715 }
716
717
718 static int
719 radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
720               byte *buf, size_t size )
721 {
722     byte val;
723     int c=0, c2; /*init c because gcc is not clever enough for the continue*/
724     int checkcrc=0;
725     int rc = 0;
726     size_t n = 0;
727     int  idx, i, onlypad=0;
728     u32 crc;
729
730     crc = afx->crc;
731     idx = afx->idx;
732     val = afx->radbuf[0];
733     for( n=0; n < size; ) {
734
735         if( afx->buffer_pos < afx->buffer_len )
736             c = afx->buffer[afx->buffer_pos++];
737         else { /* read the next line */
738             unsigned maxlen = MAX_LINELEN;
739             afx->buffer_pos = 0;
740             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
741                                                &afx->buffer_size, &maxlen );
742             if( !maxlen )
743                 afx->truncated++;
744             if( !afx->buffer_len )
745                 break; /* eof */
746             continue;
747         }
748
749       again:
750         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
751             continue;
752         else if( c == '=' ) { /* pad character: stop */
753             /* some mailers leave quoted-printable encoded characters
754              * so we try to workaround this */
755             if( afx->buffer_pos+2 < afx->buffer_len ) {
756                 int cc1, cc2, cc3;
757                 cc1 = afx->buffer[afx->buffer_pos];
758                 cc2 = afx->buffer[afx->buffer_pos+1];
759                 cc3 = afx->buffer[afx->buffer_pos+2];
760                 if( isxdigit(cc1) && isxdigit(cc2)
761                                   && strchr( "=\n\r\t ", cc3 )) {
762                     /* well it seems to be the case - adjust */
763                     c = isdigit(cc1)? (cc1 - '0'): (ascii_toupper(cc1)-'A'+10);
764                     c <<= 4;
765                     c |= isdigit(cc2)? (cc2 - '0'): (ascii_toupper(cc2)-'A'+10);
766                     afx->buffer_pos += 2;
767                     afx->qp_detected = 1;
768                     goto again;
769                 }
770             }
771             else if(n==0)
772               onlypad=1;
773
774             if( idx == 1 )
775                 buf[n++] = val;
776             checkcrc++;
777             break;
778         }
779         else if( (c = asctobin[(c2=c)]) == 255 ) {
780             log_error(_("invalid radix64 character %02X skipped\n"), c2);
781             continue;
782         }
783         switch(idx) {
784           case 0: val =  c << 2; break;
785           case 1: val |= (c>>4)&3; buf[n++]=val;val=(c<<4)&0xf0;break;
786           case 2: val |= (c>>2)&15; buf[n++]=val;val=(c<<6)&0xc0;break;
787           case 3: val |= c&0x3f; buf[n++] = val; break;
788         }
789         idx = (idx+1) % 4;
790     }
791
792     for(i=0; i < n; i++ )
793         crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
794     crc &= 0x00ffffff;
795     afx->crc = crc;
796     afx->idx = idx;
797     afx->radbuf[0] = val;
798
799     if( checkcrc ) {
800         afx->any_data = 1;
801         afx->inp_checked=0;
802         afx->faked = 0;
803         for(;;) { /* skip lf and pad characters */
804             if( afx->buffer_pos < afx->buffer_len )
805                 c = afx->buffer[afx->buffer_pos++];
806             else { /* read the next line */
807                 unsigned maxlen = MAX_LINELEN;
808                 afx->buffer_pos = 0;
809                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
810                                                    &afx->buffer_size, &maxlen );
811                 if( !maxlen )
812                     afx->truncated++;
813                 if( !afx->buffer_len )
814                     break; /* eof */
815                 continue;
816             }
817             if( c == '\n' || c == ' ' || c == '\r'
818                 || c == '\t' || c == '=' )
819                 continue;
820             break;
821         }
822         if( c == -1 )
823             log_error(_("premature eof (no CRC)\n"));
824         else {
825             u32 mycrc = 0;
826             idx = 0;
827             do {
828                 if( (c = asctobin[c]) == 255 )
829                     break;
830                 switch(idx) {
831                   case 0: val =  c << 2; break;
832                   case 1: val |= (c>>4)&3; mycrc |= val << 16;val=(c<<4)&0xf0;break;
833                   case 2: val |= (c>>2)&15; mycrc |= val << 8;val=(c<<6)&0xc0;break;
834                   case 3: val |= c&0x3f; mycrc |= val; break;
835                 }
836                 for(;;) {
837                     if( afx->buffer_pos < afx->buffer_len )
838                         c = afx->buffer[afx->buffer_pos++];
839                     else { /* read the next line */
840                         unsigned maxlen = MAX_LINELEN;
841                         afx->buffer_pos = 0;
842                         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
843                                                            &afx->buffer_size,
844                                                                 &maxlen );
845                         if( !maxlen )
846                             afx->truncated++;
847                         if( !afx->buffer_len )
848                             break; /* eof */
849                         continue;
850                     }
851                     break;
852                 }
853                 if( !afx->buffer_len )
854                     break; /* eof */
855             } while( ++idx < 4 );
856             if( c == -1 ) {
857                 log_info(_("premature eof (in CRC)\n"));
858                 rc = invalid_crc();
859             }
860             else if( idx == 0 ) {
861                 /* No CRC at all is legal ("MAY") */
862                 rc=0;
863             }
864             else if( idx != 4 ) {
865                 log_info(_("malformed CRC\n"));
866                 rc = invalid_crc();
867             }
868             else if( mycrc != afx->crc ) {
869                 log_info (_("CRC error; %06lX - %06lX\n"),
870                                     (ulong)afx->crc, (ulong)mycrc);
871                 rc = invalid_crc();
872             }
873             else {
874                 rc = 0;
875                 /* FIXME: Here we should emit another control packet,
876                  * so that we know in mainproc that we are processing
877                  * a clearsign message */
878 #if 0
879                 for(rc=0;!rc;) {
880                     rc = 0 /*check_trailer( &fhdr, c )*/;
881                     if( !rc ) {
882                         if( (c=iobuf_get(a)) == -1 )
883                             rc = 2;
884                     }
885                 }
886                 if( rc == -1 )
887                     rc = 0;
888                 else if( rc == 2 ) {
889                     log_error(_("premature eof (in trailer)\n"));
890                     rc = G10ERR_INVALID_ARMOR;
891                 }
892                 else {
893                     log_error(_("error in trailer line\n"));
894                     rc = G10ERR_INVALID_ARMOR;
895                 }
896 #endif
897             }
898         }
899     }
900
901     if( !n && !onlypad )
902         rc = -1;
903
904     *retn = n;
905     return rc;
906 }
907
908 /****************
909  * This filter is used to handle the armor stuff
910  */
911 static int
912 armor_filter( void *opaque, int control,
913              IOBUF a, byte *buf, size_t *ret_len)
914 {
915     size_t size = *ret_len;
916     armor_filter_context_t *afx = opaque;
917     int rc=0, i, c;
918     byte radbuf[3];
919     int  idx, idx2;
920     size_t n=0;
921     u32 crc;
922 #if 0
923     static FILE *fp ;
924
925     if( !fp ) {
926         fp = fopen("armor.out", "w");
927         assert(fp);
928     }
929 #endif
930
931     if( DBG_FILTER )
932         log_debug("armor-filter: control: %d\n", control );
933     if( control == IOBUFCTRL_UNDERFLOW && afx->inp_bypass ) {
934         n = 0;
935         if( afx->buffer_len ) {
936             for(; n < size && afx->buffer_pos < afx->buffer_len; n++ )
937                 buf[n++] = afx->buffer[afx->buffer_pos++];
938             if( afx->buffer_pos >= afx->buffer_len )
939                 afx->buffer_len = 0;
940         }
941         for(; n < size; n++ ) {
942             if( (c=iobuf_get(a)) == -1 )
943                 break;
944             buf[n] = c & 0xff;
945         }
946         if( !n )
947             rc = -1;
948         *ret_len = n;
949     }
950     else if( control == IOBUFCTRL_UNDERFLOW ) {
951         /* We need some space for the faked packet.  The minmum
952          * required size is the PARTIAL_CHUNK size plus a byte for the
953          * length itself */
954         if( size < PARTIAL_CHUNK+1 ) 
955             BUG(); /* supplied buffer too short */
956
957         if( afx->faked )
958             rc = fake_packet( afx, a, &n, buf, size );
959         else if( !afx->inp_checked ) {
960             rc = check_input( afx, a );
961             if( afx->inp_bypass ) {
962                 for(n=0; n < size && afx->buffer_pos < afx->buffer_len; )
963                     buf[n++] = afx->buffer[afx->buffer_pos++];
964                 if( afx->buffer_pos >= afx->buffer_len )
965                     afx->buffer_len = 0;
966                 if( !n )
967                     rc = -1;
968             }
969             else if( afx->faked ) {
970                 unsigned int hashes = afx->hashes;
971                 const byte *sesmark;
972                 size_t sesmarklen;
973                 
974                 sesmark = get_session_marker( &sesmarklen );
975                 if ( sesmarklen > 20 )
976                     BUG();
977
978                 /* the buffer is at least 15+n*15 bytes long, so it
979                  * is easy to construct the packets */
980
981                 hashes &= 1|2|4|8|16|32|64;
982                 if( !hashes ) {
983                     hashes |= 4;  /* default to MD 5 */
984                     /* This is non-ideal since PGP 5-8 have the same
985                        end-of-line bugs as PGP 2. However, we only
986                        enable pgp2mode if there is no Hash: header. */
987                     if( opt.pgp2_workarounds )
988                         afx->pgp2mode = 1;
989                 }
990                 n=0;
991                 /* First a gpg control packet... */
992                 buf[n++] = 0xff; /* new format, type 63, 1 length byte */
993                 n++;   /* see below */
994                 memcpy(buf+n, sesmark, sesmarklen ); n+= sesmarklen;
995                 buf[n++] = CTRLPKT_CLEARSIGN_START; 
996                 buf[n++] = afx->not_dash_escaped? 0:1; /* sigclass */
997                 if( hashes & 1 )
998                     buf[n++] = DIGEST_ALGO_RMD160;
999                 if( hashes & 2 )
1000                     buf[n++] = DIGEST_ALGO_SHA1;
1001                 if( hashes & 4 )
1002                     buf[n++] = DIGEST_ALGO_MD5;
1003                 if( hashes & 8 )
1004                     buf[n++] = DIGEST_ALGO_SHA224;
1005                 if( hashes & 16 )
1006                     buf[n++] = DIGEST_ALGO_SHA256;
1007                 if( hashes & 32 )
1008                     buf[n++] = DIGEST_ALGO_SHA384;
1009                 if( hashes & 64 )
1010                     buf[n++] = DIGEST_ALGO_SHA512;
1011                 buf[1] = n - 2;
1012
1013                 /* ...followed by an invented plaintext packet.
1014                    Amusingly enough, this packet is not compliant with
1015                    2440 as the initial partial length is less than 512
1016                    bytes.  Of course, we'll accept it anyway ;) */
1017
1018                 buf[n++] = 0xCB; /* new packet format, type 11 */
1019                 buf[n++] = 0xE1; /* 2^1 == 2 bytes */
1020                 buf[n++] = 't';  /* canonical text mode */
1021                 buf[n++] = 0;    /* namelength */
1022                 buf[n++] = 0xE2; /* 2^2 == 4 more bytes */
1023                 memset(buf+n, 0, 4); /* timestamp */
1024                 n += 4;
1025             }
1026             else if( !rc )
1027                 rc = radix64_read( afx, a, &n, buf, size );
1028         }
1029         else
1030             rc = radix64_read( afx, a, &n, buf, size );
1031 #if 0
1032         if( n )
1033             if( fwrite(buf, n, 1, fp ) != 1 )
1034                 BUG();
1035 #endif
1036         *ret_len = n;
1037     }
1038     else if( control == IOBUFCTRL_FLUSH && !afx->cancel ) {
1039         if( !afx->status ) { /* write the header line */
1040             const char *s;
1041             strlist_t comment=opt.comments;
1042
1043             if( afx->what >= DIM(head_strings) )
1044                 log_bug("afx->what=%d", afx->what);
1045             iobuf_writestr(a, "-----");
1046             iobuf_writestr(a, head_strings[afx->what] );
1047             iobuf_writestr(a, "-----" );
1048             iobuf_writestr(a,afx->eol);
1049             if( !opt.no_version )
1050               {
1051                 iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
1052                                PRINTABLE_OS_NAME ")" );
1053                 iobuf_writestr(a,afx->eol);
1054               }
1055
1056             /* write the comment strings */
1057             for(s=comment->d;comment;comment=comment->next,s=comment->d)
1058               {
1059                 iobuf_writestr(a, "Comment: " );
1060                 for( ; *s; s++ )
1061                   {
1062                     if( *s == '\n' )
1063                       iobuf_writestr(a, "\\n" );
1064                     else if( *s == '\r' )
1065                       iobuf_writestr(a, "\\r" );
1066                     else if( *s == '\v' )
1067                       iobuf_writestr(a, "\\v" );
1068                     else
1069                       iobuf_put(a, *s );
1070                   }
1071
1072                 iobuf_writestr(a,afx->eol);
1073               }
1074
1075             if ( afx->hdrlines ) {
1076                 for ( s = afx->hdrlines; *s; s++ ) {
1077 #ifdef HAVE_DOSISH_SYSTEM
1078                     if ( *s == '\n' )
1079                         iobuf_put( a, '\r');
1080 #endif
1081                     iobuf_put(a, *s );
1082                 }
1083             }
1084
1085             iobuf_writestr(a,afx->eol);
1086             afx->status++;
1087             afx->idx = 0;
1088             afx->idx2 = 0;
1089             afx->crc = CRCINIT;
1090
1091         }
1092         crc = afx->crc;
1093         idx = afx->idx;
1094         idx2 = afx->idx2;
1095         for(i=0; i < idx; i++ )
1096             radbuf[i] = afx->radbuf[i];
1097
1098         for(i=0; i < size; i++ )
1099             crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
1100         crc &= 0x00ffffff;
1101
1102         for( ; size; buf++, size-- ) {
1103             radbuf[idx++] = *buf;
1104             if( idx > 2 ) {
1105                 idx = 0;
1106                 c = bintoasc[(*radbuf >> 2) & 077];
1107                 iobuf_put(a, c);
1108                 c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1109                 iobuf_put(a, c);
1110                 c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1111                 iobuf_put(a, c);
1112                 c = bintoasc[radbuf[2]&077];
1113                 iobuf_put(a, c);
1114                 if( ++idx2 >= (64/4) )
1115                   { /* pgp doesn't like 72 here */
1116                     iobuf_writestr(a,afx->eol);
1117                     idx2=0;
1118                   }
1119             }
1120         }
1121         for(i=0; i < idx; i++ )
1122             afx->radbuf[i] = radbuf[i];
1123         afx->idx = idx;
1124         afx->idx2 = idx2;
1125         afx->crc  = crc;
1126     }
1127     else if( control == IOBUFCTRL_INIT )
1128       {
1129         if( !is_initialized )
1130           initialize();
1131
1132         /* Figure out what we're using for line endings if the caller
1133            didn't specify. */
1134         if(afx->eol[0]==0)
1135           {
1136 #ifdef HAVE_DOSISH_SYSTEM
1137             afx->eol[0]='\r';
1138             afx->eol[1]='\n';
1139 #else
1140             afx->eol[0]='\n';
1141 #endif
1142           }
1143       }
1144     else if( control == IOBUFCTRL_CANCEL ) {
1145         afx->cancel = 1;
1146     }
1147     else if( control == IOBUFCTRL_FREE ) {
1148         if( afx->cancel )
1149             ;
1150         else if( afx->status ) { /* pad, write cecksum, and bottom line */
1151             crc = afx->crc;
1152             idx = afx->idx;
1153             idx2 = afx->idx2;
1154             for(i=0; i < idx; i++ )
1155                 radbuf[i] = afx->radbuf[i];
1156             if( idx ) {
1157                 c = bintoasc[(*radbuf>>2)&077];
1158                 iobuf_put(a, c);
1159                 if( idx == 1 ) {
1160                     c = bintoasc[((*radbuf << 4) & 060) & 077];
1161                     iobuf_put(a, c);
1162                     iobuf_put(a, '=');
1163                     iobuf_put(a, '=');
1164                 }
1165                 else { /* 2 */
1166                     c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
1167                     iobuf_put(a, c);
1168                     c = bintoasc[((radbuf[1] << 2) & 074) & 077];
1169                     iobuf_put(a, c);
1170                     iobuf_put(a, '=');
1171                 }
1172                 if( ++idx2 >= (64/4) )
1173                   { /* pgp doesn't like 72 here */
1174                     iobuf_writestr(a,afx->eol);
1175                     idx2=0;
1176                   }
1177             }
1178             /* may need a linefeed */
1179             if( idx2 )
1180               iobuf_writestr(a,afx->eol);
1181             /* write the CRC */
1182             iobuf_put(a, '=');
1183             radbuf[0] = crc >>16;
1184             radbuf[1] = crc >> 8;
1185             radbuf[2] = crc;
1186             c = bintoasc[(*radbuf >> 2) & 077];
1187             iobuf_put(a, c);
1188             c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1189             iobuf_put(a, c);
1190             c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1191             iobuf_put(a, c);
1192             c = bintoasc[radbuf[2]&077];
1193             iobuf_put(a, c);
1194             iobuf_writestr(a,afx->eol);
1195             /* and the the trailer */
1196             if( afx->what >= DIM(tail_strings) )
1197                 log_bug("afx->what=%d", afx->what);
1198             iobuf_writestr(a, "-----");
1199             iobuf_writestr(a, tail_strings[afx->what] );
1200             iobuf_writestr(a, "-----" );
1201             iobuf_writestr(a,afx->eol);
1202         }
1203         else if( !afx->any_data && !afx->inp_bypass ) {
1204             log_error(_("no valid OpenPGP data found.\n"));
1205             afx->no_openpgp_data = 1;
1206             write_status_text( STATUS_NODATA, "1" );
1207         }
1208         if( afx->truncated )
1209             log_info(_("invalid armor: line longer than %d characters\n"),
1210                       MAX_LINELEN );
1211         /* issue an error to enforce dissemination of correct software */
1212         if( afx->qp_detected )
1213             log_error(_("quoted printable character in armor - "
1214                         "probably a buggy MTA has been used\n") );
1215         xfree( afx->buffer );
1216         afx->buffer = NULL;
1217         release_armor_context (afx);
1218     }
1219     else if( control == IOBUFCTRL_DESC )
1220         *(char**)buf = "armor_filter";
1221     return rc;
1222 }
1223
1224
1225 /****************
1226  * create a radix64 encoded string.
1227  */
1228 char *
1229 make_radix64_string( const byte *data, size_t len )
1230 {
1231     char *buffer, *p;
1232
1233     buffer = p = xmalloc( (len+2)/3*4 + 1 );
1234     for( ; len >= 3 ; len -= 3, data += 3 ) {
1235         *p++ = bintoasc[(data[0] >> 2) & 077];
1236         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1237         *p++ = bintoasc[(((data[1]<<2)&074)|((data[2]>>6)&03))&077];
1238         *p++ = bintoasc[data[2]&077];
1239     }
1240     if( len == 2 ) {
1241         *p++ = bintoasc[(data[0] >> 2) & 077];
1242         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1243         *p++ = bintoasc[((data[1]<<2)&074)];
1244     }
1245     else if( len == 1 ) {
1246         *p++ = bintoasc[(data[0] >> 2) & 077];
1247         *p++ = bintoasc[(data[0] <<4)&060];
1248     }
1249     *p = 0;
1250     return buffer;
1251 }
1252
1253
1254 /***********************************************
1255  *  For the pipemode command we can't use the armor filter for various
1256  *  reasons, so we use this new unarmor_pump stuff to remove the armor 
1257  */
1258
1259 enum unarmor_state_e {
1260     STA_init = 0,
1261     STA_bypass,
1262     STA_wait_newline,
1263     STA_wait_dash,
1264     STA_first_dash, 
1265     STA_compare_header,
1266     STA_found_header_wait_newline,
1267     STA_skip_header_lines,
1268     STA_skip_header_lines_non_ws,
1269     STA_read_data,
1270     STA_wait_crc,
1271     STA_read_crc,
1272     STA_ready
1273 };
1274
1275 struct unarmor_pump_s {
1276     enum unarmor_state_e state;
1277     byte val;
1278     int checkcrc;
1279     int pos;   /* counts from 0..3 */
1280     u32 crc;
1281     u32 mycrc; /* the one store in the data */
1282 };
1283
1284
1285
1286 UnarmorPump
1287 unarmor_pump_new (void)
1288 {
1289     UnarmorPump x;
1290
1291     if( !is_initialized )
1292         initialize();
1293     x = xmalloc_clear (sizeof *x);
1294     return x;
1295 }
1296
1297 void
1298 unarmor_pump_release (UnarmorPump x)
1299 {
1300     xfree (x);
1301 }
1302
1303 /* 
1304  * Get the next character from the ascii armor taken from the IOBUF
1305  * created earlier by unarmor_pump_new().
1306  * Return:  c = Character
1307  *        256 = ignore this value
1308  *         -1 = End of current armor 
1309  *         -2 = Premature EOF (not used)
1310  *         -3 = Invalid armor
1311  */
1312 int
1313 unarmor_pump (UnarmorPump x, int c)
1314 {
1315     int rval = 256; /* default is to ignore the return value */
1316
1317     switch (x->state) {
1318       case STA_init:
1319         { 
1320             byte tmp[1];
1321             tmp[0] = c; 
1322             if ( is_armored (tmp) )
1323                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
1324             else {
1325                 x->state = STA_bypass;
1326                 return c;
1327             }
1328         }
1329         break;
1330       case STA_bypass:
1331         return c; /* return here to avoid crc calculation */
1332       case STA_wait_newline:
1333         if (c == '\n')
1334             x->state = STA_wait_dash;
1335         break;
1336       case STA_wait_dash:
1337         x->state = c == '-'? STA_first_dash : STA_wait_newline;
1338         break;
1339       case STA_first_dash: /* just need for initalization */
1340         x->pos = 0;
1341         x->state = STA_compare_header;
1342       case STA_compare_header:
1343         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
1344             if ( x->pos == 28 ) 
1345                 x->state = STA_found_header_wait_newline;
1346         }
1347         else 
1348             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
1349         break;
1350       case STA_found_header_wait_newline:
1351         /* to make CR,LF issues easier we simply allow for white space
1352            behind the 5 dashes */
1353         if ( c == '\n' )
1354             x->state = STA_skip_header_lines;
1355         else if ( c != '\r' && c != ' ' && c != '\t' )
1356             x->state = STA_wait_dash; /* garbage after the header line */
1357         break;
1358       case STA_skip_header_lines:
1359         /* i.e. wait for one empty line */
1360         if ( c == '\n' ) {
1361             x->state = STA_read_data;
1362             x->crc = CRCINIT;
1363             x->val = 0;
1364             x->pos = 0;
1365         }
1366         else if ( c != '\r' && c != ' ' && c != '\t' )
1367             x->state = STA_skip_header_lines_non_ws;
1368         break;
1369       case STA_skip_header_lines_non_ws:
1370         /* like above but we already encountered non white space */
1371         if ( c == '\n' )
1372             x->state = STA_skip_header_lines;
1373         break;
1374       case STA_read_data:
1375         /* fixme: we don't check for the trailing dash lines but rely
1376          * on the armor stop characters */
1377         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
1378             break; /* skip all kind of white space */
1379
1380         if( c == '=' ) { /* pad character: stop */
1381             if( x->pos == 1 ) /* in this case val has some value */
1382                 rval = x->val;
1383             x->state = STA_wait_crc;
1384             break;
1385         }
1386
1387         {
1388             int c2;
1389             if( (c = asctobin[(c2=c)]) == 255 ) {
1390                 log_error(_("invalid radix64 character %02X skipped\n"), c2);
1391                 break;
1392             }
1393         }
1394         
1395         switch(x->pos) {
1396           case 0:
1397             x->val = c << 2;
1398             break;
1399           case 1:
1400             x->val |= (c>>4)&3;
1401             rval = x->val;
1402             x->val = (c<<4)&0xf0;
1403             break;
1404           case 2:
1405             x->val |= (c>>2)&15;
1406             rval = x->val;
1407             x->val = (c<<6)&0xc0;
1408             break;
1409           case 3:
1410             x->val |= c&0x3f;
1411             rval = x->val;
1412             break;
1413         }
1414         x->pos = (x->pos+1) % 4;
1415         break;
1416       case STA_wait_crc:
1417         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' || c == '=' )
1418             break; /* skip ws and pad characters */
1419         /* assume that we are at the next line */
1420         x->state = STA_read_crc;
1421         x->pos = 0;
1422         x->mycrc = 0;
1423       case STA_read_crc:
1424         if( (c = asctobin[c]) == 255 ) {
1425             rval = -1; /* ready */
1426             if( x->crc != x->mycrc ) {
1427                 log_info (_("CRC error; %06lX - %06lX\n"),
1428                           (ulong)x->crc, (ulong)x->mycrc);
1429                 if ( invalid_crc() )
1430                     rval = -3;
1431             }
1432             x->state = STA_ready; /* not sure whether this is correct */
1433             break;
1434         }
1435         
1436         switch(x->pos) {
1437           case 0:
1438             x->val = c << 2;
1439             break;
1440           case 1:
1441             x->val |= (c>>4)&3;
1442             x->mycrc |= x->val << 16;
1443             x->val = (c<<4)&0xf0;
1444             break;
1445           case 2:
1446             x->val |= (c>>2)&15;
1447             x->mycrc |= x->val << 8;
1448             x->val = (c<<6)&0xc0;
1449             break;
1450           case 3:
1451             x->val |= c&0x3f;
1452             x->mycrc |= x->val;
1453             break;
1454         }
1455         x->pos = (x->pos+1) % 4;
1456         break;
1457       case STA_ready:
1458         rval = -1;
1459         break;
1460     }
1461
1462     if ( !(rval & ~255) ) { /* compute the CRC */
1463         x->crc = (x->crc << 8) ^ crc_table[((x->crc >> 16)&0xff) ^ rval];
1464         x->crc &= 0x00ffffff;
1465     }
1466
1467     return rval;
1468 }