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