core: Improve the debug messages even more.
[gpgme.git] / src / data.c
1 /* data.c - An abstraction for data objects.
2  * Copyright (C) 2002, 2003, 2004, 2005, 2007 g10 Code GmbH
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <https://gnu.org/licenses/>.
18  * SPDX-License-Identifier: LGPL-2.1-or-later
19  */
20
21 #if HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <stdlib.h>
26 #ifdef HAVE_UNISTD_H
27 # include <unistd.h>
28 #endif
29 #include <errno.h>
30 #include <string.h>
31 #include <assert.h>
32
33 #include "gpgme.h"
34 #include "data.h"
35 #include "util.h"
36 #include "ops.h"
37 #include "priv-io.h"
38 #include "debug.h"
39
40
41 /* The property table which has an entry for each active data object.
42  * The data object itself uses an index into this table and the table
43  * has a pointer back to the data object.  All access to that table is
44  * controlled by the property_table_lock.
45  *
46  * We use a separate table instead of linking all data objects
47  * together for faster locating properties of the data object using
48  * the data objects serial number.  We use 64 bit for the serial
49  * number which is good enough to create a new data object every
50  * nanosecond for more than 500 years.  Thus no wrap around will ever
51  * happen.
52  */
53 struct property_s
54 {
55   gpgme_data_t dh;   /* The data objcet or NULL if the slot is not used.  */
56   uint64_t dserial;  /* The serial number of the data object.  */
57   struct {
58     unsigned int blankout : 1;  /* Void the held data.  */
59   } flags;
60 };
61 typedef struct property_s *property_t;
62
63 static property_t property_table;
64 static unsigned int property_table_size;
65 DEFINE_STATIC_LOCK (property_table_lock);
66 #define PROPERTY_TABLE_ALLOCATION_CHUNK 32
67
68
69 \f
70 /* Insert the newly created data object DH into the property table and
71  * store the index of it at R_IDX.  An error code is returned on error
72  * and the table is not changed.  */
73 static gpg_error_t
74 insert_into_property_table (gpgme_data_t dh, unsigned int *r_idx)
75 {
76   static uint64_t last_dserial;
77   gpg_error_t err;
78   unsigned int idx;
79
80   LOCK (property_table_lock);
81   if (!property_table)
82     {
83       property_table_size = PROPERTY_TABLE_ALLOCATION_CHUNK;
84       property_table = calloc (property_table_size, sizeof *property_table);
85       if (!property_table)
86         {
87           err = gpg_error_from_syserror ();
88           goto leave;
89         }
90     }
91
92   /* Find an empty slot.  */
93   for (idx = 0; idx < property_table_size; idx++)
94     if (!property_table[idx].dh)
95       break;
96   if (!(idx < property_table_size))
97     {
98       /* No empty slot found.  Enlarge the table.  */
99       property_t newtbl;
100       unsigned int newsize;
101
102       newsize = property_table_size + PROPERTY_TABLE_ALLOCATION_CHUNK;;
103       if ((newsize * sizeof *property_table)
104           < (property_table_size * sizeof *property_table))
105         {
106           err = gpg_error (GPG_ERR_ENOMEM);
107           goto leave;
108         }
109       newtbl = realloc (property_table, newsize * sizeof *property_table);
110       if (!newtbl)
111         {
112           err = gpg_error_from_syserror ();
113           goto leave;
114         }
115       property_table = newtbl;
116       for (idx = property_table_size; idx < newsize; idx++)
117         property_table[idx].dh = NULL;
118       idx = property_table_size;
119       property_table_size = newsize;
120     }
121
122   /* Slot found. */
123   property_table[idx].dh = dh;
124   property_table[idx].dserial = ++last_dserial;
125   memset (&property_table[idx].flags, 0, sizeof property_table[idx].flags);
126   *r_idx = idx;
127   err = 0;
128
129  leave:
130   UNLOCK (property_table_lock);
131   return err;
132 }
133
134
135 /* Remove the data object at PROPIDX from the table.  DH is only used
136  * for cross checking.  */
137 static void
138 remove_from_property_table (gpgme_data_t dh, unsigned int propidx)
139 {
140   LOCK (property_table_lock);
141   assert (property_table);
142   assert (propidx < property_table_size);
143   assert (property_table[propidx].dh == dh);
144   property_table[propidx].dh = NULL;
145   UNLOCK (property_table_lock);
146 }
147
148
149 /* Return the data object's serial number for handle DH.  This is a
150  * unique serial number for each created data object.  */
151 uint64_t
152 _gpgme_data_get_dserial (gpgme_data_t dh)
153 {
154   uint64_t dserial;
155   unsigned int idx;
156
157   if (!dh)
158     return 0;
159
160   idx = dh->propidx;
161   LOCK (property_table_lock);
162   assert (property_table);
163   assert (idx < property_table_size);
164   assert (property_table[idx].dh == dh);
165   dserial = property_table[idx].dserial;
166   UNLOCK (property_table_lock);
167
168   return dserial;
169 }
170
171
172 /* Set an internal property of a data object.  The data object may
173  * either be identified by the usual DH or by using the data serial
174  * number DSERIAL.  */
175 gpg_error_t
176 _gpgme_data_set_prop (gpgme_data_t dh, uint64_t dserial,
177                       data_prop_t name, int value)
178 {
179   gpg_error_t err = 0;
180   int idx;
181   TRACE_BEG  (DEBUG_DATA, "gpgme_data_set_prop", dh,
182               "dserial=%llu %lu=%d",
183               (unsigned long long)dserial,
184               (unsigned long)name, value);
185
186   LOCK (property_table_lock);
187   if ((!dh && !dserial) || (dh && dserial))
188     {
189       err = gpg_error (GPG_ERR_INV_VALUE);
190       goto leave;
191     }
192   if (dh) /* Lookup via handle.  */
193     {
194       idx = dh->propidx;
195       assert (property_table);
196       assert (idx < property_table_size);
197       assert (property_table[idx].dh == dh);
198     }
199   else /* Lookup via DSERIAL.  */
200     {
201       if (!property_table)
202         {
203           err = gpg_error (GPG_ERR_NOT_FOUND);
204           goto leave;
205         }
206       for (idx = 0; idx < property_table_size; idx++)
207         if (property_table[idx].dh && property_table[idx].dserial == dserial)
208           break;
209       if (!(idx < property_table_size))
210         {
211           err = gpg_error (GPG_ERR_NOT_FOUND);
212           goto leave;
213         }
214     }
215
216   switch (name)
217     {
218     case DATA_PROP_NONE: /* Nothing to to do.  */
219       break;
220     case DATA_PROP_BLANKOUT:
221       property_table[idx].flags.blankout = !!value;
222       break;
223
224     default:
225       err = gpg_error (GPG_ERR_UNKNOWN_NAME);
226       break;
227     }
228
229  leave:
230   UNLOCK (property_table_lock);
231   return TRACE_ERR (err);
232 }
233
234
235 /* Get an internal property of a data object.  This is the counter
236  * part to _gpgme_data_set_property.  The value of the property is
237  * stored at R_VALUE.  On error 0 is stored at R_VALUE.  */
238 gpg_error_t
239 _gpgme_data_get_prop (gpgme_data_t dh, uint64_t dserial,
240                       data_prop_t name, int *r_value)
241 {
242   gpg_error_t err = 0;
243   int idx;
244   TRACE_BEG  (DEBUG_DATA, "gpgme_data_get_prop", dh,
245               "dserial=%llu %lu",
246               (unsigned long long)dserial,
247               (unsigned long)name);
248
249   *r_value = 0;
250
251   LOCK (property_table_lock);
252   if ((!dh && !dserial) || (dh && dserial))
253     {
254       err = gpg_error (GPG_ERR_INV_VALUE);
255       goto leave;
256     }
257   if (dh) /* Lookup via handle.  */
258     {
259       idx = dh->propidx;
260       assert (property_table);
261       assert (idx < property_table_size);
262       assert (property_table[idx].dh == dh);
263     }
264   else /* Lookup via DSERIAL.  */
265     {
266       if (!property_table)
267         {
268           err = gpg_error (GPG_ERR_NOT_FOUND);
269           goto leave;
270         }
271       for (idx = 0; idx < property_table_size; idx++)
272         if (property_table[idx].dh && property_table[idx].dserial == dserial)
273           break;
274       if (!(idx < property_table_size))
275         {
276           err = gpg_error (GPG_ERR_NOT_FOUND);
277           goto leave;
278         }
279     }
280
281   switch (name)
282     {
283     case DATA_PROP_NONE: /* Nothing to to do.  */
284       break;
285     case DATA_PROP_BLANKOUT:
286       *r_value = property_table[idx].flags.blankout;
287       break;
288
289     default:
290       err = gpg_error (GPG_ERR_UNKNOWN_NAME);
291       break;
292     }
293
294  leave:
295   UNLOCK (property_table_lock);
296   return TRACE_ERR (err);
297 }
298
299
300 \f
301 gpgme_error_t
302 _gpgme_data_new (gpgme_data_t *r_dh, struct _gpgme_data_cbs *cbs)
303 {
304   gpgme_error_t err;
305   gpgme_data_t dh;
306
307   if (!r_dh)
308     return gpg_error (GPG_ERR_INV_VALUE);
309
310   *r_dh = NULL;
311
312   if (_gpgme_selftest)
313     return _gpgme_selftest;
314
315   dh = calloc (1, sizeof (*dh));
316   if (!dh)
317     return gpg_error_from_syserror ();
318
319   dh->cbs = cbs;
320
321   err = insert_into_property_table (dh, &dh->propidx);
322   if (err)
323     {
324       free (dh);
325       return err;
326     }
327
328   *r_dh = dh;
329   return 0;
330 }
331
332
333 void
334 _gpgme_data_release (gpgme_data_t dh)
335 {
336   if (!dh)
337     return;
338
339   remove_from_property_table (dh, dh->propidx);
340   if (dh->file_name)
341     free (dh->file_name);
342   free (dh);
343 }
344
345
346 \f
347 /* Read up to SIZE bytes into buffer BUFFER from the data object with
348    the handle DH.  Return the number of characters read, 0 on EOF and
349    -1 on error.  If an error occurs, errno is set.  */
350 gpgme_ssize_t
351 gpgme_data_read (gpgme_data_t dh, void *buffer, size_t size)
352 {
353   gpgme_ssize_t res;
354   int blankout;
355   TRACE_BEG  (DEBUG_DATA, "gpgme_data_read", dh,
356               "buffer=%p, size=%zu", buffer, size);
357
358   if (!dh)
359     {
360       gpg_err_set_errno (EINVAL);
361       return TRACE_SYSRES (-1);
362     }
363   if (!dh->cbs->read)
364     {
365       gpg_err_set_errno (ENOSYS);
366       return TRACE_SYSRES (-1);
367     }
368
369   if (_gpgme_data_get_prop (dh, 0, DATA_PROP_BLANKOUT, &blankout)
370       || blankout)
371     res = 0;
372   else
373     {
374       do
375         res = (*dh->cbs->read) (dh, buffer, size);
376       while (res < 0 && errno == EINTR);
377     }
378
379   return TRACE_SYSRES ((int)res);
380 }
381
382
383 /* Write up to SIZE bytes from buffer BUFFER to the data object with
384    the handle DH.  Return the number of characters written, or -1 on
385    error.  If an error occurs, errno is set.  */
386 gpgme_ssize_t
387 gpgme_data_write (gpgme_data_t dh, const void *buffer, size_t size)
388 {
389   gpgme_ssize_t res;
390   TRACE_BEG  (DEBUG_DATA, "gpgme_data_write", dh,
391               "buffer=%p, size=%zu", buffer, size);
392
393   if (!dh)
394     {
395       gpg_err_set_errno (EINVAL);
396       return TRACE_SYSRES (-1);
397     }
398   if (!dh->cbs->write)
399     {
400       gpg_err_set_errno (ENOSYS);
401       return TRACE_SYSRES (-1);
402     }
403   do
404     res = (*dh->cbs->write) (dh, buffer, size);
405   while (res < 0 && errno == EINTR);
406
407   return TRACE_SYSRES ((int)res);
408 }
409
410
411 /* Set the current position from where the next read or write starts
412    in the data object with the handle DH to OFFSET, relative to
413    WHENCE.  */
414 gpgme_off_t
415 gpgme_data_seek (gpgme_data_t dh, gpgme_off_t offset, int whence)
416 {
417   TRACE_BEG  (DEBUG_DATA, "gpgme_data_seek", dh,
418               "offset=%lli, whence=%i", (long long int)offset, whence);
419
420   if (!dh)
421     {
422       gpg_err_set_errno (EINVAL);
423       return TRACE_SYSRES (-1);
424     }
425   if (!dh->cbs->seek)
426     {
427       gpg_err_set_errno (ENOSYS);
428       return TRACE_SYSRES (-1);
429     }
430
431   /* For relative movement, we must take into account the actual
432      position of the read counter.  */
433   if (whence == SEEK_CUR)
434     offset -= dh->pending_len;
435
436   offset = (*dh->cbs->seek) (dh, offset, whence);
437   if (offset >= 0)
438     dh->pending_len = 0;
439
440   return TRACE_SYSRES ((int)offset);
441 }
442
443
444 /* Convenience function to do a gpgme_data_seek (dh, 0, SEEK_SET).  */
445 gpgme_error_t
446 gpgme_data_rewind (gpgme_data_t dh)
447 {
448   gpgme_error_t err;
449   TRACE_BEG  (DEBUG_DATA, "gpgme_data_rewind", dh, "");
450
451   err = ((gpgme_data_seek (dh, 0, SEEK_SET) == -1)
452          ? gpg_error_from_syserror () : 0);
453
454   return TRACE_ERR (err);
455 }
456
457
458 /* Release the data object with the handle DH.  */
459 void
460 gpgme_data_release (gpgme_data_t dh)
461 {
462   TRACE (DEBUG_DATA, "gpgme_data_release", dh, "");
463
464   if (!dh)
465     return;
466
467   if (dh->cbs->release)
468     (*dh->cbs->release) (dh);
469   _gpgme_data_release (dh);
470 }
471
472
473 /* Get the current encoding meta information for the data object with
474    handle DH.  */
475 gpgme_data_encoding_t
476 gpgme_data_get_encoding (gpgme_data_t dh)
477 {
478   TRACE (DEBUG_DATA, "gpgme_data_get_encoding", dh,
479          "dh->encoding=%i", dh ? dh->encoding : GPGME_DATA_ENCODING_NONE);
480   return dh ? dh->encoding : GPGME_DATA_ENCODING_NONE;
481 }
482
483
484 /* Set the encoding meta information for the data object with handle
485    DH to ENC.  */
486 gpgme_error_t
487 gpgme_data_set_encoding (gpgme_data_t dh, gpgme_data_encoding_t enc)
488 {
489   TRACE_BEG  (DEBUG_DATA, "gpgme_data_set_encoding", dh,
490               "encoding=%i", enc);
491   if (!dh)
492     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
493   if (enc < 0 || enc > GPGME_DATA_ENCODING_MIME)
494     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
495   dh->encoding = enc;
496   return TRACE_ERR (0);
497 }
498
499
500 /* Set the file name associated with the data object with handle DH to
501    FILE_NAME.  */
502 gpgme_error_t
503 gpgme_data_set_file_name (gpgme_data_t dh, const char *file_name)
504 {
505   TRACE_BEG  (DEBUG_DATA, "gpgme_data_set_file_name", dh,
506               "file_name=%s", file_name);
507
508   if (!dh)
509     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
510
511   if (dh->file_name)
512     free (dh->file_name);
513
514   if (file_name)
515     {
516       dh->file_name = strdup (file_name);
517       if (!dh->file_name)
518         return TRACE_ERR (gpg_error_from_syserror ());
519     }
520   else
521     dh->file_name = 0;
522
523   return TRACE_ERR (0);
524 }
525
526
527 /* Get the file name associated with the data object with handle DH,
528    or NULL if there is none.  */
529 char *
530 gpgme_data_get_file_name (gpgme_data_t dh)
531 {
532   if (!dh)
533     {
534       TRACE (DEBUG_DATA, "gpgme_data_get_file_name", dh, "");
535       return NULL;
536     }
537
538   TRACE (DEBUG_DATA, "gpgme_data_get_file_name", dh,
539          "dh->file_name=%s", dh->file_name);
540   return dh->file_name;
541 }
542
543
544 /* Set a flag for the data object DH.  See the manual for details.  */
545 gpg_error_t
546 gpgme_data_set_flag (gpgme_data_t dh, const char *name, const char *value)
547 {
548   TRACE_BEG  (DEBUG_DATA, "gpgme_data_set_flag", dh,
549               "%s=%s", name, value);
550
551   if (!dh)
552     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
553
554   if (!strcmp (name, "size-hint"))
555     {
556       dh->size_hint= value? _gpgme_string_to_off (value) : 0;
557     }
558   else
559     return gpg_error (GPG_ERR_UNKNOWN_NAME);
560
561   return 0;
562 }
563
564
565 \f
566 /* Functions to support the wait interface.  */
567
568 gpgme_error_t
569 _gpgme_data_inbound_handler (void *opaque, int fd)
570 {
571   struct io_cb_data *data = (struct io_cb_data *) opaque;
572   gpgme_data_t dh = (gpgme_data_t) data->handler_value;
573   char buffer[BUFFER_SIZE];
574   char *bufp = buffer;
575   gpgme_ssize_t buflen;
576   TRACE_BEG  (DEBUG_CTX, "_gpgme_data_inbound_handler", dh,
577               "fd=%d", fd);
578
579   buflen = _gpgme_io_read (fd, buffer, BUFFER_SIZE);
580   if (buflen < 0)
581     return gpg_error_from_syserror ();
582   if (buflen == 0)
583     {
584       _gpgme_io_close (fd);
585       return TRACE_ERR (0);
586     }
587
588   do
589     {
590       gpgme_ssize_t amt = gpgme_data_write (dh, bufp, buflen);
591       if (amt == 0 || (amt < 0 && errno != EINTR))
592         return TRACE_ERR (gpg_error_from_syserror ());
593       bufp += amt;
594       buflen -= amt;
595     }
596   while (buflen > 0);
597   return TRACE_ERR (0);
598 }
599
600
601 gpgme_error_t
602 _gpgme_data_outbound_handler (void *opaque, int fd)
603 {
604   struct io_cb_data *data = (struct io_cb_data *) opaque;
605   gpgme_data_t dh = (gpgme_data_t) data->handler_value;
606   gpgme_ssize_t nwritten;
607   TRACE_BEG  (DEBUG_CTX, "_gpgme_data_outbound_handler", dh,
608               "fd=%d", fd);
609
610   if (!dh->pending_len)
611     {
612       gpgme_ssize_t amt = gpgme_data_read (dh, dh->pending, BUFFER_SIZE);
613       if (amt < 0)
614         return TRACE_ERR (gpg_error_from_syserror ());
615       if (amt == 0)
616         {
617           _gpgme_io_close (fd);
618           return TRACE_ERR (0);
619         }
620       dh->pending_len = amt;
621     }
622
623   nwritten = _gpgme_io_write (fd, dh->pending, dh->pending_len);
624   if (nwritten == -1 && errno == EAGAIN)
625     return TRACE_ERR (0);
626
627   if (nwritten == -1 && errno == EPIPE)
628     {
629       /* Not much we can do.  The other end closed the pipe, but we
630          still have data.  This should only ever happen if the other
631          end is going to tell us what happened on some other channel.
632          Silently close our end.  */
633       _gpgme_io_close (fd);
634       return TRACE_ERR (0);
635     }
636
637   if (nwritten <= 0)
638     return TRACE_ERR (gpg_error_from_syserror ());
639
640   if (nwritten < dh->pending_len)
641     memmove (dh->pending, dh->pending + nwritten, dh->pending_len - nwritten);
642   dh->pending_len -= nwritten;
643   return TRACE_ERR (0);
644 }
645
646
647 /* Get the file descriptor associated with DH, if possible.  Otherwise
648    return -1.  */
649 int
650 _gpgme_data_get_fd (gpgme_data_t dh)
651 {
652   if (!dh || !dh->cbs->get_fd)
653     return -1;
654   return (*dh->cbs->get_fd) (dh);
655 }
656
657
658 /* Get the size-hint value for DH or 0 if not available.  */
659 gpgme_off_t
660 _gpgme_data_get_size_hint (gpgme_data_t dh)
661 {
662   return dh ? dh->size_hint : 0;
663 }