GNUnet  0.11.x
bio.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2006, 2009, 2013 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
25 #include "platform.h"
26 #include "gnunet_util_lib.h"
27 
28 #define LOG(kind, ...) GNUNET_log_from (kind, "util-bio", __VA_ARGS__)
29 
30 #ifndef PATH_MAX
31 
34 #define PATH_MAX 4096
35 #endif
36 
37 
41 #define BIO_BUFFER_SIZE 65536
42 
47 #define MAX_META_DATA (1024 * 1024)
48 
49 
56 enum IOType
57 {
61  IO_FILE = 0,
62 
67 };
68 
69 
74 {
78  enum IOType type;
79 
84 
88  char *emsg;
89 
93  char *buffer;
94 
98  size_t have;
99 
103  size_t size;
104 
108  off_t pos;
109 };
110 
111 
118 struct GNUNET_BIO_ReadHandle *
120 {
121  struct GNUNET_DISK_FileHandle *fd;
122  struct GNUNET_BIO_ReadHandle *h;
123 
125  if (NULL == fd)
126  return NULL;
127  h = GNUNET_malloc (sizeof(struct GNUNET_BIO_ReadHandle) + BIO_BUFFER_SIZE);
128  h->type = IO_FILE;
129  h->buffer = (char *) &h[1];
130  h->size = BIO_BUFFER_SIZE;
131  h->fd = fd;
132  return h;
133 }
134 
135 
143 struct GNUNET_BIO_ReadHandle *
145 {
146  struct GNUNET_BIO_ReadHandle *h;
147 
148  h = GNUNET_new (struct GNUNET_BIO_ReadHandle);
149  h->type = IO_BUFFER;
150  h->buffer = buffer;
151  h->size = size;
152  return h;
153 }
154 
155 
165 int
167 {
168  int err;
169 
170  err = (NULL == h->emsg) ? GNUNET_OK : GNUNET_SYSERR;
171  if (NULL != emsg)
172  *emsg = h->emsg;
173  else
174  GNUNET_free (h->emsg);
175  switch (h->type)
176  {
177  case IO_FILE:
179  break;
180  case IO_BUFFER:
181  break;
182  default:
183  break;
184  }
185  GNUNET_free (h);
186  return err;
187 }
188 
189 
199 static int
201  const char *what,
202  char *result,
203  size_t len)
204 {
205  size_t pos = 0;
206  size_t min;
207  ssize_t ret;
208 
209  do
210  {
211  min = h->have - h->pos;
212  if (0 < min)
213  {
214  if (len - pos < min)
215  min = len - pos;
216  GNUNET_memcpy (&result[pos], &h->buffer[h->pos], min);
217  h->pos += min;
218  pos += min;
219  }
220  if (len == pos)
221  return GNUNET_OK;
222  GNUNET_assert (((off_t) h->have) == h->pos);
223  ret = GNUNET_DISK_file_read (h->fd, h->buffer, h->size);
224  if (-1 == ret)
225  {
226  GNUNET_asprintf (&h->emsg,
227  _ ("Error reading `%s' from file: %s"),
228  what,
229  strerror (errno));
230  return GNUNET_SYSERR;
231  }
232  if (0 == ret)
233  {
234  GNUNET_asprintf (&h->emsg,
235  _ ("Error reading `%s' from file: %s"),
236  what,
237  _ ("End of file"));
238  return GNUNET_SYSERR;
239  }
240  h->pos = 0;
241  h->have = ret;
242  }
243  while (pos < len);
244  return GNUNET_OK;
245 }
246 
247 
257 static int
259  const char *what,
260  char *result,
261  size_t len)
262 {
263  if ((h->size < len) || (h->size - h->pos < len))
264  {
265  GNUNET_asprintf (&h->emsg,
266  _ ("Error while reading `%s' from buffer: %s"),
267  what,
268  _ ("Not enough data left"));
269  return GNUNET_SYSERR;
270  }
271  GNUNET_memcpy (result, h->buffer + h->pos, len);
272  h->pos += len;
273  return GNUNET_OK;
274 }
275 
276 
286 int
288  const char *what,
289  void *result,
290  size_t len)
291 {
292  char *dst = result;
293 
294  if (NULL != h->emsg)
295  return GNUNET_SYSERR;
296 
297  if (0 == len)
298  return GNUNET_OK;
299 
300  switch (h->type)
301  {
302  case IO_FILE:
303  return read_from_file (h, what, dst, len);
304  case IO_BUFFER:
305  return read_from_buffer (h, what, dst, len);
306  default:
307  GNUNET_asprintf (&h->emsg,
308  _ ("Invalid handle type while reading `%s'"),
309  what);
310  return GNUNET_SYSERR;
311  }
312 }
313 
314 
325 int
327  const char *what,
328  char **result,
329  size_t max_length)
330 {
331  char *buf;
332  uint32_t big;
333 
335  _ ("string length"),
336  (int32_t *) &big))
337  {
338  char *tmp = h->emsg;
339  if (NULL != tmp)
340  GNUNET_asprintf (&h->emsg,
341  _ ("%s (while reading `%s')"),
342  tmp,
343  what);
344  else
345  GNUNET_asprintf (&h->emsg,
346  _ ("Error reading length of string `%s'"),
347  what);
348  GNUNET_free (tmp);
349  return GNUNET_SYSERR;
350  }
351  if (0 == big)
352  {
353  *result = NULL;
354  return GNUNET_OK;
355  }
356  if (big > max_length)
357  {
358  GNUNET_asprintf (&h->emsg,
359  _ ("String `%s' longer than allowed (%u > %u)"),
360  what,
361  big,
362  max_length);
363  return GNUNET_SYSERR;
364  }
365  buf = GNUNET_malloc (big);
366  *result = buf;
367  buf[--big] = '\0';
368  if (0 == big)
369  return GNUNET_OK;
370  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, big))
371  {
372  GNUNET_free (buf);
373  *result = NULL;
374  return GNUNET_SYSERR;
375  }
376  return GNUNET_OK;
377 }
378 
379 
388 int
390  const char *what,
392 {
393  uint32_t size;
394  char *buf;
396 
398  _ ("metadata length"),
399  (int32_t *) &size))
400  return GNUNET_SYSERR;
401  if (0 == size)
402  {
403  *result = NULL;
404  return GNUNET_OK;
405  }
406  if (MAX_META_DATA < size)
407  {
409  &h->emsg,
410  _ ("Serialized metadata `%s' larger than allowed (%u > %u)"),
411  what,
412  size,
413  MAX_META_DATA);
414  return GNUNET_SYSERR;
415  }
416  buf = GNUNET_malloc (size);
417  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, size))
418  {
419  GNUNET_free (buf);
420  return GNUNET_SYSERR;
421  }
422  meta = GNUNET_CONTAINER_meta_data_deserialize (buf, size);
423  if (NULL == meta)
424  {
425  GNUNET_free (buf);
426  GNUNET_asprintf (&h->emsg, _ ("Failed to deserialize metadata `%s'"), what);
427  return GNUNET_SYSERR;
428  }
429  GNUNET_free (buf);
430  *result = meta;
431  return GNUNET_OK;
432 }
433 
434 
442 int
444  const char *what,
445  float *f)
446 {
447  int32_t *i = (int32_t *) f;
448  return GNUNET_BIO_read_int32 (h, what, i);
449 }
450 
451 
459 int
461  const char *what,
462  double *f)
463 {
464  int64_t *i = (int64_t *) f;
465  return GNUNET_BIO_read_int64 (h, what, i);
466 }
467 
468 
477 int
479  const char *what,
480  int32_t *i)
481 {
482  int32_t big;
483 
484  if (GNUNET_OK != GNUNET_BIO_read (h, what, &big, sizeof(int32_t)))
485  return GNUNET_SYSERR;
486  *i = ntohl (big);
487  return GNUNET_OK;
488 }
489 
490 
499 int
501  const char *what,
502  int64_t *i)
503 {
504  int64_t big;
505 
506  if (GNUNET_OK != GNUNET_BIO_read (h, what, &big, sizeof(int64_t)))
507  return GNUNET_SYSERR;
508  *i = GNUNET_ntohll (big);
509  return GNUNET_OK;
510 }
511 
512 
517 {
521  enum IOType type;
522 
527 
531  char *emsg;
532 
538  void *buffer;
539 
543  size_t have;
544 
548  size_t size;
549 };
550 
551 
558 struct GNUNET_BIO_WriteHandle *
560 {
561  struct GNUNET_DISK_FileHandle *fd;
562  struct GNUNET_BIO_WriteHandle *h;
563 
564  fd =
571  if (NULL == fd)
572  return NULL;
574  h->buffer = &h[1];
575  h->size = BIO_BUFFER_SIZE;
576  h->fd = fd;
577  return h;
578 }
579 
580 
586 struct GNUNET_BIO_WriteHandle *
588 {
589  struct GNUNET_BIO_WriteHandle *h;
590 
591  h = GNUNET_new (struct GNUNET_BIO_WriteHandle);
592  h->type = IO_BUFFER;
593  h->buffer = (void *) GNUNET_malloc (sizeof (struct GNUNET_Buffer));
594  return h;
595 }
596 
597 
607 int
609 {
610  int err;
611 
612  err = (NULL == h->emsg) ? GNUNET_OK : GNUNET_SYSERR;
613  if (NULL != emsg)
614  *emsg = h->emsg;
615  else
616  GNUNET_free (h->emsg);
617  switch (h->type)
618  {
619  case IO_FILE:
620  if (NULL == h->fd)
621  return GNUNET_SYSERR;
622  if (GNUNET_OK != GNUNET_BIO_flush (h))
623  {
624  if (NULL != emsg)
625  *emsg = h->emsg;
626  else
627  GNUNET_free (h->emsg);
628  err = GNUNET_SYSERR;
629  }
630  else
631  {
633  }
634  break;
635  case IO_BUFFER:
636  GNUNET_buffer_clear ((struct GNUNET_Buffer *) h->buffer);
637  GNUNET_free (h->buffer);
638  break;
639  }
640  GNUNET_free (h);
641  return err;
642 }
643 
644 
654 int
656 {
657  ssize_t ret;
658 
659  if (IO_FILE != h->type)
660  return GNUNET_OK;
661 
662  ret = GNUNET_DISK_file_write (h->fd, h->buffer, h->have);
663  if (ret != (ssize_t) h->have)
664  {
666  h->fd = NULL;
667  GNUNET_free (h->emsg);
668  GNUNET_asprintf (&h->emsg, _ ("Unable to flush buffer to file"));
669  return GNUNET_SYSERR;
670  }
671  h->have = 0;
672  return GNUNET_OK;
673 }
674 
675 
688 int
690  char **emsg,
691  void **contents,
692  size_t *size)
693 {
694  if (IO_BUFFER != h->type)
695  return GNUNET_SYSERR;
696  if ((NULL == contents) || (NULL == size))
697  return GNUNET_SYSERR;
698  int ret = (NULL != h->emsg) ? GNUNET_SYSERR : GNUNET_OK;
699  if (NULL != emsg)
700  *emsg = h->emsg;
701  else
702  GNUNET_free (h->emsg);
703  *contents = GNUNET_buffer_reap ((struct GNUNET_Buffer *) h->buffer, size);
704  return ret;
705 }
706 
707 
717 static int
719  const char *what,
720  const char *source,
721  size_t len)
722 {
723  size_t min;
724  size_t pos = 0;
725  char *buffer = (char *) h->buffer;
726 
727  if (NULL == h->fd)
728  {
729  GNUNET_asprintf (&h->emsg,
730  _ ("Error while writing `%s' to file: %s"),
731  what,
732  _ ("No associated file"));
733  return GNUNET_SYSERR;
734  }
735 
736  do
737  {
738  min = h->size - h->have;
739  if (len - pos < min)
740  min = len - pos;
741  GNUNET_memcpy (&buffer[h->have], &source[pos], min);
742  pos += min;
743  h->have += min;
744  if (len == pos)
745  return GNUNET_OK;
746  GNUNET_assert (h->have == h->size);
747  if (GNUNET_OK != GNUNET_BIO_flush (h))
748  {
749  char *tmp = h->emsg;
750  GNUNET_asprintf (&h->emsg,
751  _ ("Error while writing `%s' to file: %s"),
752  what,
753  tmp);
754  GNUNET_free (tmp);
755  return GNUNET_SYSERR;
756  }
757  }
758  while (pos < len);
759  GNUNET_break (0);
760  return GNUNET_OK;
761 }
762 
763 
773 static int
775  const char *what,
776  const char *source,
777  size_t len)
778 {
779  GNUNET_buffer_write ((struct GNUNET_Buffer *) h->buffer, source, len);
780  h->have += len;
781  return GNUNET_OK;
782 }
783 
784 
794 int
796  const char *what,
797  const void *buffer,
798  size_t n)
799 {
800  const char *src = buffer;
801 
802  if (NULL != h->emsg)
803  return GNUNET_SYSERR;
804 
805  if (0 == n)
806  return GNUNET_OK;
807 
808  switch (h->type)
809  {
810  case IO_FILE:
811  return write_to_file (h, what, src, n);
812  case IO_BUFFER:
813  return write_to_buffer (h, what, src, n);
814  default:
815  GNUNET_asprintf (&h->emsg,
816  _ ("Invalid handle type while writing `%s'"),
817  what);
818  return GNUNET_SYSERR;
819  }
820 }
821 
822 
831 int
833  const char *what,
834  const char *s)
835 {
836  uint32_t slen;
837 
838  slen = (uint32_t) ((s == NULL) ? 0 : strlen (s) + 1);
839  if (GNUNET_OK != GNUNET_BIO_write_int32 (h, _ ("string length"), slen))
840  return GNUNET_SYSERR;
841  if (0 != slen)
842  return GNUNET_BIO_write (h, what, s, slen - 1);
843  return GNUNET_OK;
844 }
845 
846 
855 int
857  const char *what,
858  const struct GNUNET_CONTAINER_MetaData *m)
859 {
860  ssize_t size;
861  char *buf;
862 
863  if (m == NULL)
864  return GNUNET_BIO_write_int32 (h, _ ("metadata length"), 0);
865  buf = NULL;
867  m,
868  &buf,
871  if (-1 == size)
872  {
873  GNUNET_free (buf);
874  GNUNET_free (h->emsg);
875  GNUNET_asprintf (&h->emsg,
876  _ ("Failed to serialize metadata `%s'"),
877  what);
878  return GNUNET_SYSERR;
879  }
881  _ ("metadata length"),
882  (uint32_t) size))
883  || (GNUNET_OK != GNUNET_BIO_write (h, what, buf, size)))
884  {
885  GNUNET_free (buf);
886  return GNUNET_SYSERR;
887  }
888  GNUNET_free (buf);
889  return GNUNET_OK;
890 }
891 
892 
900 int
902  const char *what,
903  float f)
904 {
905  int32_t i = f;
906  return GNUNET_BIO_write_int32 (h, what, i);
907 }
908 
909 
917 int
919  const char *what,
920  double f)
921 {
922  int64_t i = f;
923  return GNUNET_BIO_write_int64 (h, what, i);
924 }
925 
926 
935 int
937  const char *what,
938  int32_t i)
939 {
940  int32_t big;
941 
942  big = htonl (i);
943  return GNUNET_BIO_write (h, what, &big, sizeof(int32_t));
944 }
945 
946 
955 int
957  const char *what,
958  int64_t i)
959 {
960  int64_t big;
961 
962  big = GNUNET_htonll (i);
963  return GNUNET_BIO_write (h, what, &big, sizeof(int64_t));
964 }
965 
966 
977 static int
979  struct GNUNET_BIO_ReadHandle *h,
980  const char *what,
981  void *target,
982  size_t target_size)
983 {
984  return GNUNET_BIO_read (h, what, target, target_size);
985 }
986 
987 
996 struct GNUNET_BIO_ReadSpec
998  void *result,
999  size_t len)
1000 {
1001  struct GNUNET_BIO_ReadSpec rs = {
1003  .cls = NULL,
1004  .what = what,
1005  .target = result,
1006  .size = len,
1007  };
1008 
1009  return rs;
1010 }
1011 
1012 
1023 static int
1025  struct GNUNET_BIO_ReadHandle *h,
1026  const char *what,
1027  void *target,
1028  size_t target_size)
1029 {
1030  char **result = target;
1031  return GNUNET_BIO_read_string (h, what, result, target_size);
1032 }
1033 
1034 
1044 struct GNUNET_BIO_ReadSpec
1046  char **result,
1047  size_t max_length)
1048 {
1049  struct GNUNET_BIO_ReadSpec rs = {
1051  .cls = NULL,
1052  .target = result,
1053  .size = max_length,
1054  };
1055 
1056  return rs;
1057 }
1058 
1059 
1071 static int
1073  struct GNUNET_BIO_ReadHandle *h,
1074  const char *what,
1075  void *target,
1076  size_t target_size)
1077 {
1078  struct GNUNET_CONTAINER_MetaData **result = target;
1079  return GNUNET_BIO_read_meta_data (h, what, result);
1080 }
1081 
1082 
1090 struct GNUNET_BIO_ReadSpec
1093 {
1094  struct GNUNET_BIO_ReadSpec rs = {
1096  .cls = NULL,
1097  .target = result,
1098  .size = 0,
1099  };
1100 
1101  return rs;
1102 }
1103 
1104 
1115 static int
1117  struct GNUNET_BIO_ReadHandle *h,
1118  const char *what,
1119  void *target,
1120  size_t target_size)
1121 {
1122  int32_t *result = target;
1123  return GNUNET_BIO_read_int32 (h, what, result);
1124 }
1125 
1126 
1134 struct GNUNET_BIO_ReadSpec
1136  int32_t *i)
1137 {
1138  struct GNUNET_BIO_ReadSpec rs = {
1140  .cls = NULL,
1141  .target = i,
1142  .size = 0,
1143  };
1144 
1145  return rs;
1146 }
1147 
1148 
1159 static int
1161  struct GNUNET_BIO_ReadHandle *h,
1162  const char *what,
1163  void *target,
1164  size_t target_size)
1165 {
1166  int64_t *result = target;
1167  return GNUNET_BIO_read_int64 (h, what, result);
1168 }
1169 
1170 
1178 struct GNUNET_BIO_ReadSpec
1180  int64_t *i)
1181 {
1182  struct GNUNET_BIO_ReadSpec rs = {
1184  .cls = NULL,
1185  .target = i,
1186  .size = 0,
1187  };
1188 
1189  return rs;
1190 }
1191 
1192 
1199 struct GNUNET_BIO_ReadSpec
1200 GNUNET_BIO_read_spec_float (const char *what, float *f)
1201 {
1202  struct GNUNET_BIO_ReadSpec rs = {
1204  .cls = NULL,
1205  .target = (int32_t *) f,
1206  .size = 0,
1207  };
1208 
1209  return rs;
1210 }
1211 
1212 
1219 struct GNUNET_BIO_ReadSpec
1220 GNUNET_BIO_read_spec_double (const char *what, double *f)
1221 {
1222  struct GNUNET_BIO_ReadSpec rs = {
1224  .cls = NULL,
1225  .target = (int64_t *) f,
1226  .size = 0,
1227  };
1228 
1229  return rs;
1230 }
1231 
1232 
1241 int
1243  struct GNUNET_BIO_ReadSpec *rs)
1244 {
1245  int ret = GNUNET_OK;
1246 
1247  for (size_t i = 0; NULL!=rs[i].rh; ++i)
1248  {
1249  ret = rs[i].rh (rs[i].cls, h, rs[i].what, rs[i].target, rs[i].size);
1250  if (GNUNET_OK != ret)
1251  return ret;
1252  }
1253 
1254  return ret;
1255 }
1256 
1257 
1268 static int
1270  struct GNUNET_BIO_WriteHandle *h,
1271  const char *what,
1272  void *source,
1273  size_t source_size)
1274 {
1275  return GNUNET_BIO_write (h, what, source, source_size);
1276 }
1277 
1278 
1287 struct GNUNET_BIO_WriteSpec
1289  void *source,
1290  size_t size)
1291 {
1292  struct GNUNET_BIO_WriteSpec ws = {
1294  .cls = NULL,
1295  .what = what,
1296  .source = source,
1297  .source_size = size,
1298  };
1299 
1300  return ws;
1301 }
1302 
1303 
1315 static int
1317  struct GNUNET_BIO_WriteHandle *h,
1318  const char *what,
1319  void *source,
1320  size_t source_size)
1321 {
1322  const char *s = source;
1323  return GNUNET_BIO_write_string (h, what, s);
1324 }
1325 
1326 
1334 struct GNUNET_BIO_WriteSpec
1336  const char *s)
1337 {
1338  struct GNUNET_BIO_WriteSpec ws = {
1340  .cls = NULL,
1341  .what = what,
1342  .source = (void *) s,
1343  .source_size = 0,
1344  };
1345 
1346  return ws;
1347 }
1348 
1349 
1361 static int
1363  struct GNUNET_BIO_WriteHandle *h,
1364  const char *what,
1365  void *source,
1366  size_t source_size)
1367 {
1368  const struct GNUNET_CONTAINER_MetaData *m = source;
1369  return GNUNET_BIO_write_meta_data (h, what, m);
1370 }
1371 
1372 
1380 struct GNUNET_BIO_WriteSpec
1382  const struct GNUNET_CONTAINER_MetaData *m)
1383 {
1384  struct GNUNET_BIO_WriteSpec ws = {
1386  .cls = NULL,
1387  .what = what,
1388  .source = (void *) m,
1389  .source_size = 0,
1390  };
1391 
1392  return ws;
1393 }
1394 
1395 
1406 static int
1408  struct GNUNET_BIO_WriteHandle *h,
1409  const char *what,
1410  void *source,
1411  size_t source_size)
1412 {
1413  int32_t i = *(int32_t *) source;
1414  return GNUNET_BIO_write_int32 (h, what, i);
1415 }
1416 
1417 
1425 struct GNUNET_BIO_WriteSpec
1427  int32_t *i)
1428 {
1429  struct GNUNET_BIO_WriteSpec ws = {
1431  .cls = NULL,
1432  .what = what,
1433  .source = i,
1434  .source_size = 0,
1435  };
1436 
1437  return ws;
1438 }
1439 
1440 
1451 static int
1453  struct GNUNET_BIO_WriteHandle *h,
1454  const char *what,
1455  void *source,
1456  size_t source_size)
1457 {
1458  int64_t i = *(int64_t *) source;
1459  return GNUNET_BIO_write_int64 (h, what, i);
1460 }
1461 
1462 
1470 struct GNUNET_BIO_WriteSpec
1472  int64_t *i)
1473 {
1474  struct GNUNET_BIO_WriteSpec ws = {
1476  .cls = NULL,
1477  .what = what,
1478  .source = i,
1479  .source_size = 0,
1480  };
1481 
1482  return ws;
1483 }
1484 
1485 
1493 struct GNUNET_BIO_WriteSpec
1494 GNUNET_BIO_write_spec_float (const char *what, float *f)
1495 {
1496  struct GNUNET_BIO_WriteSpec ws = {
1498  .cls = NULL,
1499  .what = what,
1500  .source = (int32_t *) f,
1501  .source_size = 0,
1502  };
1503 
1504  return ws;
1505 }
1506 
1507 
1515 struct GNUNET_BIO_WriteSpec
1516 GNUNET_BIO_write_spec_double (const char *what, double *f)
1517 {
1518  struct GNUNET_BIO_WriteSpec ws = {
1520  .cls = NULL,
1521  .what = what,
1522  .source = (int64_t *) f,
1523  .source_size = 0,
1524  };
1525 
1526  return ws;
1527 }
1528 
1529 
1538 int
1540  struct GNUNET_BIO_WriteSpec *ws)
1541 {
1542  int ret = GNUNET_OK;
1543 
1544  for (size_t i = 0; NULL!=ws[i].wh; ++i)
1545  {
1546  ret = ws[i].wh (ws[i].cls, h, ws[i].what, ws[i].source, ws[i].source_size);
1547  if (GNUNET_OK != ret)
1548  return ret;
1549  }
1550 
1551  /* If it's a file-based handle, the flush makes sure that the data in the
1552  buffer is actualy written to the disk. */
1553  if (IO_FILE == h->type)
1554  ret = GNUNET_BIO_flush (h);
1555 
1556  return ret;
1557 }
1558 
1559 
1560 /* end of bio.c */
void * cls
Closure for rh.
int GNUNET_BIO_read_float(struct GNUNET_BIO_ReadHandle *h, const char *what, float *f)
Read a float.
Definition: bio.c:443
Structure specifying a writing operation on an IO handle.
Open the file for reading.
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_buffer(void)
Create a handle backed by an in-memory buffer.
Definition: bio.c:587
Create file if it doesn&#39;t exist.
int GNUNET_BIO_read_int32(struct GNUNET_BIO_ReadHandle *h, const char *what, int32_t *i)
Read an (u)int32_t.
Definition: bio.c:478
ssize_t GNUNET_CONTAINER_meta_data_serialize(const struct GNUNET_CONTAINER_MetaData *md, char **target, size_t max, enum GNUNET_CONTAINER_MetaDataSerializationOptions opt)
Serialize meta-data to target.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1280
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_object(const char *what, void *result, size_t len)
Create the specification to read a certain amount of bytes.
Definition: bio.c:997
IOType
Enum used internally to know how buffering is handled.
Definition: bio.c:56
If not enough space is available, it is acceptable to only serialize some of the metadata.
enum IOType type
The "backend" type.
Definition: bio.c:521
int GNUNET_BIO_write_double(struct GNUNET_BIO_WriteHandle *h, const char *what, double f)
Write a double.
Definition: bio.c:918
size_t source_size
Size of source.
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:732
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open_file(const char *fn)
Open a file for reading.
Definition: bio.c:119
int GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, const char *what, int64_t i)
Write an (u)int64_t.
Definition: bio.c:956
int GNUNET_BIO_flush(struct GNUNET_BIO_WriteHandle *h)
Force a file-based buffered writer to flush its buffer.
Definition: bio.c:655
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int write_to_file(struct GNUNET_BIO_WriteHandle *h, const char *what, const char *source, size_t len)
Function used internally to write the contents of a buffer into a file.
Definition: bio.c:718
struct GNUNET_DISK_FileHandle * fd
Handle to a file on disk, if type is IO_FILE.
Definition: bio.c:83
static int write_to_buffer(struct GNUNET_BIO_WriteHandle *h, const char *what, const char *source, size_t len)
Function used internally to write the contents of a buffer to another buffer.
Definition: bio.c:774
Nobody is allowed to do anything to the file.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
void GNUNET_buffer_write(struct GNUNET_Buffer *buf, const char *data, size_t len)
Write bytes to the buffer.
Definition: buffer.c:86
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
void * cls
Closure for rh.
#define MAX_META_DATA
Maximum size allowed for meta data written/read from disk.
Definition: bio.c:47
int GNUNET_BIO_read_spec_commit(struct GNUNET_BIO_ReadHandle *h, struct GNUNET_BIO_ReadSpec *rs)
Execute the read specifications in order.
Definition: bio.c:1242
static int read_from_file(struct GNUNET_BIO_ReadHandle *h, const char *what, char *result, size_t len)
Function used internally to read the contents of a file into a buffer.
Definition: bio.c:200
static int read_spec_handler_meta_data(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read a metadata container from within a read spec.
Definition: bio.c:1072
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open_buffer(void *buffer, size_t size)
Create a handle from an existing allocated buffer.
Definition: bio.c:144
#define BIO_BUFFER_SIZE
Size for I/O buffers.
Definition: bio.c:41
const char * what
What is being read (for error message creation)
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int64(const char *what, int64_t *i)
Create the specification to read an (u)int64_t.
Definition: bio.c:1179
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_object(const char *what, void *source, size_t size)
Create the specification to read some bytes.
Definition: bio.c:1288
struct GNUNET_DISK_FileHandle * fd
Handle to a file on disk, if type is IO_FILE.
Definition: bio.c:526
static int read_spec_handler_object(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read some bytes from within a read spec.
Definition: bio.c:978
void * buffer
I/O buffer.
Definition: bio.c:538
GNUNET_BIO_ReadHandler rh
Function performing data deserialization.
int GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open handle.
Definition: bio.c:166
size_t size
Total size of buffer.
Definition: bio.c:103
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int read_spec_handler_int64(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read an (u)int64_t from within a read spec.
Definition: bio.c:1160
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
int GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read some contents into a buffer.
Definition: bio.c:287
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_string(const char *what, const char *s)
Create the specification to write a 0-terminated string.
Definition: bio.c:1335
void * target
Destination buffer.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Meta data to associate with a file, directory or namespace.
static int read_from_buffer(struct GNUNET_BIO_ReadHandle *h, const char *what, char *result, size_t len)
Function used internally to read the content of a buffer into a buffer.
Definition: bio.c:258
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_meta_data(const char *what, struct GNUNET_CONTAINER_MetaData **result)
Create the specification to read a metadata container.
Definition: bio.c:1091
void * GNUNET_buffer_reap(struct GNUNET_Buffer *buf, size_t *size)
Clear the buffer and return its contents.
Definition: buffer.c:149
static char * fn
Filename of the unique file.
static int write_spec_handler_int32(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write an (u)int32_t from within a write spec.
Definition: bio.c:1407
Truncate file if it exists.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:820
static int write_spec_handler_meta_data(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write a metadata container from within a write spec.
Definition: bio.c:1362
static int read_spec_handler_string(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used interally to read a string from within a read spec.
Definition: bio.c:1024
The handle uses a file to read/write data.
Definition: bio.c:61
static char buf[2048]
size_t have
Number of bytes available in buffer.
Definition: bio.c:98
size_t have
Number of bytes available in buffer.
Definition: bio.c:543
static int result
Global testing status.
Structure specifying a reading operation on an IO handle.
int GNUNET_BIO_get_buffer_contents(struct GNUNET_BIO_WriteHandle *h, char **emsg, void **contents, size_t *size)
Get the IO handle&#39;s contents.
Definition: bio.c:689
Handle for buffered writing.
Definition: bio.c:516
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_double(const char *what, double *f)
Create the specification to write an double.
Definition: bio.c:1516
char * buffer
I/O buffer.
Definition: bio.c:93
off_t pos
Current read offset in buffer.
Definition: bio.c:108
static int write_spec_handler_string(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write a 0-terminated string from within a write spec. ...
Definition: bio.c:1316
int GNUNET_BIO_read_string(struct GNUNET_BIO_ReadHandle *h, const char *what, char **result, size_t max_length)
Read 0-terminated string.
Definition: bio.c:326
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_string(const char *what, char **result, size_t max_length)
Create the specification to read a 0-terminated string.
Definition: bio.c:1045
static GstElement * source
Appsrc instance into which we write data for the pipeline.
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_meta_data(const char *what, const struct GNUNET_CONTAINER_MetaData *m)
Create the specification to write a metadata container.
Definition: bio.c:1381
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:559
static int write_spec_handler_int64(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write an (u)int64_t from within a write spec.
Definition: bio.c:1452
Open the file for writing.
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:608
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_float(const char *what, float *f)
Create the specification to read a float.
Definition: bio.c:1200
enum IOType type
The "backend" type.
Definition: bio.c:78
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, const char *what, int32_t i)
Write an (u)int32_t.
Definition: bio.c:936
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int32(const char *what, int32_t *i)
Create the specification to read an (u)int32_t.
Definition: bio.c:1135
GNUNET_BIO_WriteHandler wh
Function performing data serialization.
The data is stored entirely in memory.
Definition: bio.c:66
char * emsg
Error message, NULL if there were no errors.
Definition: bio.c:531
int GNUNET_BIO_write_spec_commit(struct GNUNET_BIO_WriteHandle *h, struct GNUNET_BIO_WriteSpec *ws)
Execute the write specifications in order.
Definition: bio.c:1539
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int32(const char *what, int32_t *i)
Create the specification to write an (u)int32_t.
Definition: bio.c:1426
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *what, const char *s)
Write a 0-terminated string.
Definition: bio.c:832
int GNUNET_BIO_write_meta_data(struct GNUNET_BIO_WriteHandle *h, const char *what, const struct GNUNET_CONTAINER_MetaData *m)
Write a metadata container.
Definition: bio.c:856
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_float(const char *what, float *f)
Create the specification to write a float.
Definition: bio.c:1494
int GNUNET_BIO_read_double(struct GNUNET_BIO_ReadHandle *h, const char *what, double *f)
Read a double.
Definition: bio.c:460
void GNUNET_buffer_clear(struct GNUNET_Buffer *buf)
Free the backing memory of the given buffer.
Definition: buffer.c:164
size_t size
Total size of buffer.
Definition: bio.c:548
static int read_spec_handler_int32(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read an (u)int32_t from within a read spec.
Definition: bio.c:1116
int GNUNET_BIO_read_meta_data(struct GNUNET_BIO_ReadHandle *h, const char *what, struct GNUNET_CONTAINER_MetaData **result)
Read a metadata container.
Definition: bio.c:389
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int64(const char *what, int64_t *i)
Create the specification to write an (u)int64_t.
Definition: bio.c:1471
Common buffer management functions.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1203
const char * what
What is being read (for error message creation)
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const char *what, const void *buffer, size_t n)
Write a buffer to a handle.
Definition: bio.c:795
char * emsg
Error message, NULL if there were no errors.
Definition: bio.c:88
Handle used to access files (and pipes).
int GNUNET_BIO_read_int64(struct GNUNET_BIO_ReadHandle *h, const char *what, int64_t *i)
Read an (u)int64_t.
Definition: bio.c:500
#define GNUNET_malloc(size)
Wrapper around malloc.
Handle for buffered reading.
Definition: bio.c:73
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
#define GNUNET_free(ptr)
Wrapper around free.
static int write_spec_handler_object(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write some bytes from within a write spec.
Definition: bio.c:1269
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
int GNUNET_BIO_write_float(struct GNUNET_BIO_WriteHandle *h, const char *what, float f)
Write a float.
Definition: bio.c:901
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_double(const char *what, double *f)
Create the specification to read a double.
Definition: bio.c:1220