* Makefile.am (sm): Build kbx only if gpgsm is to be build.
[gnupg.git] / common / b64enc.c
1 /* b64enc.c - Simple Base64 encoder.
2  *      Copyright (C) 2001, 2003, 2004 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdlib.h>
23 #include <errno.h>
24 #include <assert.h>
25
26 #include "i18n.h"
27 #include "util.h"
28
29 #define B64ENC_DID_HEADER   1
30 #define B64ENC_DID_TRAILER  2
31 #define B64ENC_NO_LINEFEEDS 16
32
33
34 /* The base-64 character list */
35 static unsigned char bintoasc[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
36                                     "abcdefghijklmnopqrstuvwxyz" 
37                                     "0123456789+/"; 
38
39 /* Prepare for base-64 writing to the stream FP.  If TITLE is not NULL
40    and not an empty string, this string will be used as the title for
41    the armor lines, with TITLE being an empty string, we don't write
42    the header lines and furthermore even don't write any linefeeds.
43    With TITLE beeing NULL, we merely don't write header but make sure
44    that lines are not too long. Note, that we don't write any output
45    unless at least one byte get written using b64enc_write. */
46 gpg_error_t
47 b64enc_start (struct b64state *state, FILE *fp, const char *title)
48 {
49   memset (state, 0, sizeof *state);
50   state->fp = fp;
51   if (title && !*title)
52     state->flags |= B64ENC_NO_LINEFEEDS;
53   else if (title)
54     {
55       state->title = xtrystrdup (title);
56       if (!state->title)
57         return  gpg_error_from_errno (errno);
58     }
59   return 0;
60 }
61
62
63 /* Write NBYTES from BUFFER to the Base 64 stream identified by
64    STATE. With BUFFER and NBYTES being 0, merely do a fflush on the
65    stream. */
66 gpg_error_t
67 b64enc_write (struct b64state *state, const void *buffer, size_t nbytes)
68 {
69   unsigned char radbuf[4];
70   int idx, quad_count;
71   const unsigned char *p;
72   FILE *fp = state->fp;
73
74
75   if (!nbytes)
76     {
77       if (buffer && fflush (fp))
78         goto write_error;
79       return 0;
80     }
81
82   if (!(state->flags & B64ENC_DID_HEADER))
83     {
84       if (state->title)
85         {
86           if ( fputs ("-----BEGIN ", fp) == EOF
87                || fputs (state->title, fp) == EOF
88                || fputs ("-----\n", fp) == EOF)
89             goto write_error;
90         }
91       state->flags |= B64ENC_DID_HEADER;
92     }
93
94   idx = state->idx;
95   quad_count = state->quad_count;
96   assert (idx < 4);
97   memcpy (radbuf, state->radbuf, idx);
98   
99   for (p=buffer; nbytes; p++, nbytes--)
100     {
101       radbuf[idx++] = *p;
102       if (idx > 2)
103         {
104           char tmp[4];
105
106           tmp[0] = bintoasc[(*radbuf >> 2) & 077];
107           tmp[1] = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
108           tmp[2] = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
109           tmp[3] = bintoasc[radbuf[2]&077];
110           for (idx=0; idx < 4; idx++)
111             putc (tmp[idx], fp);
112           idx = 0;
113           if (ferror (fp))
114             goto write_error;
115           if (++quad_count >= (64/4)) 
116             {
117               quad_count = 0;
118               if (!(state->flags & B64ENC_NO_LINEFEEDS)
119                   && fputs ("\n", fp) == EOF)
120                 goto write_error;
121             }
122         }
123     }
124   memcpy (state->radbuf, radbuf, idx);
125   state->idx = idx;
126   state->quad_count = quad_count;
127   return 0;
128
129  write_error:
130   return gpg_error_from_errno (errno);
131 }
132
133 gpg_error_t
134 b64enc_finish (struct b64state *state)
135 {
136   gpg_error_t err = 0;
137   unsigned char radbuf[4];
138   int idx, quad_count;
139   FILE *fp;
140
141   if (!(state->flags & B64ENC_DID_HEADER))
142     goto cleanup;
143
144   /* Flush the base64 encoding */
145   fp = state->fp;
146   idx = state->idx;
147   quad_count = state->quad_count;
148   assert (idx < 4);
149   memcpy (radbuf, state->radbuf, idx);
150
151   if (idx)
152     {
153       char tmp[4];
154       
155       tmp[0] = bintoasc[(*radbuf>>2)&077];
156       if (idx == 1)
157         {
158           tmp[1] = bintoasc[((*radbuf << 4) & 060) & 077];
159           tmp[2] = '=';
160           tmp[3] = '=';
161         }
162       else 
163         { 
164           tmp[1] = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
165           tmp[2] = bintoasc[((radbuf[1] << 2) & 074) & 077];
166           tmp[3] = '=';
167         }
168       for (idx=0; idx < 4; idx++)
169         putc (tmp[idx], fp);
170       idx = 0;
171       if (ferror (fp))
172         goto write_error;
173       
174       if (++quad_count >= (64/4)) 
175         {
176           quad_count = 0;
177           if (!(state->flags & B64ENC_NO_LINEFEEDS)
178               && fputs ("\n", fp) == EOF)
179             goto write_error;
180         }
181     }
182
183   /* Finish the last line and write the trailer. */
184   if (quad_count
185       && !(state->flags & B64ENC_NO_LINEFEEDS)
186       && fputs ("\n", fp) == EOF)
187     goto write_error;
188
189   if (state->title)
190     {
191       if ( fputs ("-----END ", fp) == EOF
192            || fputs (state->title, fp) == EOF
193            || fputs ("-----\n", fp) == EOF)
194         goto write_error;
195     }
196
197   goto cleanup;
198
199  write_error:
200   err = gpg_error_from_errno (errno);
201
202  cleanup:
203   if (state->title)
204     {
205       xfree (state->title);
206       state->title = NULL;
207     }
208   state->fp = NULL;
209   return err;
210 }
211