GNUnet  0.11.x
strings.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2005-2017 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  */
27 #include "platform.h"
28 #if HAVE_ICONV
29 #include <iconv.h>
30 #endif
31 #include "gnunet_crypto_lib.h"
32 #include "gnunet_strings_lib.h"
33 #include <unicase.h>
34 #include <unistr.h>
35 #include <uniconv.h>
36 
37 #define LOG(kind, ...) GNUNET_log_from (kind, "util-strings", __VA_ARGS__)
38 
39 #define LOG_STRERROR(kind, syscall) \
40  GNUNET_log_from_strerror (kind, "util-strings", syscall)
41 
42 
64 size_t
65 GNUNET_STRINGS_buffer_fill (char *buffer, size_t size, unsigned int count, ...)
66 {
67  size_t needed;
68  size_t slen;
69  const char *s;
70  va_list ap;
71 
72  needed = 0;
73  va_start (ap, count);
74  while (count > 0)
75  {
76  s = va_arg (ap, const char *);
77 
78  slen = strlen (s) + 1;
79  if (buffer != NULL)
80  {
81  GNUNET_assert (needed + slen <= size);
82  GNUNET_memcpy (&buffer[needed], s, slen);
83  }
84  needed += slen;
85  count--;
86  }
87  va_end (ap);
88  return needed;
89 }
90 
91 
99 char *
101  unsigned int num_pids)
102 {
103  char *buf;
104  size_t off;
105  size_t plen = num_pids * 5 + 1;
106 
107  off = 0;
108  buf = GNUNET_malloc (plen);
109  for (unsigned int i = 0; i < num_pids; i++)
110  {
111  off += GNUNET_snprintf (&buf[off],
112  plen - off,
113  "%s%s",
114  GNUNET_i2s (&pids[i]),
115  (i == num_pids - 1) ? "" : "-");
116  }
117  return buf;
118 }
119 
120 
134 unsigned int
135 GNUNET_STRINGS_buffer_tokenize (const char *buffer,
136  size_t size,
137  unsigned int count,
138  ...)
139 {
140  unsigned int start;
141  unsigned int needed;
142  const char **r;
143  va_list ap;
144 
145  needed = 0;
146  va_start (ap, count);
147  while (count > 0)
148  {
149  r = va_arg (ap, const char **);
150 
151  start = needed;
152  while ((needed < size) && (buffer[needed] != '\0'))
153  needed++;
154  if (needed == size)
155  {
156  va_end (ap);
157  return 0; /* error */
158  }
159  *r = &buffer[start];
160  needed++; /* skip 0-termination */
161  count--;
162  }
163  va_end (ap);
164  return needed;
165 }
166 
167 
174 char *
176 {
177  const char *unit = _ (/* size unit */ "b");
178  char *ret;
179 
180  if (size > 5 * 1024)
181  {
182  size = size / 1024;
183  unit = "KiB";
184  if (size > 5 * 1024)
185  {
186  size = size / 1024;
187  unit = "MiB";
188  if (size > 5 * 1024)
189  {
190  size = size / 1024;
191  unit = "GiB";
192  if (size > 5 * 1024)
193  {
194  size = size / 1024;
195  unit = "TiB";
196  }
197  }
198  }
199  }
200  ret = GNUNET_malloc (32);
201  GNUNET_snprintf (ret, 32, "%llu %s", size, unit);
202  return ret;
203 }
204 
205 
218 size_t
219 GNUNET_strlcpy (char *dst, const char *src, size_t n)
220 {
221  size_t slen;
222 
223  GNUNET_assert (0 != n);
224  slen = strnlen (src, n - 1);
225  memcpy (dst, src, slen);
226  dst[slen] = '\0';
227  return slen;
228 }
229 
230 
235 {
239  const char *name;
240 
244  unsigned long long value;
245 };
246 
247 
259 static int
260 convert_with_table (const char *input,
261  const struct ConversionTable *table,
262  unsigned long long *output)
263 {
264  unsigned long long ret;
265  char *in;
266  const char *tok;
267  unsigned long long last;
268  unsigned int i;
269 
270  ret = 0;
271  last = 0;
272  in = GNUNET_strdup (input);
273  for (tok = strtok (in, " "); tok != NULL; tok = strtok (NULL, " "))
274  {
275  do
276  {
277  i = 0;
278  while ((table[i].name != NULL) && (0 != strcasecmp (table[i].name, tok)))
279  i++;
280  if (table[i].name != NULL)
281  {
282  last *= table[i].value;
283  break; /* next tok */
284  }
285  else
286  {
287  char *endptr;
288  ret += last;
289  errno = 0;
290  last = strtoull (tok, &endptr, 10);
291  if ((0 != errno) || (endptr == tok))
292  {
293  GNUNET_free (in);
294  return GNUNET_SYSERR; /* expected number */
295  }
296  if ('\0' == endptr[0])
297  break; /* next tok */
298  else
299  tok = endptr; /* and re-check (handles times like "10s") */
300  }
301  }
302  while (GNUNET_YES);
303  }
304  ret += last;
305  *output = ret;
306  GNUNET_free (in);
307  return GNUNET_OK;
308 }
309 
310 
318 int
319 GNUNET_STRINGS_fancy_size_to_bytes (const char *fancy_size,
320  unsigned long long *size)
321 {
322  static const struct ConversionTable table[] =
323  { { "B", 1 },
324  { "KiB", 1024 },
325  { "kB", 1000 },
326  { "MiB", 1024 * 1024 },
327  { "MB", 1000 * 1000 },
328  { "GiB", 1024 * 1024 * 1024 },
329  { "GB", 1000 * 1000 * 1000 },
330  { "TiB", 1024LL * 1024LL * 1024LL * 1024LL },
331  { "TB", 1000LL * 1000LL * 1000LL * 1024LL },
332  { "PiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
333  { "PB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL },
334  { "EiB", 1024LL * 1024LL * 1024LL * 1024LL * 1024LL * 1024LL },
335  { "EB", 1000LL * 1000LL * 1000LL * 1024LL * 1000LL * 1000LL },
336  { NULL, 0 } };
337 
338  return convert_with_table (fancy_size, table, size);
339 }
340 
341 
350 int
352  struct GNUNET_TIME_Relative *rtime)
353 {
354  static const struct ConversionTable table[] =
355  { { "us", 1 },
356  { "ms", 1000 },
357  { "s", 1000 * 1000LL },
358  { "second", 1000 * 1000LL },
359  { "seconds", 1000 * 1000LL },
360  { "\"", 1000 * 1000LL },
361  { "m", 60 * 1000 * 1000LL },
362  { "min", 60 * 1000 * 1000LL },
363  { "minute", 60 * 1000 * 1000LL },
364  { "minutes", 60 * 1000 * 1000LL },
365  { "'", 60 * 1000 * 1000LL },
366  { "h", 60 * 60 * 1000 * 1000LL },
367  { "hour", 60 * 60 * 1000 * 1000LL },
368  { "hours", 60 * 60 * 1000 * 1000LL },
369  { "d", 24 * 60 * 60 * 1000LL * 1000LL },
370  { "day", 24 * 60 * 60 * 1000LL * 1000LL },
371  { "days", 24 * 60 * 60 * 1000LL * 1000LL },
372  { "week", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
373  { "weeks", 7 * 24 * 60 * 60 * 1000LL * 1000LL },
374  { "year", 31536000000000LL /* year */ },
375  { "years", 31536000000000LL /* year */ },
376  { "a", 31536000000000LL /* year */ },
377  { NULL, 0 } };
378  int ret;
379  unsigned long long val;
380 
381  if (0 == strcasecmp ("forever", fancy_time))
382  {
384  return GNUNET_OK;
385  }
386  ret = convert_with_table (fancy_time, table, &val);
387  rtime->rel_value_us = (uint64_t) val;
388  return ret;
389 }
390 
391 
401 int
403  struct GNUNET_TIME_Absolute *atime)
404 {
405  struct tm tv;
406  time_t t;
407  const char *eos;
408 
409  if (0 == strcasecmp ("end of time", fancy_time))
410  {
412  return GNUNET_OK;
413  }
414  eos = &fancy_time[strlen (fancy_time)];
415  memset (&tv, 0, sizeof(tv));
416  if ((eos != strptime (fancy_time, "%a %b %d %H:%M:%S %Y", &tv)) &&
417  (eos != strptime (fancy_time, "%c", &tv)) &&
418  (eos != strptime (fancy_time, "%Ec", &tv)) &&
419  (eos != strptime (fancy_time, "%Y-%m-%d %H:%M:%S", &tv)) &&
420  (eos != strptime (fancy_time, "%Y-%m-%d %H:%M", &tv)) &&
421  (eos != strptime (fancy_time, "%x", &tv)) &&
422  (eos != strptime (fancy_time, "%Ex", &tv)) &&
423  (eos != strptime (fancy_time, "%Y-%m-%d", &tv)) &&
424  (eos != strptime (fancy_time, "%Y-%m", &tv)) &&
425  (eos != strptime (fancy_time, "%Y", &tv)))
426  return GNUNET_SYSERR;
427  t = mktime (&tv);
428  atime->abs_value_us = (uint64_t) ((uint64_t) t * 1000LL * 1000LL);
429  return GNUNET_OK;
430 }
431 
432 
446 char *
447 GNUNET_STRINGS_conv (const char *input,
448  size_t len,
449  const char *input_charset,
450  const char *output_charset)
451 {
452  char *ret;
453  uint8_t *u8_string;
454  char *encoded_string;
455  size_t u8_string_length;
456  size_t encoded_string_length;
457 
458  u8_string = u8_conv_from_encoding (input_charset,
459  iconveh_error,
460  input,
461  len,
462  NULL,
463  NULL,
464  &u8_string_length);
465  if (NULL == u8_string)
466  {
467  LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_from_encoding");
468  goto fail;
469  }
470  if (0 == strcmp (output_charset, "UTF-8"))
471  {
472  ret = GNUNET_malloc (u8_string_length + 1);
473  GNUNET_memcpy (ret, u8_string, u8_string_length);
474  ret[u8_string_length] = '\0';
475  free (u8_string);
476  return ret;
477  }
478  encoded_string = u8_conv_to_encoding (output_charset,
479  iconveh_error,
480  u8_string,
481  u8_string_length,
482  NULL,
483  NULL,
484  &encoded_string_length);
485  free (u8_string);
486  if (NULL == encoded_string)
487  {
488  LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "u8_conv_to_encoding");
489  goto fail;
490  }
491  ret = GNUNET_malloc (encoded_string_length + 1);
492  GNUNET_memcpy (ret, encoded_string, encoded_string_length);
493  ret[encoded_string_length] = '\0';
494  free (encoded_string);
495  return ret;
496 fail:
498  _ ("Character sets requested were `%s'->`%s'\n"),
499  "UTF-8",
500  output_charset);
501  ret = GNUNET_malloc (len + 1);
502  GNUNET_memcpy (ret, input, len);
503  ret[len] = '\0';
504  return ret;
505 }
506 
507 
520 char *
521 GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset)
522 {
523  return GNUNET_STRINGS_conv (input, len, charset, "UTF-8");
524 }
525 
526 
538 char *
539 GNUNET_STRINGS_from_utf8 (const char *input, size_t len, const char *charset)
540 {
541  return GNUNET_STRINGS_conv (input, len, "UTF-8", charset);
542 }
543 
544 
552 void
553 GNUNET_STRINGS_utf8_tolower (const char *input, char *output)
554 {
555  uint8_t *tmp_in;
556  size_t len;
557 
558  tmp_in = u8_tolower ((uint8_t *) input,
559  strlen ((char *) input),
560  NULL,
561  UNINORM_NFD,
562  NULL,
563  &len);
564  GNUNET_memcpy (output, tmp_in, len);
565  output[len] = '\0';
566  free (tmp_in);
567 }
568 
569 
577 void
578 GNUNET_STRINGS_utf8_toupper (const char *input, char *output)
579 {
580  uint8_t *tmp_in;
581  size_t len;
582 
583  tmp_in = u8_toupper ((uint8_t *) input,
584  strlen ((char *) input),
585  NULL,
586  UNINORM_NFD,
587  NULL,
588  &len);
589  GNUNET_memcpy (output, tmp_in, len);
590  output[len] = '\0';
591  free (tmp_in);
592 }
593 
594 
602 char *
604 {
605  char *buffer;
606  size_t len;
607  char *fm;
608  const char *fil_ptr;
609 
610  if (fil == NULL)
611  return NULL;
612 
613  if (fil[0] == DIR_SEPARATOR)
614  /* absolute path, just copy */
615  return GNUNET_strdup (fil);
616  if (fil[0] == '~')
617  {
618  fm = getenv ("HOME");
619  if (fm == NULL)
620  {
622  _ ("Failed to expand `$HOME': environment variable `HOME' not set"));
623  return NULL;
624  }
625  fm = GNUNET_strdup (fm);
626  /* do not copy '~' */
627  fil_ptr = fil + 1;
628 
629  /* skip over dir seperator to be consistent */
630  if (fil_ptr[0] == DIR_SEPARATOR)
631  fil_ptr++;
632  }
633  else
634  {
635  /* relative path */
636  fil_ptr = fil;
637  len = 512;
638  fm = NULL;
639  while (1)
640  {
641  buffer = GNUNET_malloc (len);
642  if (getcwd (buffer, len) != NULL)
643  {
644  fm = buffer;
645  break;
646  }
647  if ((errno == ERANGE) && (len < 1024 * 1024 * 4))
648  {
649  len *= 2;
650  GNUNET_free (buffer);
651  continue;
652  }
653  GNUNET_free (buffer);
654  break;
655  }
656  if (fm == NULL)
657  {
659  buffer = getenv ("PWD"); /* alternative */
660  if (buffer != NULL)
661  fm = GNUNET_strdup (buffer);
662  }
663  if (fm == NULL)
664  fm = GNUNET_strdup ("./"); /* give up */
665  }
666  GNUNET_asprintf (&buffer,
667  "%s%s%s",
668  fm,
669  (fm[strlen (fm) - 1] == DIR_SEPARATOR) ? ""
671  fil_ptr);
672  GNUNET_free (fm);
673  return buffer;
674 }
675 
676 
686 const char *
688  int do_round)
689 {
690  static char buf[128];
691  const char *unit = _ (/* time unit */ "┬Ás");
692  uint64_t dval = delta.rel_value_us;
693 
694  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == delta.rel_value_us)
695  return _ ("forever");
696  if (0 == delta.rel_value_us)
697  return _ ("0 ms");
698  if (((GNUNET_YES == do_round) && (dval > 5 * 1000)) || (0 == (dval % 1000)))
699  {
700  dval = dval / 1000;
701  unit = _ (/* time unit */ "ms");
702  if (((GNUNET_YES == do_round) && (dval > 5 * 1000)) || (0 == (dval % 1000)))
703  {
704  dval = dval / 1000;
705  unit = _ (/* time unit */ "s");
706  if (((GNUNET_YES == do_round) && (dval > 5 * 60)) || (0 == (dval % 60)))
707  {
708  dval = dval / 60;
709  unit = _ (/* time unit */ "m");
710  if (((GNUNET_YES == do_round) && (dval > 5 * 60)) || (0 == (dval % 60)))
711  {
712  dval = dval / 60;
713  unit = _ (/* time unit */ "h");
714  if (((GNUNET_YES == do_round) && (dval > 5 * 24)) ||
715  (0 == (dval % 24)))
716  {
717  dval = dval / 24;
718  if (1 == dval)
719  unit = _ (/* time unit */ "day");
720  else
721  unit = _ (/* time unit */ "days");
722  }
723  }
724  }
725  }
726  }
727  GNUNET_snprintf (buf, sizeof(buf), "%llu %s", dval, unit);
728  return buf;
729 }
730 
731 
741 const char *
743 {
744  static char buf[255];
745  time_t tt;
746  struct tm *tp;
747 
748  if (t.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
749  return _ ("end of time");
750  tt = t.abs_value_us / 1000LL / 1000LL;
751  tp = localtime (&tt);
752  /* This is hacky, but i don't know a way to detect libc character encoding.
753  * Just expect utf8 from glibc these days.
754  * As for msvcrt, use the wide variant, which always returns utf16
755  * (otherwise we'd have to detect current codepage or use W32API character
756  * set conversion routines to convert to UTF8).
757  */strftime (buf, sizeof(buf), "%a %b %d %H:%M:%S %Y", tp);
758 
759  return buf;
760 }
761 
762 
774 const char *
776 {
777  const char *short_fn = filename;
778  const char *ss;
779 
780  while (NULL != (ss = strstr (short_fn, DIR_SEPARATOR_STR)) && (ss[1] != '\0'))
781  short_fn = 1 + ss;
782  return short_fn;
783 }
784 
785 
793 static unsigned int
794 getValue__ (unsigned char a)
795 {
796  unsigned int dec;
797 
798  switch (a)
799  {
800  case 'O':
801  case 'o':
802  a = '0';
803  break;
804 
805  case 'i':
806  case 'I':
807  case 'l':
808  case 'L':
809  a = '1';
810  break;
811 
812  /* also consider U to be V */
813  case 'u':
814  case 'U':
815  a = 'V';
816  break;
817 
818  default:
819  break;
820  }
821  if ((a >= '0') && (a <= '9'))
822  return a - '0';
823  if ((a >= 'a') && (a <= 'z'))
824  a = toupper (a);
825  /* return (a - 'a' + 10); */
826  dec = 0;
827  if ((a >= 'A') && (a <= 'Z'))
828  {
829  if ('I' < a)
830  dec++;
831  if ('L' < a)
832  dec++;
833  if ('O' < a)
834  dec++;
835  if ('U' < a)
836  dec++;
837  return(a - 'A' + 10 - dec);
838  }
839  return -1;
840 }
841 
842 
855 char *
857  size_t size,
858  char *out,
859  size_t out_size)
860 {
864  static char *encTable__ = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
865  unsigned int wpos;
866  unsigned int rpos;
867  unsigned int bits;
868  unsigned int vbit;
869  const unsigned char *udata;
870 
871  udata = data;
872  if (out_size < (size * 8 + 4) / 5)
873  {
874  GNUNET_break (0);
875  return NULL;
876  }
877  vbit = 0;
878  wpos = 0;
879  rpos = 0;
880  bits = 0;
881  while ((rpos < size) || (vbit > 0))
882  {
883  if ((rpos < size) && (vbit < 5))
884  {
885  bits = (bits << 8) | udata[rpos++]; /* eat 8 more bits */
886  vbit += 8;
887  }
888  if (vbit < 5)
889  {
890  bits <<= (5 - vbit); /* zero-padding */
891  GNUNET_assert (vbit == ((size * 8) % 5));
892  vbit = 5;
893  }
894  if (wpos >= out_size)
895  {
896  GNUNET_break (0);
897  return NULL;
898  }
899  out[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
900  vbit -= 5;
901  }
902  GNUNET_assert (0 == vbit);
903  if (wpos < out_size)
904  out[wpos] = '\0';
905  return &out[wpos];
906 }
907 
908 
919 char *
921 {
922  char *str_buf;
923  size_t len = size * 8;
924  char *end;
925 
926  if (len % 5 > 0)
927  len += 5 - len % 5;
928  len /= 5;
929  str_buf = GNUNET_malloc (len + 1);
930  end = GNUNET_STRINGS_data_to_string (buf, size, str_buf, len);
931  if (NULL == end)
932  {
933  GNUNET_free (str_buf);
934  return NULL;
935  }
936  *end = '\0';
937  return str_buf;
938 }
939 
940 
951 int
953  size_t enclen,
954  void *out,
955  size_t out_size)
956 {
957  unsigned int rpos;
958  unsigned int wpos;
959  unsigned int bits;
960  unsigned int vbit;
961  int ret;
962  int shift;
963  unsigned char *uout;
964  unsigned int encoded_len = out_size * 8;
965 
966  if (0 == enclen)
967  {
968  if (0 == out_size)
969  return GNUNET_OK;
970  return GNUNET_SYSERR;
971  }
972  uout = out;
973  wpos = out_size;
974  rpos = enclen;
975  if ((encoded_len % 5) > 0)
976  {
977  vbit = encoded_len % 5; /* padding! */
978  shift = 5 - vbit;
979  bits = (ret = getValue__ (enc[--rpos])) >> shift;
980  }
981  else
982  {
983  vbit = 5;
984  shift = 0;
985  bits = (ret = getValue__ (enc[--rpos]));
986  }
987  if ((encoded_len + shift) / 5 != enclen)
988  return GNUNET_SYSERR;
989  if (-1 == ret)
990  return GNUNET_SYSERR;
991  while (wpos > 0)
992  {
993  if (0 == rpos)
994  {
995  GNUNET_break (0);
996  return GNUNET_SYSERR;
997  }
998  bits = ((ret = getValue__ (enc[--rpos])) << vbit) | bits;
999  if (-1 == ret)
1000  return GNUNET_SYSERR;
1001  vbit += 5;
1002  if (vbit >= 8)
1003  {
1004  uout[--wpos] = (unsigned char) bits;
1005  bits >>= 8;
1006  vbit -= 8;
1007  }
1008  }
1009  if ((0 != rpos) || (0 != vbit))
1010  return GNUNET_SYSERR;
1011  return GNUNET_OK;
1012 }
1013 
1014 
1031 int
1032 GNUNET_STRINGS_parse_uri (const char *path,
1033  char **scheme_part,
1034  const char **path_part)
1035 {
1036  size_t len;
1037  size_t i;
1038  int end;
1039  int pp_state = 0;
1040  const char *post_scheme_part = NULL;
1041 
1042  len = strlen (path);
1043  for (end = 0, i = 0; ! end && i < len; i++)
1044  {
1045  switch (pp_state)
1046  {
1047  case 0:
1048  if ((path[i] == ':') && (i > 0))
1049  {
1050  pp_state += 1;
1051  continue;
1052  }
1053  if (! (((path[i] >= 'A') && (path[i] <= 'Z') ) ||
1054  ((path[i] >= 'a') && (path[i] <= 'z') ) ||
1055  ((path[i] >= '0') && (path[i] <= '9') ) || (path[i] == '+') ||
1056  (path[i] == '-') || (path[i] == '.')))
1057  end = 1;
1058  break;
1059 
1060  case 1:
1061  case 2:
1062  if (path[i] == '/')
1063  {
1064  pp_state += 1;
1065  continue;
1066  }
1067  end = 1;
1068  break;
1069 
1070  case 3:
1071  post_scheme_part = &path[i];
1072  end = 1;
1073  break;
1074 
1075  default:
1076  end = 1;
1077  }
1078  }
1079  if (post_scheme_part == NULL)
1080  return GNUNET_NO;
1081  if (scheme_part)
1082  {
1083  *scheme_part = GNUNET_malloc (post_scheme_part - path + 1);
1084  GNUNET_memcpy (*scheme_part, path, post_scheme_part - path);
1085  (*scheme_part)[post_scheme_part - path] = '\0';
1086  }
1087  if (path_part)
1088  *path_part = post_scheme_part;
1089  return GNUNET_YES;
1090 }
1091 
1092 
1107 int
1109  int can_be_uri,
1110  int *r_is_uri,
1111  char **r_uri_scheme)
1112 {
1113  const char *post_scheme_path;
1114  int is_uri;
1115  char *uri;
1116  /* consider POSIX paths to be absolute too, even on W32,
1117  * as plibc expansion will fix them for us.
1118  */
1119  if (filename[0] == '/')
1120  return GNUNET_YES;
1121  if (can_be_uri)
1122  {
1123  is_uri = GNUNET_STRINGS_parse_uri (filename, &uri, &post_scheme_path);
1124  if (r_is_uri)
1125  *r_is_uri = is_uri;
1126  if (is_uri)
1127  {
1128  if (r_uri_scheme)
1129  *r_uri_scheme = uri;
1130  else
1131  GNUNET_free_non_null (uri);
1132 
1133  return GNUNET_STRINGS_path_is_absolute (post_scheme_path,
1134  GNUNET_NO,
1135  NULL,
1136  NULL);
1137  }
1138  }
1139  else
1140  {
1141  if (r_is_uri)
1142  *r_is_uri = GNUNET_NO;
1143  }
1144 
1145  return GNUNET_NO;
1146 }
1147 
1148 
1157 int
1159  enum GNUNET_STRINGS_FilenameCheck checks)
1160 {
1161  struct stat st;
1162 
1163  if ((NULL == filename) || (filename[0] == '\0'))
1164  return GNUNET_SYSERR;
1165  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_ABSOLUTE))
1166  if (! GNUNET_STRINGS_path_is_absolute (filename, GNUNET_NO, NULL, NULL))
1167  return GNUNET_NO;
1168  if (0 != (checks
1171  {
1172  if (0 != stat (filename, &st))
1173  {
1174  if (0 != (checks & GNUNET_STRINGS_CHECK_EXISTS))
1175  return GNUNET_NO;
1176  else
1177  return GNUNET_SYSERR;
1178  }
1179  }
1180  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_DIRECTORY))
1181  if (! S_ISDIR (st.st_mode))
1182  return GNUNET_NO;
1183  if (0 != (checks & GNUNET_STRINGS_CHECK_IS_LINK))
1184  if (! S_ISLNK (st.st_mode))
1185  return GNUNET_NO;
1186  return GNUNET_YES;
1187 }
1188 
1189 
1202 int
1203 GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr,
1204  uint16_t addrlen,
1205  struct sockaddr_in6 *r_buf)
1206 {
1207  char zbuf[addrlen + 1];
1208  int ret;
1209  char *port_colon;
1210  unsigned int port;
1211  char dummy[2];
1212 
1213  if (addrlen < 6)
1214  return GNUNET_SYSERR;
1215  GNUNET_memcpy (zbuf, zt_addr, addrlen);
1216  if ('[' != zbuf[0])
1217  {
1219  _ ("IPv6 address did not start with `['\n"));
1220  return GNUNET_SYSERR;
1221  }
1222  zbuf[addrlen] = '\0';
1223  port_colon = strrchr (zbuf, ':');
1224  if (NULL == port_colon)
1225  {
1227  _ ("IPv6 address did contain ':' to separate port number\n"));
1228  return GNUNET_SYSERR;
1229  }
1230  if (']' != *(port_colon - 1))
1231  {
1232  GNUNET_log (
1234  _ ("IPv6 address did contain ']' before ':' to separate port number\n"));
1235  return GNUNET_SYSERR;
1236  }
1237  ret = sscanf (port_colon, ":%u%1s", &port, dummy);
1238  if ((1 != ret) || (port > 65535))
1239  {
1240  GNUNET_log (
1242  _ ("IPv6 address did contain a valid port number after the last ':'\n"));
1243  return GNUNET_SYSERR;
1244  }
1245  *(port_colon - 1) = '\0';
1246  memset (r_buf, 0, sizeof(struct sockaddr_in6));
1247  ret = inet_pton (AF_INET6, &zbuf[1], &r_buf->sin6_addr);
1248  if (ret <= 0)
1249  {
1251  _ ("Invalid IPv6 address `%s': %s\n"),
1252  &zbuf[1],
1253  strerror (errno));
1254  return GNUNET_SYSERR;
1255  }
1256  r_buf->sin6_port = htons (port);
1257  r_buf->sin6_family = AF_INET6;
1258 #if HAVE_SOCKADDR_IN_SIN_LEN
1259  r_buf->sin6_len = (u_char) sizeof(struct sockaddr_in6);
1260 #endif
1261  return GNUNET_OK;
1262 }
1263 
1264 
1276 int
1277 GNUNET_STRINGS_to_address_ipv4 (const char *zt_addr,
1278  uint16_t addrlen,
1279  struct sockaddr_in *r_buf)
1280 {
1281  unsigned int temps[4];
1282  unsigned int port;
1283  unsigned int cnt;
1284  char dummy[2];
1285 
1286  if (addrlen < 9)
1287  return GNUNET_SYSERR;
1288  cnt = sscanf (zt_addr,
1289  "%u.%u.%u.%u:%u%1s",
1290  &temps[0],
1291  &temps[1],
1292  &temps[2],
1293  &temps[3],
1294  &port,
1295  dummy);
1296  if (5 != cnt)
1297  return GNUNET_SYSERR;
1298  for (cnt = 0; cnt < 4; cnt++)
1299  if (temps[cnt] > 0xFF)
1300  return GNUNET_SYSERR;
1301  if (port > 65535)
1302  return GNUNET_SYSERR;
1303  r_buf->sin_family = AF_INET;
1304  r_buf->sin_port = htons (port);
1305  r_buf->sin_addr.s_addr =
1306  htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) + temps[3]);
1307 #if HAVE_SOCKADDR_IN_SIN_LEN
1308  r_buf->sin_len = (u_char) sizeof(struct sockaddr_in);
1309 #endif
1310  return GNUNET_OK;
1311 }
1312 
1313 
1325 int
1327  uint16_t addrlen,
1328  struct sockaddr_storage *r_buf)
1329 {
1330  if (addr[0] == '[')
1331  return GNUNET_STRINGS_to_address_ipv6 (addr,
1332  addrlen,
1333  (struct sockaddr_in6 *) r_buf);
1334  return GNUNET_STRINGS_to_address_ipv4 (addr,
1335  addrlen,
1336  (struct sockaddr_in *) r_buf);
1337 }
1338 
1339 
1349 size_t
1351  uint8_t *af,
1352  struct sockaddr **sa)
1353 {
1354  char *cp = GNUNET_strdup (addr);
1355 
1356  *af = AF_UNSPEC;
1357  if ('[' == *addr)
1358  {
1359  /* IPv6 */
1360  *sa = GNUNET_malloc (sizeof(struct sockaddr_in6));
1361  if (GNUNET_OK !=
1363  strlen (cp),
1364  (struct sockaddr_in6 *) *sa))
1365  {
1366  GNUNET_free (*sa);
1367  *sa = NULL;
1368  GNUNET_free (cp);
1369  return 0;
1370  }
1371  *af = AF_INET6;
1372  GNUNET_free (cp);
1373  return sizeof(struct sockaddr_in6);
1374  }
1375  else
1376  {
1377  /* IPv4 */
1378  *sa = GNUNET_malloc (sizeof(struct sockaddr_in));
1379  if (GNUNET_OK !=
1381  strlen (cp),
1382  (struct sockaddr_in *) *sa))
1383  {
1384  GNUNET_free (*sa);
1385  *sa = NULL;
1386  GNUNET_free (cp);
1387  return 0;
1388  }
1389  *af = AF_INET;
1390  GNUNET_free (cp);
1391  return sizeof(struct sockaddr_in);
1392  }
1393 }
1394 
1395 
1400 static char *const *
1401 _make_continuous_arg_copy (int argc, char *const *argv)
1402 {
1403  size_t argvsize = 0;
1404  int i;
1405  char **new_argv;
1406  char *p;
1407 
1408  for (i = 0; i < argc; i++)
1409  argvsize += strlen (argv[i]) + 1 + sizeof(char *);
1410  new_argv = GNUNET_malloc (argvsize + sizeof(char *));
1411  p = (char *) &new_argv[argc + 1];
1412  for (i = 0; i < argc; i++)
1413  {
1414  new_argv[i] = p;
1415  strcpy (p, argv[i]);
1416  p += strlen (argv[i]) + 1;
1417  }
1418  new_argv[argc] = NULL;
1419  return (char *const *) new_argv;
1420 }
1421 
1422 
1437 int
1439  char *const *argv,
1440  int *u8argc,
1441  char *const **u8argv)
1442 {
1443  char *const *new_argv =
1444  (char *const *) _make_continuous_arg_copy (argc, argv);
1445  *u8argv = new_argv;
1446  *u8argc = argc;
1447  return GNUNET_OK;
1448 }
1449 
1450 
1460 static int
1461 parse_port_policy (const char *port_policy,
1462  struct GNUNET_STRINGS_PortPolicy *pp)
1463 {
1464  const char *pos;
1465  int s;
1466  int e;
1467  char eol[2];
1468 
1469  pos = port_policy;
1470  if ('!' == *pos)
1471  {
1473  pos++;
1474  }
1475  if (2 == sscanf (pos, "%u-%u%1s", &s, &e, eol))
1476  {
1477  if ((0 == s) || (s > 0xFFFF) || (e < s) || (e > 0xFFFF))
1478  {
1479  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Port not in range\n"));
1480  return GNUNET_SYSERR;
1481  }
1482  pp->start_port = (uint16_t) s;
1483  pp->end_port = (uint16_t) e;
1484  return GNUNET_OK;
1485  }
1486  if (1 == sscanf (pos, "%u%1s", &s, eol))
1487  {
1488  if ((0 == s) || (s > 0xFFFF))
1489  {
1490  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _ ("Port not in range\n"));
1491  return GNUNET_SYSERR;
1492  }
1493 
1494  pp->start_port = (uint16_t) s;
1495  pp->end_port = (uint16_t) s;
1496  return GNUNET_OK;
1497  }
1499  _ ("Malformed port policy `%s'\n"),
1500  port_policy);
1501  return GNUNET_SYSERR;
1502 }
1503 
1504 
1518 GNUNET_STRINGS_parse_ipv4_policy (const char *routeListX)
1519 {
1520  unsigned int count;
1521  unsigned int i;
1522  unsigned int j;
1523  unsigned int len;
1524  int cnt;
1525  unsigned int pos;
1526  unsigned int temps[8];
1527  int slash;
1529  int colon;
1530  int end;
1531  char *routeList;
1532  char dummy[2];
1533 
1534  if (NULL == routeListX)
1535  return NULL;
1536  len = strlen (routeListX);
1537  if (0 == len)
1538  return NULL;
1539  routeList = GNUNET_strdup (routeListX);
1540  count = 0;
1541  for (i = 0; i < len; i++)
1542  if (routeList[i] == ';')
1543  count++;
1544  result = GNUNET_malloc (sizeof(struct GNUNET_STRINGS_IPv4NetworkPolicy)
1545  * (count + 1));
1546  i = 0;
1547  pos = 0;
1548  while (i < count)
1549  {
1550  for (colon = pos; ':' != routeList[colon]; colon++)
1551  if ((';' == routeList[colon]) || ('\0' == routeList[colon]))
1552  break;
1553  for (end = colon; ';' != routeList[end]; end++)
1554  if ('\0' == routeList[end])
1555  break;
1556  if ('\0' == routeList[end])
1557  break;
1558  routeList[end] = '\0';
1559  if (':' == routeList[colon])
1560  {
1561  routeList[colon] = '\0';
1562  if (GNUNET_OK != parse_port_policy (&routeList[colon + 1], &result[i].pp))
1563  break;
1564  }
1565  cnt = sscanf (&routeList[pos],
1566  "%u.%u.%u.%u/%u.%u.%u.%u%1s",
1567  &temps[0],
1568  &temps[1],
1569  &temps[2],
1570  &temps[3],
1571  &temps[4],
1572  &temps[5],
1573  &temps[6],
1574  &temps[7],
1575  dummy);
1576  if (8 == cnt)
1577  {
1578  for (j = 0; j < 8; j++)
1579  if (temps[j] > 0xFF)
1580  {
1582  _ ("Invalid format for IP: `%s'\n"),
1583  &routeList[pos]);
1584  GNUNET_free (result);
1585  GNUNET_free (routeList);
1586  return NULL;
1587  }
1588  result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1589  + (temps[2] << 8) + temps[3]);
1590  result[i].netmask.s_addr = htonl ((temps[4] << 24) + (temps[5] << 16)
1591  + (temps[6] << 8) + temps[7]);
1592  pos = end + 1;
1593  i++;
1594  continue;
1595  }
1596  /* try second notation */
1597  cnt = sscanf (&routeList[pos],
1598  "%u.%u.%u.%u/%u%1s",
1599  &temps[0],
1600  &temps[1],
1601  &temps[2],
1602  &temps[3],
1603  &slash,
1604  dummy);
1605  if (5 == cnt)
1606  {
1607  for (j = 0; j < 4; j++)
1608  if (temps[j] > 0xFF)
1609  {
1611  _ ("Invalid format for IP: `%s'\n"),
1612  &routeList[pos]);
1613  GNUNET_free (result);
1614  GNUNET_free (routeList);
1615  return NULL;
1616  }
1617  result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1618  + (temps[2] << 8) + temps[3]);
1619  if ((slash <= 32) && (slash >= 0))
1620  {
1621  result[i].netmask.s_addr = 0;
1622  while (slash > 0)
1623  {
1624  result[i].netmask.s_addr =
1625  (result[i].netmask.s_addr >> 1) + 0x80000000;
1626  slash--;
1627  }
1628  result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
1629  pos = end + 1;
1630  i++;
1631  continue;
1632  }
1633  else
1634  {
1636  _ ("Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
1637  slash);
1638  GNUNET_free (result);
1639  GNUNET_free (routeList);
1640  return NULL; /* error */
1641  }
1642  }
1643  /* try third notation */
1644  slash = 32;
1645  cnt = sscanf (&routeList[pos],
1646  "%u.%u.%u.%u%1s",
1647  &temps[0],
1648  &temps[1],
1649  &temps[2],
1650  &temps[3],
1651  dummy);
1652  if (4 == cnt)
1653  {
1654  for (j = 0; j < 4; j++)
1655  if (temps[j] > 0xFF)
1656  {
1658  _ ("Invalid format for IP: `%s'\n"),
1659  &routeList[pos]);
1660  GNUNET_free (result);
1661  GNUNET_free (routeList);
1662  return NULL;
1663  }
1664  result[i].network.s_addr = htonl ((temps[0] << 24) + (temps[1] << 16)
1665  + (temps[2] << 8) + temps[3]);
1666  result[i].netmask.s_addr = 0;
1667  while (slash > 0)
1668  {
1669  result[i].netmask.s_addr = (result[i].netmask.s_addr >> 1) + 0x80000000;
1670  slash--;
1671  }
1672  result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
1673  pos = end + 1;
1674  i++;
1675  continue;
1676  }
1678  _ ("Invalid format for IP: `%s'\n"),
1679  &routeList[pos]);
1680  GNUNET_free (result);
1681  GNUNET_free (routeList);
1682  return NULL; /* error */
1683  }
1684  if (pos < strlen (routeList))
1685  {
1687  _ ("Invalid format: `%s'\n"),
1688  &routeListX[pos]);
1689  GNUNET_free (result);
1690  GNUNET_free (routeList);
1691  return NULL; /* oops */
1692  }
1693  GNUNET_free (routeList);
1694  return result; /* ok */
1695 }
1696 
1697 
1710 GNUNET_STRINGS_parse_ipv6_policy (const char *routeListX)
1711 {
1712  unsigned int count;
1713  unsigned int i;
1714  unsigned int len;
1715  unsigned int pos;
1716  int start;
1717  int slash;
1718  int ret;
1719  char *routeList;
1721  unsigned int bits;
1722  unsigned int off;
1723  int save;
1724  int colon;
1725  char dummy[2];
1726 
1727  if (NULL == routeListX)
1728  return NULL;
1729  len = strlen (routeListX);
1730  if (0 == len)
1731  return NULL;
1732  routeList = GNUNET_strdup (routeListX);
1733  count = 0;
1734  for (i = 0; i < len; i++)
1735  if (';' == routeList[i])
1736  count++;
1737  if (';' != routeList[len - 1])
1738  {
1740  _ ("Invalid network notation (does not end with ';': `%s')\n"),
1741  routeList);
1742  GNUNET_free (routeList);
1743  return NULL;
1744  }
1745 
1746  result = GNUNET_malloc (sizeof(struct GNUNET_STRINGS_IPv6NetworkPolicy)
1747  * (count + 1));
1748  i = 0;
1749  pos = 0;
1750  while (i < count)
1751  {
1752  start = pos;
1753  while (';' != routeList[pos])
1754  pos++;
1755  slash = pos;
1756  while ((slash >= start) && (routeList[slash] != '/'))
1757  slash--;
1758 
1759  if (slash < start)
1760  {
1761  memset (&result[i].netmask, 0xFF, sizeof(struct in6_addr));
1762  slash = pos;
1763  }
1764  else
1765  {
1766  routeList[pos] = '\0';
1767  for (colon = pos; ':' != routeList[colon]; colon--)
1768  if ('/' == routeList[colon])
1769  break;
1770  if (':' == routeList[colon])
1771  {
1772  routeList[colon] = '\0';
1773  if (GNUNET_OK !=
1774  parse_port_policy (&routeList[colon + 1], &result[i].pp))
1775  {
1776  GNUNET_free (result);
1777  GNUNET_free (routeList);
1778  return NULL;
1779  }
1780  }
1781  ret = inet_pton (AF_INET6, &routeList[slash + 1], &result[i].netmask);
1782  if (ret <= 0)
1783  {
1784  save = errno;
1785  if ((1 != sscanf (&routeList[slash + 1], "%u%1s", &bits, dummy)) ||
1786  (bits > 128))
1787  {
1788  if (0 == ret)
1790  _ ("Wrong format `%s' for netmask\n"),
1791  &routeList[slash + 1]);
1792  else
1793  {
1794  errno = save;
1795  LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "inet_pton");
1796  }
1797  GNUNET_free (result);
1798  GNUNET_free (routeList);
1799  return NULL;
1800  }
1801  off = 0;
1802  while (bits > 8)
1803  {
1804  result[i].netmask.s6_addr[off++] = 0xFF;
1805  bits -= 8;
1806  }
1807  while (bits > 0)
1808  {
1809  result[i].netmask.s6_addr[off] =
1810  (result[i].netmask.s6_addr[off] >> 1) + 0x80;
1811  bits--;
1812  }
1813  }
1814  }
1815  routeList[slash] = '\0';
1816  ret = inet_pton (AF_INET6, &routeList[start], &result[i].network);
1817  if (ret <= 0)
1818  {
1819  if (0 == ret)
1821  _ ("Wrong format `%s' for network\n"),
1822  &routeList[slash + 1]);
1823  else
1824  LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "inet_pton");
1825  GNUNET_free (result);
1826  GNUNET_free (routeList);
1827  return NULL;
1828  }
1829  pos++;
1830  i++;
1831  }
1832  GNUNET_free (routeList);
1833  return result;
1834 }
1835 
1836 
1839 #define FILLCHAR '='
1840 static char *cvt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1841  "abcdefghijklmnopqrstuvwxyz"
1842  "0123456789+/";
1843 
1844 
1854 size_t
1855 GNUNET_STRINGS_base64_encode (const void *in, size_t len, char **output)
1856 {
1857  const char *data = in;
1858  size_t ret;
1859  char *opt;
1860 
1861  ret = 0;
1862  opt = GNUNET_malloc (2 + (len * 4 / 3) + 8);
1863  for (size_t i = 0; i < len; ++i)
1864  {
1865  char c;
1866 
1867  c = (data[i] >> 2) & 0x3f;
1868  opt[ret++] = cvt[(int) c];
1869  c = (data[i] << 4) & 0x3f;
1870  if (++i < len)
1871  c |= (data[i] >> 4) & 0x0f;
1872  opt[ret++] = cvt[(int) c];
1873  if (i < len)
1874  {
1875  c = (data[i] << 2) & 0x3f;
1876  if (++i < len)
1877  c |= (data[i] >> 6) & 0x03;
1878  opt[ret++] = cvt[(int) c];
1879  }
1880  else
1881  {
1882  ++i;
1883  opt[ret++] = FILLCHAR;
1884  }
1885  if (i < len)
1886  {
1887  c = data[i] & 0x3f;
1888  opt[ret++] = cvt[(int) c];
1889  }
1890  else
1891  {
1892  opt[ret++] = FILLCHAR;
1893  }
1894  }
1895  *output = opt;
1896  return ret;
1897 }
1898 
1899 
1900 #define cvtfind(a) \
1901  ((((a) >= 'A') && ((a) <= 'Z')) \
1902  ? (a) - 'A' \
1903  : (((a) >= 'a') && ((a) <= 'z')) \
1904  ? (a) - 'a' + 26 \
1905  : (((a) >= '0') && ((a) <= '9')) \
1906  ? (a) - '0' + 52 \
1907  : ((a) == '+') ? 62 : ((a) == '/') ? 63 : -1)
1908 
1909 
1919 size_t
1920 GNUNET_STRINGS_base64_decode (const char *data, size_t len, void **out)
1921 {
1922  char *output;
1923  size_t ret = 0;
1924 
1925 #define CHECK_CRLF \
1926  while (data[i] == '\r' || data[i] == '\n') \
1927  { \
1928  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, \
1929  "ignoring CR/LF\n"); \
1930  i++; \
1931  if (i >= len) \
1932  goto END; \
1933  }
1934 
1935  output = GNUNET_malloc ((len * 3 / 4) + 8);
1937  "base64_decode decoding len=%d\n",
1938  (int) len);
1939  for (size_t i = 0; i < len; ++i)
1940  {
1941  char c;
1942  char c1;
1943 
1944  CHECK_CRLF;
1945  if (FILLCHAR == data[i])
1946  break;
1947  c = (char) cvtfind (data[i]);
1948  ++i;
1949  CHECK_CRLF;
1950  c1 = (char) cvtfind (data[i]);
1951  c = (c << 2) | ((c1 >> 4) & 0x3);
1952  output[ret++] = c;
1953  if (++i < len)
1954  {
1955  CHECK_CRLF;
1956  c = data[i];
1957  if (FILLCHAR == c)
1958  break;
1959  c = (char) cvtfind (c);
1960  c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
1961  output[ret++] = c1;
1962  }
1963  if (++i < len)
1964  {
1965  CHECK_CRLF;
1966  c1 = data[i];
1967  if (FILLCHAR == c1)
1968  break;
1969 
1970  c1 = (char) cvtfind (c1);
1971  c = ((c << 6) & 0xc0) | c1;
1972  output[ret++] = c;
1973  }
1974  }
1975 END:
1976  *out = output;
1977  return ret;
1978 }
1979 
1980 
1981 /* end of strings.c */
static void do_round(void *cls)
Send out PUSHes and PULLs, possibly update #view, samplers.
unsigned long long value
Factor to apply for this unit.
Definition: strings.c:244
struct GNUNET_STRINGS_IPv4NetworkPolicy * GNUNET_STRINGS_parse_ipv4_policy(const char *routeListX)
Parse an IPv4 network policy.
Definition: strings.c:1518
#define CHECK_CRLF
#define FILLCHAR
******************** Base64 encoding
Definition: strings.c:1839
uint64_t rel_value_us
The actual value.
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
static int parse_port_policy(const char *port_policy, struct GNUNET_STRINGS_PortPolicy *pp)
Parse the given port policy.
Definition: strings.c:1461
char * GNUNET_STRINGS_conv(const char *input, size_t len, const char *input_charset, const char *output_charset)
Convert the len characters long character sequence given in input that is in the given input charset ...
Definition: strings.c:447
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
int GNUNET_STRINGS_parse_uri(const char *path, char **scheme_part, const char **path_part)
Parse a path that might be an URI.
Definition: strings.c:1032
struct GNUNET_STRINGS_PortPolicy pp
Policy for port access.
static struct GNUNET_SCHEDULER_Task * tt
Task scheduled to handle timeout.
Definition: gnunet-abd.c:76
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
char * GNUNET_STRINGS_byte_size_fancy(unsigned long long size)
Convert a given filesize into a fancy human-readable format.
Definition: strings.c:175
uint16_t start_port
Starting port range (0 if none given).
static int convert_with_table(const char *input, const struct ConversionTable *table, unsigned long long *output)
Convert a string of the form "4 X 5 Y" into a numeric value by interpreting "X" and "Y" as units and ...
Definition: strings.c:260
struct GNUNET_STRINGS_IPv6NetworkPolicy * GNUNET_STRINGS_parse_ipv6_policy(const char *routeListX)
Parse an IPv6 network policy.
Definition: strings.c:1710
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1438
int GNUNET_STRINGS_path_is_absolute(const char *filename, int can_be_uri, int *r_is_uri, char **r_uri_scheme)
Check whether filename is absolute or not, and if it&#39;s an URI.
Definition: strings.c:1108
#define cvtfind(a)
Definition: strings.c:1900
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time, struct GNUNET_TIME_Relative *rtime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:351
Check that the path is an absolute path.
network in CIDR notation for IPV6.
int negate_portrange
GNUNET_YES if the port range should be negated ("!" in policy).
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
int GNUNET_STRINGS_fancy_time_to_absolute(const char *fancy_time, struct GNUNET_TIME_Absolute *atime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:402
static struct Experiment * e
struct in_addr netmask
IPv4 netmask.
We&#39;re done processing.
int GNUNET_STRINGS_fancy_size_to_bytes(const char *fancy_size, unsigned long long *size)
Convert a given fancy human-readable size to bytes.
Definition: strings.c:319
static char *const * _make_continuous_arg_copy(int argc, char *const *argv)
Makes a copy of argv that consists of a single memory chunk that can be freed with a single call to G...
Definition: strings.c:1401
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_SCHEDULER_Task * t
Main task.
Check that it exists.
static void save()
Write persistent statistics to disk.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct in6_addr netmask
IPv6 netmask.
uint64_t abs_value_us
The actual value.
static char * cvt
Definition: strings.c:1840
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct in_addr network
IPv4 address.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
int GNUNET_STRINGS_to_address_ipv4(const char *zt_addr, uint16_t addrlen, struct sockaddr_in *r_buf)
Tries to convert &#39;zt_addr&#39; string to an IPv4 address.
Definition: strings.c:1277
unsigned int GNUNET_STRINGS_buffer_tokenize(const char *buffer, size_t size, unsigned int count,...)
Given a buffer of a given size, find "count" 0-terminated strings in the buffer and assign the count ...
Definition: strings.c:135
cryptographic primitives for GNUnet
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
void GNUNET_STRINGS_utf8_toupper(const char *input, char *output)
Convert the utf-8 input string to uppercase.
Definition: strings.c:578
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static struct PeerEntry ** table
Table with our interned peer IDs.
Definition: peer.c:55
char * GNUNET_STRINGS_pp2s(const struct GNUNET_PeerIdentity *pids, unsigned int num_pids)
Convert a peer path to a human-readable string.
Definition: strings.c:100
#define DIR_SEPARATOR_STR
Definition: platform.h:168
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
IPV4 network in CIDR notation.
static char buf[2048]
static char * filename
static int result
Global testing status.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
char * GNUNET_STRINGS_from_utf8(const char *input, size_t len, const char *charset)
Convert the len bytes-long UTF-8 string given in input to the given charset.
Definition: strings.c:539
size_t GNUNET_STRINGS_buffer_fill(char *buffer, size_t size, unsigned int count,...)
Fill a buffer of the given size with count 0-terminated strings (given as varargs).
Definition: strings.c:65
Unit conversion table entry for &#39;convert_with_table&#39;.
Definition: strings.c:234
size_t GNUNET_STRINGS_parse_socket_addr(const char *addr, uint8_t *af, struct sockaddr **sa)
Parse an address given as a string into a struct sockaddr.
Definition: strings.c:1350
static OpusDecoder * dec
OPUS decoder.
#define LOG(kind,...)
Definition: strings.c:37
static unsigned int getValue__(unsigned char a)
Get the decoded value corresponding to a character according to Crockford Base32 encoding.
Definition: strings.c:794
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **out)
Decode from Base64.
Definition: strings.c:1920
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1855
#define DIR_SEPARATOR
Definition: platform.h:167
const char * GNUNET_STRINGS_get_short_name(const char *filename)
"man basename" Returns a pointer to a part of filename (allocates nothing)!
Definition: strings.c:775
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
int GNUNET_STRINGS_check_filename(const char *filename, enum GNUNET_STRINGS_FilenameCheck checks)
Perform checks on filename.
Definition: strings.c:1158
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:603
char * getenv()
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
#define S_ISLNK(m)
Definition: disk.c:61
The identity of the host (wraps the signing key of the peer).
uint16_t end_port
End of port range (0 if none given).
#define LOG_STRERROR(kind, syscall)
Definition: strings.c:39
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
static OpusEncoder * enc
OPUS encoder.
int GNUNET_STRINGS_to_address_ipv6(const char *zt_addr, uint16_t addrlen, struct sockaddr_in6 *r_buf)
Tries to convert zt_addr string to an IPv6 address.
Definition: strings.c:1203
#define GNUNET_log(kind,...)
GNUNET_STRINGS_FilenameCheck
Flags for what we should check a file for.
char * GNUNET_STRINGS_to_utf8(const char *input, size_t len, const char *charset)
Convert the len characters long character sequence given in input that is in the given charset to UTF...
Definition: strings.c:521
struct GNUNET_STRINGS_PortPolicy pp
Policy for port access.
struct in6_addr network
IPv6 address.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
Check that it is a link.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:920
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
"asctime", except for GNUnet time.
Definition: strings.c:742
uint32_t data
The data value.
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
Definition: strings.c:219
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
const char * name
Name of the unit (or NULL for end of table).
Definition: strings.c:239
static size_t strnlen(const char *s, size_t n)
int GNUNET_STRINGS_to_address_ip(const char *addr, uint16_t addrlen, struct sockaddr_storage *r_buf)
Tries to convert addr string to an IP (v4 or v6) address.
Definition: strings.c:1326
#define GNUNET_malloc(size)
Wrapper around malloc.
int GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert Crockford Base32hex encoding back to data.
Definition: strings.c:952
char * GNUNET_STRINGS_data_to_string(const void *data, size_t size, char *out, size_t out_size)
Convert binary data to ASCII encoding using Crockford Base32 encoding.
Definition: strings.c:856
Check that it is a directory.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
void GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
Convert the utf-8 input string to lowercase.
Definition: strings.c:553
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...