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