Release 0.2.1
[gpgme.git] / gpgme / data.c
1 /* data.c
2  *      Copyright (C) 2000 Werner Koch (dd9jn)
3  *      Copyright (C) 2001 g10 Code GmbH
4  *
5  * This file is part of GPGME.
6  *
7  * GPGME 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 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GPGME 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <assert.h>
26 #include <errno.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include "syshdr.h"
30
31 #include "util.h"
32 #include "context.h"
33 #include "ops.h"
34
35 #define ALLOC_CHUNK 1024
36 #define my_isdigit(a)  ( (a) >='0' && (a) <= '9' )
37 #define my_isxdigit(a) ( my_isdigit((a))               \
38                          || ((a) >= 'A' && (a) <= 'F') \
39                          || ((a) >= 'f' && (a) <= 'f') )
40
41
42 /**
43  * gpgme_data_new:
44  * @r_dh: returns the new data object 
45  * 
46  * Create a new data object without any content. 
47  * 
48  * Return value: An error value or 0 on success
49  **/
50 GpgmeError
51 gpgme_data_new ( GpgmeData *r_dh )
52 {
53     GpgmeData dh;
54
55     if (!r_dh)
56         return mk_error (Invalid_Value);
57     *r_dh = NULL;
58     dh = xtrycalloc ( 1, sizeof *dh );
59     if (!dh)
60         return mk_error (Out_Of_Core);
61     dh->mode = GPGME_DATA_MODE_INOUT; 
62     *r_dh = dh;
63     return 0;
64 }
65
66
67 /**
68  * gpgme_data_new_from_mem:
69  * @r_dh:   Returns a new data object.
70  * @buffer: Initialize with this.
71  * @size: Size of the buffer
72  * @copy: Flag wether a copy of the buffer should be used.
73  * 
74  * Create a new data object and initialize with data
75  * from the memory.  A @copy with value %TRUE creates a copy of the
76  * memory, a value of %FALSE uses the original memory of @buffer and the
77  * caller has to make sure that this buffer is valid until gpgme_release_data()
78  * is called.
79  * 
80  * Return value: 
81  **/
82 GpgmeError
83 gpgme_data_new_from_mem ( GpgmeData *r_dh,
84                           const char *buffer, size_t size, int copy )
85 {
86     GpgmeData dh;
87     GpgmeError err;
88
89     if (!r_dh || !buffer)
90         return mk_error (Invalid_Value);
91     *r_dh = NULL;
92     err = gpgme_data_new ( &dh );
93     if (err)
94         return err;
95     dh->len = size;
96     if (copy) {
97         dh->private_buffer = xtrymalloc ( size );
98         if ( !dh->private_buffer ) {
99             gpgme_data_release (dh);
100             return mk_error (Out_Of_Core);
101         }
102         dh->private_len = size;
103         memcpy (dh->private_buffer, buffer, size );
104         dh->data = dh->private_buffer;
105         dh->writepos = size;
106     }
107     else {
108         dh->data = buffer;
109     }
110     dh->type = GPGME_DATA_TYPE_MEM;
111     
112     *r_dh = dh;
113     return 0;
114 }
115
116
117 GpgmeError
118 gpgme_data_new_with_read_cb ( GpgmeData *r_dh,
119                               int (*read_cb)(void*,char *,size_t,size_t*),
120                               void *read_cb_value )
121 {
122     GpgmeData dh;
123     GpgmeError err;
124
125     if (!r_dh || !read_cb)
126         return mk_error (Invalid_Value);
127     *r_dh = NULL;
128     err = gpgme_data_new ( &dh );
129     if (err)
130         return err;
131     dh->type = GPGME_DATA_TYPE_CB;
132     dh->mode = GPGME_DATA_MODE_OUT;
133     dh->read_cb = read_cb;
134     dh->read_cb_value = read_cb_value;
135     
136     *r_dh = dh;
137     return 0;
138 }
139
140 /**
141  * gpgme_data_new_from_file:
142  * @r_dh: returns the new data object
143  * @fname: filename
144  * @copy: Flag, whether the file should be copied.
145  * 
146  * Create a new data object and initialize it with the content of 
147  * the file @file.  If @copy is %True the file is immediately read in
148  * adn closed.  @copy of %False is not yet supportted.
149  * 
150  * Return value: An error code or 0 on success. If the error code is
151  * %GPGME_File_Error, the OS error code is held in %errno.
152  **/
153 GpgmeError
154 gpgme_data_new_from_file ( GpgmeData *r_dh, const char *fname, int copy )
155 {
156     GpgmeData dh;
157     GpgmeError err;
158     struct stat st;
159     FILE *fp;
160
161     if (!r_dh)
162         return mk_error (Invalid_Value);
163     *r_dh = NULL;
164     /* We only support copy for now - in future we might want to honor the 
165      * copy flag and just store a file pointer */
166     if (!copy)
167         return mk_error (Not_Implemented);
168     if (!fname)
169         return mk_error (Invalid_Value);
170
171     err = gpgme_data_new ( &dh );
172     if (err)
173         return err;
174
175     fp = fopen (fname, "rb");
176     if (!fp) {
177         int save_errno = errno;
178         gpgme_data_release (dh);
179         errno = save_errno;
180         return mk_error (File_Error);
181     }
182
183     if( fstat(fileno(fp), &st) ) {
184         int save_errno = errno;
185         fclose (fp);
186         gpgme_data_release (dh);
187         errno = save_errno;
188         return mk_error (File_Error);
189     }
190
191     /* We should check the length of the file and don't allow for to
192      * large files */
193     dh->private_buffer = xtrymalloc ( st.st_size );
194     if ( !dh->private_buffer ) {
195         fclose (fp);
196         gpgme_data_release (dh);
197         return mk_error (Out_Of_Core);
198     }
199     dh->private_len = st.st_size;
200
201     if ( fread ( dh->private_buffer, dh->private_len, 1, fp ) != 1 ) {
202         int save_errno = errno;
203         fclose (fp);
204         gpgme_data_release (dh);
205         errno = save_errno;
206         return mk_error (File_Error);
207     }
208
209     fclose (fp);
210
211     dh->len = dh->private_len;
212     dh->data = dh->private_buffer;
213     dh->writepos = dh->len;
214     dh->type = GPGME_DATA_TYPE_MEM;
215     
216     *r_dh = dh;
217     return 0;
218 }
219
220
221 GpgmeError
222 gpgme_data_new_from_filepart ( GpgmeData *r_dh, const char *fname, FILE *fp,
223                                off_t offset, off_t length )
224 {
225     GpgmeData dh;
226     GpgmeError err;
227
228     if (!r_dh)
229         return mk_error (Invalid_Value);
230     *r_dh = NULL;
231     if ( fname && fp ) /* these are mutual exclusive */
232         return mk_error (Invalid_Value);
233     if (!fname && !fp)
234         return mk_error (Invalid_Value);
235     if (!length)
236         return mk_error (Invalid_Value);
237
238     err = gpgme_data_new ( &dh );
239     if (err)
240         return err;
241
242     if (!fp) {
243         fp = fopen (fname, "rb");
244         if (!fp) {
245             int save_errno = errno;
246             gpgme_data_release (dh);
247             errno = save_errno;
248             return mk_error (File_Error);
249         }
250     }
251
252     if ( fseek ( fp, (long)offset, SEEK_SET) ) {
253         int save_errno = errno;
254         if (fname)
255             fclose (fp);
256         gpgme_data_release (dh);
257         errno = save_errno;
258         return mk_error (File_Error);
259     }
260
261
262     dh->private_buffer = xtrymalloc ( length );
263     if ( !dh->private_buffer ) {
264         if (fname)
265             fclose (fp);
266         gpgme_data_release (dh);
267         return mk_error (Out_Of_Core);
268     }
269     dh->private_len = length;
270
271     if ( fread ( dh->private_buffer, dh->private_len, 1, fp ) != 1 ) {
272         int save_errno = errno;
273         if (fname)
274             fclose (fp);
275         gpgme_data_release (dh);
276         errno = save_errno;
277         return mk_error (File_Error);
278     }
279
280     if (fname)
281         fclose (fp);
282
283     dh->len = dh->private_len;
284     dh->data = dh->private_buffer;
285     dh->writepos = dh->len;
286     dh->type = GPGME_DATA_TYPE_MEM;
287     
288     *r_dh = dh;
289     return 0;
290 }
291
292
293 /**
294  * gpgme_data_release:
295  * @dh: Data object 
296  * 
297  * Release the data object @dh.  @dh may be NULL in which case nothing
298  * happens.
299  **/
300 void
301 gpgme_data_release ( GpgmeData dh )
302 {
303     if (dh) {
304         xfree (dh->private_buffer); 
305         xfree (dh);
306     }
307 }
308
309 char *
310 _gpgme_data_release_and_return_string ( GpgmeData dh )
311 {
312     char *val = NULL;
313
314     if (dh) {
315         if ( _gpgme_data_append ( dh, "", 1 ) ) /* append EOS */
316             xfree (dh->private_buffer );
317         else {
318             val = dh->private_buffer;
319             if ( !val && dh->data ) {
320                 val = xtrymalloc ( dh->len );
321                 if ( val )
322                     memcpy ( val, dh->data, dh->len );
323             }
324         }
325         xfree (dh);
326     }
327     return val;
328 }
329
330 /**
331  * gpgme_data_release_and_get_mem:
332  * @dh: the data object
333  * @r_len: returns the length of the memory
334  * 
335  * Release the data object @dh and return its content and the length
336  * of that content.  The caller has to free this data.  @dh maybe NULL
337  * in which case NULL is returned.  If there is not enough memory for
338  * allocating the return value, NULL is returned and the object is
339  * released.
340  * 
341  * Return value: a pointer to an allocated buffer of length @r_len.
342  **/
343 char *
344 gpgme_data_release_and_get_mem ( GpgmeData dh, size_t *r_len )
345 {
346     char *val = NULL;
347
348     if (r_len)
349         *r_len = 0;
350     if (dh) {
351         size_t len = dh->len;
352         val = dh->private_buffer;
353         if ( !val && dh->data ) {
354             val = xtrymalloc ( len );
355             if ( val )
356                 memcpy ( val, dh->data, len );
357         }
358         xfree (dh);
359         if (val && r_len )
360             *r_len = len;
361     }
362     return val;
363 }
364
365
366 /**
367  * gpgme_data_get_type:
368  * @dh: the data object
369  * 
370  * Get the type of the data object.
371  * Data types are prefixed with %GPGME_DATA_TYPE_
372  * 
373  * Return value: the data type
374  **/
375 GpgmeDataType
376 gpgme_data_get_type ( GpgmeData dh )
377 {
378     if ( !dh || (!dh->data && !dh->read_cb))
379         return GPGME_DATA_TYPE_NONE;
380             
381     return dh->type;
382 }
383
384 void 
385 _gpgme_data_set_mode ( GpgmeData dh, GpgmeDataMode mode )
386 {
387     assert (dh);
388     dh->mode = mode;
389 }
390
391
392 GpgmeDataMode
393 _gpgme_data_get_mode ( GpgmeData dh )
394 {
395     assert (dh);
396     return dh->mode;
397 }
398
399 /**
400  * gpgme_data_rewind:
401  * @dh: the data object 
402  * 
403  * Prepare the data object in a way, that a gpgme_data_read() does start
404  * at the beginning of the data.  This has to be done for all types
405  * of data objects.
406  * 
407  * Return value: An error code or 0 on success
408  **/
409 GpgmeError
410 gpgme_data_rewind ( GpgmeData dh )
411 {
412     if ( !dh )
413         return mk_error (Invalid_Value);
414
415     if ( dh->type == GPGME_DATA_TYPE_NONE 
416          || dh->type == GPGME_DATA_TYPE_MEM ) {
417         dh->readpos = 0;
418     }
419     else if (dh->type == GPGME_DATA_TYPE_CB) {
420         dh->len = dh->readpos = 0;
421         dh->read_cb_eof = 0;
422         /* FIXME: do a special call to the read function to trigger a rewind
423            there */
424     }
425     else
426         return mk_error (General_Error);
427     return 0;
428 }
429
430 /**
431  * gpgme_data_read:
432  * @dh: the data object
433  * @buffer: A buffer 
434  * @length: The length of that bufer
435  * @nread: Returns the number of bytes actually read.
436  * 
437  * Copy data from the current read position (which may be set by
438  * gpgme_data_rewind()) to the supplied @buffer, max. @length bytes
439  * are copied and the actual number of bytes are returned in @nread.
440  * If there are no more bytes available %GPGME_EOF is returned and @nread
441  * is set to 0.
442  * 
443  * Return value: An errorcode or 0 on success, EOF is indcated by the
444  * error code GPGME_EOF.
445  **/
446 GpgmeError
447 gpgme_data_read ( GpgmeData dh, char *buffer, size_t length, size_t *nread )
448 {
449     size_t nbytes;
450
451     if ( !dh )
452         return mk_error (Invalid_Value);
453     if (dh->type == GPGME_DATA_TYPE_MEM ) {
454         nbytes = dh->len - dh->readpos;
455         if ( !nbytes ) {
456             *nread = 0;
457             return mk_error(EOF);
458         }
459         if (nbytes > length)
460             nbytes = length;
461         memcpy ( buffer, dh->data + dh->readpos, nbytes );
462         *nread = nbytes;
463         dh->readpos += nbytes;
464     }
465     else if (dh->type == GPGME_DATA_TYPE_CB) {
466         nbytes = dh->len - dh->readpos;
467         if ( nbytes ) {
468             /* we have unread data - return this */
469             if (nbytes > length)
470                 nbytes = length;
471             memcpy ( buffer, dh->data + dh->readpos, nbytes );
472             *nread = nbytes;
473             dh->readpos += nbytes;
474         }
475         else { /* get the data from the callback */
476             if (!dh->read_cb || dh->read_cb_eof) { 
477                 *nread = 0;
478                 return mk_error (EOF);
479             }
480             if (dh->read_cb (dh->read_cb_value, buffer, length, nread )) {
481                 *nread = 0;
482                 dh->read_cb_eof = 1;
483                 return mk_error (EOF);
484             }
485         }
486     }
487     else
488         return mk_error (General_Error);
489     return 0;
490
491
492 GpgmeError
493 _gpgme_data_unread (GpgmeData dh, const char *buffer, size_t length )
494 {
495    if ( !dh )
496         return mk_error (Invalid_Value);
497
498    if (dh->type == GPGME_DATA_TYPE_MEM ) {
499        /* check that we don't unread more than we have yet read */
500        if ( dh->readpos < length )
501            return mk_error (Invalid_Value);
502        /* No need to use the buffer for this data type */
503        dh->readpos -= length;
504    }
505    else {
506        return mk_error (General_Error);
507    }
508
509    return 0;
510 }
511
512
513 /* 
514  * This function does make sense when we know that it contains no nil chars.
515  */
516 char *
517 _gpgme_data_get_as_string ( GpgmeData dh )
518 {
519     char *val = NULL;
520
521     if (dh) {
522         val = xtrymalloc ( dh->len+1 );
523         if ( val ) {
524             memcpy ( val, dh->data, dh->len );
525             val[dh->len] = 0;
526         }
527     }
528     return val;
529 }
530
531
532 /**
533  * gpgme_data_write:
534  * @dh: the context
535  * @buffer: data to be written to the data object
536  * @length: length o this data
537  * 
538  * Write the content of @buffer to the data object @dh at the current write
539  * position. 
540  * 
541  * Return value: 0 on succress or an errorcode
542  **/
543 GpgmeError
544 gpgme_data_write ( GpgmeData dh, const char *buffer, size_t length )
545 {
546     if (!dh || !buffer)
547         return mk_error (Invalid_Value);
548       
549     return _gpgme_data_append (dh, buffer, length );
550 }
551
552
553 GpgmeError
554 _gpgme_data_append ( GpgmeData dh, const char *buffer, size_t length )
555 {
556     assert (dh);
557
558     if ( dh->type == GPGME_DATA_TYPE_NONE ) {
559         /* convert it to a mem data type */
560         assert (!dh->private_buffer);
561         dh->type = GPGME_DATA_TYPE_MEM;
562         dh->private_len = length < ALLOC_CHUNK? ALLOC_CHUNK : length;
563         dh->private_buffer = xtrymalloc ( dh->private_len );
564         if (!dh->private_buffer) {
565             dh->private_len = 0;
566             return mk_error (Out_Of_Core);
567         }
568         dh->writepos = 0;
569         dh->data = dh->private_buffer;
570     }
571     else if ( dh->type != GPGME_DATA_TYPE_MEM ) 
572         return mk_error (Invalid_Type);
573     
574     if ( dh->mode != GPGME_DATA_MODE_INOUT 
575          && dh->mode != GPGME_DATA_MODE_IN  )
576         return mk_error (Invalid_Mode);
577
578     if ( !dh->private_buffer ) {
579         /* we have to copy it now */
580         assert (dh->data);
581         dh->private_len = dh->len+length;
582         if (dh->private_len < ALLOC_CHUNK)
583             dh->private_len = ALLOC_CHUNK;
584         dh->private_buffer = xtrymalloc ( dh->private_len );
585         if (!dh->private_buffer) {
586             dh->private_len = 0;
587             return mk_error (Out_Of_Core);
588         }
589         memcpy ( dh->private_buffer, dh->data, dh->len );
590         dh->writepos = dh->len;
591         dh->data = dh->private_buffer;
592     }
593
594     /* allocate more memory if needed */
595     if ( dh->writepos + length > dh->private_len ) {
596         char *p;
597         size_t newlen = dh->private_len
598                         + (dh->len < ALLOC_CHUNK? ALLOC_CHUNK : length);
599         p = xtryrealloc ( dh->private_buffer, newlen );
600         if ( !p ) 
601             return mk_error (Out_Of_Core);
602         dh->private_buffer = p;
603         dh->private_len = newlen;
604         dh->data = dh->private_buffer;
605         assert ( !(dh->writepos + length > dh->private_len) );      
606     }
607
608     memcpy ( dh->private_buffer + dh->writepos, buffer, length );
609     dh->writepos += length;
610     dh->len += length;
611
612     return 0;
613 }
614
615 GpgmeError
616 _gpgme_data_append_string ( GpgmeData dh, const char *s )
617 {
618     return _gpgme_data_append ( dh, s, s? strlen(s):0 );
619 }
620
621
622 GpgmeError
623 _gpgme_data_append_for_xml ( GpgmeData dh,
624                              const char *buffer, size_t len )
625 {
626     const char *text, *s;
627     size_t n;
628     int rc = 0; 
629        
630     if ( !dh || !buffer )
631         return mk_error (Invalid_Value);
632
633     do {
634         for (text=NULL, s=buffer, n=len; n && !text; s++, n-- ) {
635             if ( *s == '<' ) 
636                 text = "&lt;";
637             else if ( *s == '>' ) 
638                 text = "&gt;";  /* not sure whether this is really needed */
639             else if ( *s == '&' ) 
640                 text = "&amp;";
641             else if ( !*s )
642                 text = "&#00;";
643         }
644         if (text) {
645             s--; n++;
646         }
647         if (s != buffer) 
648             rc = _gpgme_data_append ( dh, buffer, s-buffer );
649         if ( !rc && text) {
650             rc = _gpgme_data_append_string ( dh, text );
651             s++; n--;
652         }
653         buffer = s;
654         len = n;
655     } while ( !rc && len );
656     return rc;
657 }
658
659
660 /*
661  * Append a string to DATA and convert it so that the result will be 
662  * valid XML. 
663  */
664 GpgmeError
665 _gpgme_data_append_string_for_xml ( GpgmeData dh, const char *string )
666 {
667     return _gpgme_data_append_for_xml ( dh, string, strlen (string) );
668 }
669
670
671 static int
672 hextobyte( const byte *s )
673 {
674     int c;
675
676     if( *s >= '0' && *s <= '9' )
677         c = 16 * (*s - '0');
678     else if( *s >= 'A' && *s <= 'F' )
679         c = 16 * (10 + *s - 'A');
680     else if( *s >= 'a' && *s <= 'f' )
681         c = 16 * (10 + *s - 'a');
682     else
683         return -1;
684     s++;
685     if( *s >= '0' && *s <= '9' )
686         c += *s - '0';
687     else if( *s >= 'A' && *s <= 'F' )
688         c += 10 + *s - 'A';
689     else if( *s >= 'a' && *s <= 'f' )
690         c += 10 + *s - 'a';
691     else
692         return -1;
693     return c;
694 }
695
696
697
698
699 /* 
700  * Append a string with percent style (%XX) escape characters as XML
701  */
702 GpgmeError
703 _gpgme_data_append_percentstring_for_xml ( GpgmeData dh, const char *string )
704 {
705     const byte *s;
706     byte *buf, *d;
707     int val;
708     GpgmeError err;
709
710     d = buf = xtrymalloc ( strlen (string) );
711     for (s=string; *s; s++ ) {
712         if ( *s == '%' && (val=hextobyte (s+1)) != -1 ) {
713             *d++ = val;
714             s += 2;
715         }
716         else
717             *d++ = *s;
718     }
719
720     err = _gpgme_data_append_for_xml ( dh, buf, d - buf );
721     xfree (buf);
722     return err;
723 }
724
725
726
727
728
729
730