configuration changes
[gpgme.git] / gpgme / data.c
1 /* data.c
2  *      Copyright (C) 2000 Werner Koch (dd9jn)
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME 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  * GPGME 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 <stdio.h>
23 #include <stdlib.h>
24 #include <assert.h>
25 #include <errno.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <unistd.h>
29
30 #include "util.h"
31 #include "context.h"
32 #include "ops.h"
33
34 #define ALLOC_CHUNK 1024
35 #define my_isdigit(a)  ( (a) >='0' && (a) <= '9' )
36 #define my_isxdigit(a) ( my_isdigit((a))               \
37                          || ((a) >= 'A' && (a) <= 'F') \
38                          || ((a) >= 'f' && (a) <= 'f') )
39
40
41 GpgmeError
42 gpgme_data_new ( GpgmeData *r_dh )
43 {
44     GpgmeData dh;
45
46     if (!r_dh)
47         return mk_error (Invalid_Value);
48     *r_dh = NULL;
49     dh = xtrycalloc ( 1, sizeof *dh );
50     if (!dh)
51         return mk_error (Out_Of_Core);
52     dh->mode = GPGME_DATA_MODE_INOUT; 
53     *r_dh = dh;
54     return 0;
55 }
56
57
58 /**
59  * gpgme_data_new_from_mem:
60  * @r_dh:   Returns a new data object.
61  * @buffer: Initialize with this.
62  * @size: Size of the buffer
63  * @copy: Flag wether a copy of the buffer should be used.
64  * 
65  * Create a new data object and initialize with data
66  * from the memory.  A @copy with value %TRUE creates a copy of the
67  * memory, a value of %FALSE uses the original memory of @buffer and the
68  * caller has to make sure that this buffer is valid until gpgme_release_data()
69  * is called.
70  * 
71  * Return value: 
72  **/
73 GpgmeError
74 gpgme_data_new_from_mem ( GpgmeData *r_dh,
75                           const char *buffer, size_t size, int copy )
76 {
77     GpgmeData dh;
78     GpgmeError err;
79
80     if (!r_dh || !buffer)
81         return mk_error (Invalid_Value);
82     *r_dh = NULL;
83     err = gpgme_data_new ( &dh );
84     if (err)
85         return err;
86     dh->len  = size;
87     if (copy) {
88         dh->private_buffer = xtrymalloc ( size );
89         if ( !dh->private_buffer ) {
90             gpgme_data_release (dh);
91             return mk_error (Out_Of_Core);
92         }
93         dh->private_len = size;
94         memcpy (dh->private_buffer, buffer, size );
95         dh->data = dh->private_buffer;
96         dh->writepos = size;
97     }
98     else {
99         dh->data = buffer;
100     }
101     dh->type = GPGME_DATA_TYPE_MEM;
102     
103     *r_dh = dh;
104     return 0;
105 }
106
107 GpgmeError
108 gpgme_data_new_from_file ( GpgmeData *r_dh, const char *fname, int copy )
109 {
110     GpgmeData dh;
111     GpgmeError err;
112     struct stat st;
113     FILE *fp;
114
115     if (!r_dh)
116         return mk_error (Invalid_Value);
117     *r_dh = NULL;
118     /* We only support copy for now - in future we might want to honor the 
119      * copy flag and just store a file pointer */
120     if (!copy)
121         return mk_error (Not_Implemented);
122     if (!fname)
123         return mk_error (Invalid_Value);
124
125     err = gpgme_data_new ( &dh );
126     if (err)
127         return err;
128
129     fp = fopen (fname, "rb");
130     if (!fp) {
131         int save_errno = errno;
132         gpgme_data_release (dh);
133         errno = save_errno;
134         return mk_error (File_Error);
135     }
136
137     if( fstat(fileno(fp), &st) ) {
138         int save_errno = errno;
139         fclose (fp);
140         gpgme_data_release (dh);
141         errno = save_errno;
142         return mk_error (File_Error);
143     }
144
145     /* We should check the length of the file and don't allow for to
146      * large files */
147     dh->private_buffer = xtrymalloc ( st.st_size );
148     if ( !dh->private_buffer ) {
149         fclose (fp);
150         gpgme_data_release (dh);
151         return mk_error (Out_Of_Core);
152     }
153     dh->private_len = st.st_size;
154
155     if ( fread ( dh->private_buffer, dh->private_len, 1, fp ) != 1 ) {
156         int save_errno = errno;
157         fclose (fp);
158         gpgme_data_release (dh);
159         errno = save_errno;
160         return mk_error (File_Error);
161     }
162
163     fclose (fp);
164
165     dh->len = dh->private_len;
166     dh->data = dh->private_buffer;
167     dh->writepos = dh->len;
168     dh->type = GPGME_DATA_TYPE_MEM;
169     
170     *r_dh = dh;
171     return 0;
172 }
173
174
175
176 /**
177  * gpgme_data_release:
178  * @dh: Data object 
179  * 
180  * Release the data object @dh.  @dh may be NULL in which case nothing
181  * happens.
182  **/
183 void
184 gpgme_data_release ( GpgmeData dh )
185 {
186     if (dh) {
187         xfree (dh->private_buffer); 
188         xfree (dh);
189     }
190 }
191
192 char *
193 _gpgme_data_release_and_return_string ( GpgmeData dh )
194 {
195     char *val = NULL;
196
197     if (dh) {
198         if ( _gpgme_data_append ( dh, "", 0 ) ) /* append EOS */
199             xfree (dh->private_buffer );
200         else {
201             val = dh->private_buffer;
202             if ( !val && dh->data ) {
203                 val = xtrymalloc ( dh->len );
204                 if ( val )
205                     memcpy ( val, dh->data, dh->len );
206             }
207         }
208         xfree (dh);
209     }
210     return val;
211 }
212
213 char *
214 gpgme_data_release_and_get_mem ( GpgmeData dh, size_t *r_len )
215 {
216     char *val = NULL;
217
218     if (r_len)
219         *r_len = 0;
220     if (dh) {
221         size_t len = dh->len;
222         val = dh->private_buffer;
223         if ( !val && dh->data ) {
224             val = xtrymalloc ( len );
225             if ( val )
226                 memcpy ( val, dh->data, len );
227         }
228         xfree (dh);
229         if (val && r_len )
230             *r_len = len;
231     }
232     return val;
233 }
234
235
236 GpgmeDataType
237 gpgme_data_get_type ( GpgmeData dh )
238 {
239     if ( !dh || !dh->data )
240         return GPGME_DATA_TYPE_NONE;
241             
242     return dh->type;
243 }
244
245 void 
246 _gpgme_data_set_mode ( GpgmeData dh, GpgmeDataMode mode )
247 {
248     assert (dh);
249     dh->mode = mode;
250 }
251
252
253 GpgmeDataMode
254 _gpgme_data_get_mode ( GpgmeData dh )
255 {
256     assert (dh);
257     return dh->mode;
258 }
259
260 GpgmeError
261 gpgme_data_rewind ( GpgmeData dh )
262 {
263     if ( !dh )
264         return mk_error (Invalid_Value);
265     /* Fixme: We should check whether rewinding does make sense for the
266      * data type */
267     dh->readpos = 0;
268     return 0;
269 }
270
271 GpgmeError
272 gpgme_data_read ( GpgmeData dh, char *buffer, size_t length, size_t *nread )
273 {
274     size_t nbytes;
275
276     if ( !dh )
277         return mk_error (Invalid_Value);
278     nbytes = dh->len - dh->readpos;
279     if ( !nbytes ) {
280         *nread = 0;
281         return mk_error(EOF);
282     }
283     if (nbytes > length)
284         nbytes = length;
285     memcpy ( buffer, dh->data + dh->readpos, nbytes );
286     *nread = nbytes;
287     dh->readpos += nbytes;
288     return 0;
289
290
291 /* 
292  * This function does make sense when we know that it contains no nil chars.
293  */
294 char *
295 _gpgme_data_get_as_string ( GpgmeData dh )
296 {
297     char *val = NULL;
298
299     if (dh) {
300         val = xtrymalloc ( dh->len+1 );
301         if ( val ) {
302             memcpy ( val, dh->data, dh->len );
303             val[dh->len] = 0;
304         }
305     }
306     return val;
307 }
308
309
310
311 GpgmeError
312 _gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
313 {
314     assert (dh);
315
316     if ( dh->type == GPGME_DATA_TYPE_NONE ) {
317         /* convert it to a mem data type */
318         assert (!dh->private_buffer);
319         dh->type = GPGME_DATA_TYPE_MEM;
320         dh->private_len = length < ALLOC_CHUNK? ALLOC_CHUNK : length;
321         dh->private_buffer = xtrymalloc ( dh->private_len );
322         if (!dh->private_buffer) {
323             dh->private_len = 0;
324             return mk_error (Out_Of_Core);
325         }
326         dh->writepos = 0;
327         dh->data = dh->private_buffer;
328     }
329     else if ( dh->type != GPGME_DATA_TYPE_MEM ) 
330         return mk_error (Invalid_Type);
331     
332     if ( dh->mode != GPGME_DATA_MODE_INOUT 
333          && dh->mode != GPGME_DATA_MODE_IN  )
334         return mk_error (Invalid_Mode);
335
336     if ( !dh->private_buffer ) {
337         /* we have to copy it now */
338         assert (dh->data);
339         dh->private_len = dh->len+length;
340         if (dh->private_len < ALLOC_CHUNK)
341             dh->private_len = ALLOC_CHUNK;
342         dh->private_buffer = xtrymalloc ( dh->private_len );
343         if (!dh->private_buffer) {
344             dh->private_len = 0;
345             return mk_error (Out_Of_Core);
346         }
347         memcpy ( dh->private_buffer, dh->data, dh->len );
348         dh->writepos = dh->len;
349         dh->data = dh->private_buffer;
350     }
351
352     /* allocate more memory if needed */
353     if ( dh->writepos + length > dh->private_len ) {
354         char *p;
355         size_t newlen = dh->private_len
356                         + (dh->len < ALLOC_CHUNK? ALLOC_CHUNK : length);
357         p = xtryrealloc ( dh->private_buffer, newlen );
358         if ( !p ) 
359             return mk_error (Out_Of_Core);
360         dh->private_buffer = p;
361         dh->private_len = newlen;
362         dh->data = dh->private_buffer;
363         assert ( !(dh->writepos + length > dh->private_len) );      
364     }
365
366     memcpy ( dh->private_buffer + dh->writepos, buffer, length );
367     dh->writepos += length;
368     dh->len += length;
369
370     return 0;
371 }
372
373 GpgmeError
374 _gpgme_data_append_string ( GpgmeData dh, const char *s )
375 {
376     return _gpgme_data_append ( dh, s, s? strlen(s):0 );
377 }
378
379
380 GpgmeError
381 _gpgme_data_append_for_xml ( GpgmeData dh,
382                              const char *buffer, size_t len )
383 {
384     const char *text, *s;
385     size_t n;
386     int rc = 0; 
387        
388     if ( !dh || !buffer )
389         return mk_error (Invalid_Value);
390
391     do {
392         for (text=NULL, s=buffer, n=len; n && !text; s++, n-- ) {
393             if ( *s == '<' ) 
394                 text = "&lt;";
395             else if ( *s == '>' ) 
396                 text = "&gt;";  /* not sure whether this is really needed */
397             else if ( *s == '&' ) 
398                 text = "&amp;";
399             else if ( !*s )
400                 text = "&#00;";
401         }
402         if (text) {
403             s--; n++;
404         }
405         if (s != buffer) 
406             rc = _gpgme_data_append ( dh, buffer, s-buffer );
407         if ( !rc && text) {
408             rc = _gpgme_data_append_string ( dh, text );
409             s++; n--;
410         }
411         buffer = s;
412         len = n;
413     } while ( !rc && len );
414     return rc;
415 }
416
417
418 /*
419  * Append a string to DATA and convert it so that the result will be 
420  * valid XML. 
421  */
422 GpgmeError
423 _gpgme_data_append_string_for_xml ( GpgmeData dh, const char *string )
424 {
425     return _gpgme_data_append_for_xml ( dh, string, strlen (string) );
426 }
427
428
429 static int
430 hextobyte( const byte *s )
431 {
432     int c;
433
434     if( *s >= '0' && *s <= '9' )
435         c = 16 * (*s - '0');
436     else if( *s >= 'A' && *s <= 'F' )
437         c = 16 * (10 + *s - 'A');
438     else if( *s >= 'a' && *s <= 'f' )
439         c = 16 * (10 + *s - 'a');
440     else
441         return -1;
442     s++;
443     if( *s >= '0' && *s <= '9' )
444         c += *s - '0';
445     else if( *s >= 'A' && *s <= 'F' )
446         c += 10 + *s - 'A';
447     else if( *s >= 'a' && *s <= 'f' )
448         c += 10 + *s - 'a';
449     else
450         return -1;
451     return c;
452 }
453
454
455
456
457 /* 
458  * Append a string with percent style (%XX) escape characters as XML
459  */
460 GpgmeError
461 _gpgme_data_append_percentstring_for_xml ( GpgmeData dh, const char *string )
462 {
463     const byte *s;
464     byte *buf, *d;
465     int val;
466     GpgmeError err;
467
468     d = buf = xtrymalloc ( strlen (string) );
469     for (s=string; *s; s++ ) {
470         if ( *s == '%' && (val=hextobyte (s+1)) != -1 ) {
471             *d++ = val;
472             s += 2;
473         }
474         else
475             *d++ = *s;
476     }
477
478     err = _gpgme_data_append_for_xml ( dh, buf, d - buf );
479     xfree (buf);
480     return err;
481 }
482
483
484
485
486
487
488