GNUnet  0.19.3
network.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 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  */
20 
28 #include "platform.h"
29 #include "disk.h"
30 
31 #define LOG(kind, ...) GNUNET_log_from (kind, "util-network", __VA_ARGS__)
32 #define LOG_STRERROR_FILE(kind, syscall, \
33  filename) GNUNET_log_from_strerror_file (kind, \
34  "util-network", \
35  syscall, \
36  filename)
37 #define LOG_STRERROR(kind, syscall) GNUNET_log_from_strerror (kind, \
38  "util-network", \
39  syscall)
40 
41 #define DEBUG_NETWORK GNUNET_EXTRA_LOGGING
42 
43 
44 #ifndef INVALID_SOCKET
45 #define INVALID_SOCKET -1
46 #endif
47 
48 
53 {
54  int fd;
55 
59  int af;
60 
64  int type;
65 
69  socklen_t addrlen;
70 
74  struct sockaddr *addr;
75 };
76 
77 
80 {
81  static int cache_v4 = -1;
82  static int cache_v6 = -1;
83  static int cache_un = -1;
84  int s;
85  int ret;
86 
87  switch (pf)
88  {
89  case PF_INET:
90  if (-1 != cache_v4)
91  return cache_v4;
92  break;
93 
94  case PF_INET6:
95  if (-1 != cache_v6)
96  return cache_v6;
97  break;
98 
99 #ifdef PF_UNIX
100  case PF_UNIX:
101  if (-1 != cache_un)
102  return cache_un;
103  break;
104 #endif
105  }
106  s = socket (pf, SOCK_STREAM, 0);
107  if (-1 == s)
108  {
109  if (EAFNOSUPPORT != errno)
110  {
112  "socket");
113  return GNUNET_SYSERR;
114  }
115  ret = GNUNET_NO;
116  }
117  else
118  {
119  GNUNET_break (0 == close (s));
120  ret = GNUNET_OK;
121  }
122  switch (pf)
123  {
124  case PF_INET:
125  cache_v4 = ret;
126  break;
127 
128  case PF_INET6:
129  cache_v6 = ret;
130  break;
131 
132 #ifdef PF_UNIX
133  case PF_UNIX:
134  cache_un = ret;
135  break;
136 #endif
137  }
138  return ret;
139 }
140 
141 
142 char *
144 {
145  struct sockaddr_un dummy;
146  size_t slen;
147  char *end;
148  struct GNUNET_HashCode sh;
150  size_t upm;
151 
152  upm = sizeof(dummy.sun_path);
153  slen = strlen (unixpath);
154  if (slen < upm)
155  return unixpath; /* no shortening required */
156  GNUNET_CRYPTO_hash (unixpath, slen, &sh);
157  while (16 + strlen (unixpath) >= upm)
158  {
159  if (NULL == (end = strrchr (unixpath, '/')))
160  {
162  _ (
163  "Unable to shorten unix path `%s' while keeping name unique\n"),
164  unixpath);
165  GNUNET_free (unixpath);
166  return NULL;
167  }
168  *end = '\0';
169  }
171  ae.encoding[16] = '\0';
172  strcat (unixpath, (char *) ae.encoding);
173  return unixpath;
174 }
175 
176 
177 void
178 GNUNET_NETWORK_unix_precheck (const struct sockaddr_un *un)
179 {
180  int s;
181  int eno;
182  struct stat sbuf;
183  int ret;
184 
185  s = socket (AF_UNIX, SOCK_STREAM, 0);
186  if (-1 == s)
187  {
189  "Failed to open AF_UNIX socket");
190  return;
191  }
192  ret = connect (s,
193  (struct sockaddr *) un,
194  sizeof(struct sockaddr_un));
195  eno = errno;
196  GNUNET_break (0 == close (s));
197  if (0 == ret)
198  return; /* another process is listening, do not remove! */
199  if (ECONNREFUSED != eno)
200  return; /* some other error, likely "no such file or directory" -- all well */
201  /* should unlink, but sanity checks first */
202  if (0 != stat (un->sun_path,
203  &sbuf))
204  return; /* failed to 'stat', likely does not exist after all */
205  if (S_IFSOCK != (S_IFMT & sbuf.st_mode))
206  return; /* refuse to unlink anything except sockets */
207  /* finally, really unlink */
209  "Removing left-over `%s' from previous exeuction\n",
210  un->sun_path);
211  if (0 != unlink (un->sun_path))
213  "unlink",
214  un->sun_path);
215 }
216 
217 
218 #ifndef FD_COPY
219 #define FD_COPY(s, d) do { GNUNET_memcpy ((d), (s), sizeof(fd_set)); } while (0)
220 #endif
221 
222 
225  int doBlock)
226 {
227  int flags = fcntl (fd->fd, F_GETFL);
228 
229  if (flags == -1)
230  {
232  "fcntl");
233  return GNUNET_SYSERR;
234  }
235  if (doBlock)
236  flags &= ~O_NONBLOCK;
237 
238  else
239  flags |= O_NONBLOCK;
240  if (0 != fcntl (fd->fd,
241  F_SETFL,
242  flags))
243 
244  {
246  "fcntl");
247  return GNUNET_SYSERR;
248  }
249  return GNUNET_OK;
250 }
251 
252 
260 static int
262 {
263  int i;
264  i = fcntl (h->fd, F_GETFD);
265  if (i < 0)
266  return GNUNET_SYSERR;
267  if (i == (i | FD_CLOEXEC))
268  return GNUNET_OK;
269  i |= FD_CLOEXEC;
270  if (fcntl (h->fd, F_SETFD, i) < 0)
271  return GNUNET_SYSERR;
272 
273  return GNUNET_OK;
274 }
275 
276 
277 #ifdef DARWIN
283 static int
284 socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle *h)
285 {
286  int abs_value = 1;
287 
288  if (0 !=
289  setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE,
290  (const void *) &abs_value,
291  sizeof(abs_value)))
292  return GNUNET_SYSERR;
293  return GNUNET_OK;
294 }
295 
296 
297 #endif
298 
299 
307 static void
309 {
310  int value = 1;
311 
312  if (0 !=
313  setsockopt (h->fd,
314  IPPROTO_TCP,
315  TCP_NODELAY,
316  &value, sizeof(value)))
318  "setsockopt");
319 }
320 
321 
334 static int
336  int af,
337  int type)
338 {
339  int eno;
340 
341  h->af = af;
342  h->type = type;
343  if (h->fd == INVALID_SOCKET)
344  {
345  eno = errno;
346  GNUNET_free (h);
347  errno = eno;
348  return GNUNET_SYSERR;
349  }
350 
351  if (h->fd >= FD_SETSIZE)
352  {
355  errno = EMFILE;
356  return GNUNET_SYSERR;
357  }
358 
361  "socket_set_inheritable");
362 
364  {
365  eno = errno;
366  GNUNET_break (0);
368  errno = eno;
369  return GNUNET_SYSERR;
370  }
371 #ifdef DARWIN
372  if (GNUNET_SYSERR == socket_set_nosigpipe (h))
373  {
374  eno = errno;
375  GNUNET_break (0);
377  errno = eno;
378  return GNUNET_SYSERR;
379  }
380 #endif
381  if ((type == SOCK_STREAM)
382 #ifdef AF_UNIX
383  && (af != AF_UNIX)
384 #endif
385  )
387  return GNUNET_OK;
388 }
389 
390 
391 struct GNUNET_NETWORK_Handle *
393  struct sockaddr *address,
394  socklen_t *address_len)
395 {
396  struct GNUNET_NETWORK_Handle *ret;
397  int eno;
398 
400 #if DEBUG_NETWORK
401  {
402  struct sockaddr_storage name;
403  socklen_t namelen = sizeof(name);
404 
405  int gsn = getsockname (desc->fd,
406  (struct sockaddr *) &name,
407  &namelen);
408 
409  if (0 == gsn)
411  "Accepting connection on `%s'\n",
412  GNUNET_a2s ((const struct sockaddr *) &name,
413  namelen));
414  }
415 #endif
416  ret->fd = accept (desc->fd,
417  address,
418  address_len);
419  if (-1 == ret->fd)
420  {
421  eno = errno;
422  GNUNET_free (ret);
423  errno = eno;
424  return NULL;
425  }
426  if (GNUNET_OK !=
428  (NULL != address) ? address->sa_family :
429  desc->af,
430  SOCK_STREAM))
431  {
432  return NULL;
433  }
434  return ret;
435 }
436 
437 
440  const struct sockaddr *address,
441  socklen_t address_len)
442 {
443  int ret;
444 
445 #ifdef IPV6_V6ONLY
446 #ifdef IPPROTO_IPV6
447  {
448  const int on = 1;
449 
450  if (AF_INET6 == desc->af)
451  if (setsockopt (desc->fd,
452  IPPROTO_IPV6,
453  IPV6_V6ONLY,
454  (const void *) &on,
455  sizeof(on)))
457  "setsockopt");
458  }
459 #endif
460 #endif
461  if (AF_UNIX == address->sa_family)
462  GNUNET_NETWORK_unix_precheck ((const struct sockaddr_un *) address);
463 
464  {
465  const int on = 1;
466 
467  if ( (SOCK_STREAM == desc->type) &&
468  (0 != setsockopt (desc->fd,
469  SOL_SOCKET,
470  SO_REUSEADDR,
471  &on, sizeof(on))) )
473  "setsockopt");
474  }
475  {
476  /* set permissions of newly created non-abstract UNIX domain socket to
477  "user-only"; applications can choose to relax this later */
478  mode_t old_mask = 0; /* assigned to make compiler happy */
479  const struct sockaddr_un *un = (const struct sockaddr_un *) address;
480  int not_abstract = 0;
481 
482  if ((AF_UNIX == address->sa_family)
483  && ('\0' != un->sun_path[0])) /* Not an abstract socket */
484  not_abstract = 1;
485  if (not_abstract)
486  old_mask = umask (S_IWGRP | S_IRGRP | S_IXGRP | S_IWOTH | S_IROTH
487  | S_IXOTH);
488 
489  ret = bind (desc->fd,
490  address,
491  address_len);
492 
493  if (not_abstract)
494  (void) umask (old_mask);
495  }
496  if (0 != ret)
497  return GNUNET_SYSERR;
498 
499  desc->addr = GNUNET_malloc (address_len);
500  GNUNET_memcpy (desc->addr, address, address_len);
501  desc->addrlen = address_len;
502 
503  return GNUNET_OK;
504 }
505 
506 
509 {
510  int ret;
511 
512  ret = close (desc->fd);
513 
514  const struct sockaddr_un *un = (const struct sockaddr_un *) desc->addr;
515 
516  /* Cleanup the UNIX domain socket and its parent directories in case of non
517  abstract sockets */
518  if ((AF_UNIX == desc->af) &&
519  (NULL != desc->addr) &&
520  ('\0' != un->sun_path[0]))
521  {
522  char *dirname = GNUNET_strndup (un->sun_path,
523  sizeof(un->sun_path));
524 
525  if (0 != unlink (dirname))
526  {
528  "unlink",
529  dirname);
530  }
531  else
532  {
533  size_t len;
534 
535  len = strlen (dirname);
536  while ((len > 0) && (dirname[len] != DIR_SEPARATOR))
537  len--;
538  dirname[len] = '\0';
539  if ((0 != len) && (0 != rmdir (dirname)))
540  {
541  switch (errno)
542  {
543  case EACCES:
544  case ENOTEMPTY:
545  case EPERM:
546  /* these are normal and can just be ignored */
547  break;
548 
549  default:
551  "rmdir",
552  dirname);
553  break;
554  }
555  }
556  }
557  GNUNET_free (dirname);
558  }
560  return (ret == 0) ? GNUNET_OK : GNUNET_SYSERR;
561 }
562 
563 
564 void
566 {
567  GNUNET_free (desc->addr);
568  GNUNET_free (desc);
569 }
570 
571 
578 struct GNUNET_NETWORK_Handle *
580 {
581  struct GNUNET_NETWORK_Handle *ret;
582 
583  if (fcntl (fd, F_GETFD) < 0)
584  return NULL; /* invalid FD */
586  ret->fd = fd;
587  ret->af = AF_UNSPEC;
588  return ret;
589 }
590 
591 
600 int
602  const struct sockaddr *address,
603  socklen_t address_len)
604 {
605  int ret;
606 
607  ret = connect (desc->fd,
608  address,
609  address_len);
610 
611  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
612 }
613 
614 
625 int
627  int level,
628  int optname,
629  void *optval,
630  socklen_t *optlen)
631 {
632  int ret;
633 
634  ret = getsockopt (desc->fd,
635  level,
636  optname,
637  optval, optlen);
638 
639  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
640 }
641 
642 
650 int
652  int backlog)
653 {
654  int ret;
655 
656  ret = listen (desc->fd,
657  backlog);
658 
659  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
660 }
661 
662 
669 ssize_t
671 {
672  int error;
673 
674  /* How much is there to be read? */
675  int pending;
676 
677  error = ioctl (desc->fd,
678  FIONREAD,
679  &pending);
680  if (0 == error)
681  return (ssize_t) pending;
682  return GNUNET_SYSERR;
683 }
684 
685 
686 ssize_t
688  void *buffer,
689  size_t length,
690  struct sockaddr *src_addr,
691  socklen_t *addrlen)
692 {
693  int flags = 0;
694 
695 #ifdef MSG_DONTWAIT
696  flags |= MSG_DONTWAIT;
697 #endif
698  return recvfrom (desc->fd,
699  buffer,
700  length,
701  flags,
702  src_addr,
703  addrlen);
704 }
705 
706 
715 ssize_t
717  void *buffer,
718  size_t length)
719 {
720  int ret;
721  int flags;
722 
723  flags = 0;
724 
725 #ifdef MSG_DONTWAIT
726  flags |= MSG_DONTWAIT;
727 #endif
728  ret = recv (desc->fd,
729  buffer,
730  length,
731  flags);
732  return ret;
733 }
734 
735 
736 ssize_t
738  const void *buffer,
739  size_t length)
740 {
741  int ret;
742  int flags;
743 
744  flags = 0;
745 #ifdef MSG_DONTWAIT
746  flags |= MSG_DONTWAIT;
747 #endif
748 #ifdef MSG_NOSIGNAL
749  flags |= MSG_NOSIGNAL;
750 #endif
751  ret = send (desc->fd,
752  buffer,
753  length,
754  flags);
755  return ret;
756 }
757 
758 
770 ssize_t
772  const void *message,
773  size_t length,
774  const struct sockaddr *dest_addr,
775  socklen_t dest_len)
776 {
777  int flags = 0;
778 
779 #ifdef MSG_DONTWAIT
780  flags |= MSG_DONTWAIT;
781 #endif
782 #ifdef MSG_NOSIGNAL
783  flags |= MSG_NOSIGNAL;
784 #endif
785  return sendto (desc->fd,
786  message,
787  length,
788  flags,
789  dest_addr,
790  dest_len);
791 }
792 
793 
804 int
806  int level,
807  int option_name,
808  const void *option_value,
809  socklen_t option_len)
810 {
811  return (0 == setsockopt (fd->fd,
812  level,
813  option_name,
814  option_value,
815  option_len))
816  ? GNUNET_OK
817  : GNUNET_SYSERR;
818 }
819 
820 
831 struct GNUNET_NETWORK_Handle *
833  int type,
834  int protocol)
835 {
836  struct GNUNET_NETWORK_Handle *ret;
837  int fd;
838 
839  fd = socket (domain, type, protocol);
840  if (-1 == fd)
841  return NULL;
843  ret->fd = fd;
844  if (GNUNET_OK !=
846  domain,
847  type))
848  return NULL;
849  return ret;
850 }
851 
852 
859 int
861  int how)
862 {
863  int ret;
864 
865  ret = shutdown (desc->fd, how);
866 
867  return (0 == ret) ? GNUNET_OK : GNUNET_SYSERR;
868 }
869 
870 
880 int
882 {
883  int ret = 0;
884 
885 #ifdef __linux__
886  int value = 0;
887 
888  if (0 !=
889  (ret =
890  setsockopt (desc->fd,
891  SOL_SOCKET,
892  SO_SNDBUF,
893  &value,
894  sizeof(value))))
896  "setsockopt");
897  if (0 !=
898  (ret =
899  setsockopt (desc->fd,
900  SOL_SOCKET,
901  SO_RCVBUF,
902  &value,
903  sizeof(value))))
905  "setsockopt");
906 #endif
907  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
908 }
909 
910 
916 void
918 {
919  FD_ZERO (&fds->sds);
920  fds->nsds = 0;
921 }
922 
923 
930 void
932  const struct GNUNET_NETWORK_Handle *desc)
933 {
934  FD_SET (desc->fd,
935  &fds->sds);
936  fds->nsds = GNUNET_MAX (fds->nsds,
937  desc->fd + 1);
938 }
939 
940 
948 int
950  const struct GNUNET_NETWORK_Handle *desc)
951 {
952  return FD_ISSET (desc->fd,
953  &fds->sds);
954 }
955 
956 
963 void
965  const struct GNUNET_NETWORK_FDSet *src)
966 {
967  int nfds;
968 
969  for (nfds = src->nsds; nfds >= 0; nfds--)
970  if (FD_ISSET (nfds, &src->sds))
971  FD_SET (nfds, &dst->sds);
972  dst->nsds = GNUNET_MAX (dst->nsds,
973  src->nsds);
974 }
975 
976 
983 void
985  const struct GNUNET_NETWORK_FDSet *from)
986 {
987  FD_COPY (&from->sds,
988  &to->sds);
989  to->nsds = from->nsds;
990 }
991 
992 
999 int
1001 {
1002  return desc->fd;
1003 }
1004 
1005 
1012 struct sockaddr*
1014 {
1015  return desc->addr;
1016 }
1017 
1018 
1025 socklen_t
1027 {
1028  return desc->addrlen;
1029 }
1030 
1031 
1039 void
1041  const fd_set *from,
1042  int nfds)
1043 {
1044  FD_COPY (from,
1045  &to->sds);
1046  to->nsds = nfds;
1047 }
1048 
1049 
1056 void
1058  int nfd)
1059 {
1060  GNUNET_assert ((nfd >= 0) && (nfd < FD_SETSIZE));
1061  FD_SET (nfd, &to->sds);
1062  to->nsds = GNUNET_MAX (nfd + 1,
1063  to->nsds);
1064 }
1065 
1066 
1074 int
1076  int nfd)
1077 {
1078  if ((-1 == nfd) ||
1079  (NULL == to))
1080  return GNUNET_NO;
1081  return FD_ISSET (nfd, &to->sds) ? GNUNET_YES : GNUNET_NO;
1082 }
1083 
1084 
1090 void
1092  const struct GNUNET_DISK_FileHandle *h)
1093 {
1094  int fd;
1095 
1098  &fd,
1099  sizeof(int)));
1100  FD_SET (fd,
1101  &fds->sds);
1102  fds->nsds = GNUNET_MAX (fd + 1,
1103  fds->nsds);
1104 }
1105 
1106 
1112 void
1114  const struct GNUNET_DISK_FileHandle *h)
1115 {
1117 }
1118 
1119 
1127 int
1129  const struct GNUNET_DISK_FileHandle *h)
1130 {
1131  return FD_ISSET (h->fd,
1132  &fds->sds);
1133 }
1134 
1135 
1143 int
1145  const struct GNUNET_NETWORK_FDSet *fds2)
1146 {
1147  int nfds;
1148 
1149  nfds = GNUNET_MIN (fds1->nsds,
1150  fds2->nsds);
1151  while (nfds > 0)
1152  {
1153  nfds--;
1154  if ((FD_ISSET (nfds,
1155  &fds1->sds)) &&
1156  (FD_ISSET (nfds,
1157  &fds2->sds)))
1158  return GNUNET_YES;
1159  }
1160  return GNUNET_NO;
1161 }
1162 
1163 
1169 struct GNUNET_NETWORK_FDSet *
1171 {
1172  struct GNUNET_NETWORK_FDSet *fds;
1173 
1174  fds = GNUNET_new (struct GNUNET_NETWORK_FDSet);
1176  return fds;
1177 }
1178 
1179 
1185 void
1187 {
1188  GNUNET_free (fds);
1189 }
1190 
1191 
1199 int
1201  uint16_t port)
1202 {
1203  struct GNUNET_NETWORK_Handle *socket;
1204  int bind_status;
1205  int socktype;
1206  char open_port_str[6];
1207  struct addrinfo hint;
1208  struct addrinfo *ret;
1209  struct addrinfo *ai;
1210 
1211  GNUNET_snprintf (open_port_str,
1212  sizeof(open_port_str),
1213  "%u",
1214  (unsigned int) port);
1215  socktype = (IPPROTO_TCP == ipproto) ? SOCK_STREAM : SOCK_DGRAM;
1216  ret = NULL;
1217  memset (&hint, 0, sizeof(hint));
1218  hint.ai_family = AF_UNSPEC; /* IPv4 and IPv6 */
1219  hint.ai_socktype = socktype;
1220  hint.ai_protocol = ipproto;
1221  hint.ai_addrlen = 0;
1222  hint.ai_addr = NULL;
1223  hint.ai_canonname = NULL;
1224  hint.ai_next = NULL;
1225  hint.ai_flags = AI_PASSIVE | AI_NUMERICSERV; /* Wild card address */
1226  GNUNET_assert (0 == getaddrinfo (NULL,
1227  open_port_str,
1228  &hint,
1229  &ret));
1230  bind_status = GNUNET_NO;
1231  for (ai = ret; NULL != ai; ai = ai->ai_next)
1232  {
1233  socket = GNUNET_NETWORK_socket_create (ai->ai_family,
1234  ai->ai_socktype,
1235  ai->ai_protocol);
1236  if (NULL == socket)
1237  continue;
1238  bind_status = GNUNET_NETWORK_socket_bind (socket,
1239  ai->ai_addr,
1240  ai->ai_addrlen);
1241  GNUNET_NETWORK_socket_close (socket);
1242  if (GNUNET_OK != bind_status)
1243  break;
1244  }
1245  freeaddrinfo (ret);
1246  return bind_status;
1247 }
1248 
1249 
1259 int
1261  struct GNUNET_NETWORK_FDSet *wfds,
1262  struct GNUNET_NETWORK_FDSet *efds,
1263  const struct GNUNET_TIME_Relative timeout)
1264 {
1265  int nfds;
1266  struct timeval tv;
1267 
1268  if (NULL != rfds)
1269  nfds = rfds->nsds;
1270  else
1271  nfds = 0;
1272  if (NULL != wfds)
1273  nfds = GNUNET_MAX (nfds,
1274  wfds->nsds);
1275  if (NULL != efds)
1276  nfds = GNUNET_MAX (nfds,
1277  efds->nsds);
1278  if ((0 == nfds) &&
1280  {
1281  GNUNET_break (0);
1283  _ (
1284  "Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
1285  "select");
1286  }
1287  if (timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us > (unsigned
1288  long long)
1289  LONG_MAX)
1290  {
1291  tv.tv_sec = LONG_MAX;
1292  tv.tv_usec = 999999L;
1293  }
1294  else
1295  {
1296  tv.tv_sec = (long) (timeout.rel_value_us
1297  / GNUNET_TIME_UNIT_SECONDS.rel_value_us);
1298  tv.tv_usec =
1300  - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value_us));
1301  }
1302  return select (nfds,
1303  (NULL != rfds) ? &rfds->sds : NULL,
1304  (NULL != wfds) ? &wfds->sds : NULL,
1305  (NULL != efds) ? &efds->sds : NULL,
1306  (timeout.rel_value_us ==
1307  GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) ? NULL : &tv);
1308 }
1309 
1310 
1311 /* end of network.c */
enum GNUNET_GenericReturnValue GNUNET_DISK_internal_file_handle_(const struct GNUNET_DISK_FileHandle *fh, void *dst, size_t dst_len)
Retrieve OS file handle.
Definition: disk.c:1632
Internal DISK related helper functions.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static struct SolverHandle * sh
static uint16_t port
Port number.
Definition: gnunet-bcd.c:147
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static char * address
GNS address for this phone.
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static char * value
Value of the record to add/remove.
static unsigned int pending
The number of queries that are outstanding.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void GNUNET_CRYPTO_hash_to_enc(const struct GNUNET_HashCode *block, struct GNUNET_CRYPTO_HashAsciiEncoded *result)
Convert hash to ASCII encoding.
Definition: crypto_hash.c:55
#define GNUNET_log(kind,...)
#define GNUNET_MAX(a, b)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
#define GNUNET_MIN(a, b)
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages).
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_BULK
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
struct sockaddr * GNUNET_NETWORK_get_addr(const struct GNUNET_NETWORK_Handle *desc)
Return sockaddr for this network handle.
Definition: network.c:1013
void GNUNET_NETWORK_fdset_handle_set_first(struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_DISK_FileHandle *h)
Add a file handle to the fd set.
Definition: network.c:1113
int GNUNET_NETWORK_socket_getsockopt(const struct GNUNET_NETWORK_Handle *desc, int level, int optname, void *optval, socklen_t *optlen)
Get socket options.
Definition: network.c:626
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create()
Creates an fd set.
Definition: network.c:1170
void GNUNET_NETWORK_fdset_zero(struct GNUNET_NETWORK_FDSet *fds)
Reset FD set.
Definition: network.c:917
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:508
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1186
socklen_t GNUNET_NETWORK_get_addrlen(const struct GNUNET_NETWORK_Handle *desc)
Return sockaddr length for this network handle.
Definition: network.c:1026
int GNUNET_NETWORK_get_fd(const struct GNUNET_NETWORK_Handle *desc)
Return file descriptor for this network handle.
Definition: network.c:1000
void GNUNET_NETWORK_fdset_copy_native(struct GNUNET_NETWORK_FDSet *to, const fd_set *from, int nfds)
Copy a native fd set.
Definition: network.c:1040
int GNUNET_NETWORK_test_port_free(int ipproto, uint16_t port)
Test if the given port is available.
Definition: network.c:1200
int GNUNET_NETWORK_fdset_overlap(const struct GNUNET_NETWORK_FDSet *fds1, const struct GNUNET_NETWORK_FDSet *fds2)
Checks if two fd sets overlap.
Definition: network.c:1144
ssize_t GNUNET_NETWORK_socket_recv(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length)
Read data from a connected socket (always non-blocking).
Definition: network.c:716
ssize_t GNUNET_NETWORK_socket_recvfrom(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length, struct sockaddr *src_addr, socklen_t *addrlen)
Read data from a socket (always non-blocking).
Definition: network.c:687
void GNUNET_NETWORK_fdset_add(struct GNUNET_NETWORK_FDSet *dst, const struct GNUNET_NETWORK_FDSet *src)
Add one fd set to another.
Definition: network.c:964
void GNUNET_NETWORK_fdset_set_native(struct GNUNET_NETWORK_FDSet *to, int nfd)
Set a native fd in a set.
Definition: network.c:1057
void GNUNET_NETWORK_fdset_copy(struct GNUNET_NETWORK_FDSet *to, const struct GNUNET_NETWORK_FDSet *from)
Copy one fd set to another.
Definition: network.c:984
int GNUNET_NETWORK_socket_connect(const struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Connect a socket to some remote address.
Definition: network.c:601
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_accept(const struct GNUNET_NETWORK_Handle *desc, struct sockaddr *address, socklen_t *address_len)
Accept a new connection on a socket.
Definition: network.c:392
ssize_t GNUNET_NETWORK_socket_recvfrom_amount(const struct GNUNET_NETWORK_Handle *desc)
How much data is available to be read on this descriptor?
Definition: network.c:670
int GNUNET_NETWORK_fdset_test_native(const struct GNUNET_NETWORK_FDSet *to, int nfd)
Test native fd in a set.
Definition: network.c:1075
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:832
void GNUNET_NETWORK_fdset_set(struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_NETWORK_Handle *desc)
Add a socket to the FD set.
Definition: network.c:931
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_set_blocking(struct GNUNET_NETWORK_Handle *fd, int doBlock)
Set if a socket should use blocking or non-blocking IO.
Definition: network.c:224
void GNUNET_NETWORK_socket_free_memory_only_(struct GNUNET_NETWORK_Handle *desc)
Only free memory of a socket, keep the file descriptor untouched.
Definition: network.c:565
char * GNUNET_NETWORK_shorten_unixpath(char *unixpath)
Given a unixpath that is too long (larger than UNIX_PATH_MAX), shorten it to an acceptable length whi...
Definition: network.c:143
ssize_t GNUNET_NETWORK_socket_send(const struct GNUNET_NETWORK_Handle *desc, const void *buffer, size_t length)
Send data (always non-blocking).
Definition: network.c:737
enum GNUNET_GenericReturnValue GNUNET_NETWORK_test_pf(int pf)
Test if the given protocol family is supported by this system.
Definition: network.c:79
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_bind(struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Bind a socket to a particular address.
Definition: network.c:439
int GNUNET_NETWORK_socket_listen(const struct GNUNET_NETWORK_Handle *desc, int backlog)
Listen on a socket.
Definition: network.c:651
void GNUNET_NETWORK_unix_precheck(const struct sockaddr_un *un)
If services crash, they can leave a unix domain socket file on the disk.
Definition: network.c:178
int GNUNET_NETWORK_fdset_handle_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_DISK_FileHandle *h)
Check if a file handle is part of an fd set.
Definition: network.c:1128
int GNUNET_NETWORK_socket_select(struct GNUNET_NETWORK_FDSet *rfds, struct GNUNET_NETWORK_FDSet *wfds, struct GNUNET_NETWORK_FDSet *efds, const struct GNUNET_TIME_Relative timeout)
Check if sockets or pipes meet certain conditions.
Definition: network.c:1260
int GNUNET_NETWORK_socket_shutdown(struct GNUNET_NETWORK_Handle *desc, int how)
Shut down socket operations.
Definition: network.c:860
int GNUNET_NETWORK_socket_setsockopt(struct GNUNET_NETWORK_Handle *fd, int level, int option_name, const void *option_value, socklen_t option_len)
Set socket option.
Definition: network.c:805
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition: network.c:771
int GNUNET_NETWORK_fdset_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_NETWORK_Handle *desc)
Check whether a socket is part of the fd set.
Definition: network.c:949
int GNUNET_NETWORK_socket_disable_corking(struct GNUNET_NETWORK_Handle *desc)
Disable the "CORK" feature for communication with the given socket, forcing the OS to immediately flu...
Definition: network.c:881
void GNUNET_NETWORK_fdset_handle_set(struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_DISK_FileHandle *h)
Add a file handle to the fd set.
Definition: network.c:1091
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_box_native(int fd)
Box a native socket (and check that it is a socket).
Definition: network.c:579
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_TIME_UNIT_SECONDS
One second.
static int initialize_network_handle(struct GNUNET_NETWORK_Handle *h, int af, int type)
Perform proper canonical initialization for a network handle.
Definition: network.c:335
#define INVALID_SOCKET
Definition: network.c:45
static void socket_set_nodelay(const struct GNUNET_NETWORK_Handle *h)
Disable delays when sending data via the socket.
Definition: network.c:308
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: network.c:32
#define LOG(kind,...)
Definition: network.c:31
#define LOG_STRERROR(kind, syscall)
Definition: network.c:37
static int socket_set_inheritable(const struct GNUNET_NETWORK_Handle *h)
Make a socket non-inheritable to child processes.
Definition: network.c:261
#define FD_COPY(s, d)
Definition: network.c:219
#define DIR_SEPARATOR
Definition: platform.h:164
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
#define AI_NUMERICSERV
AI_NUMERICSERV not defined in windows.
Definition: platform.h:218
const char * name
0-terminated ASCII encoding of a struct GNUNET_HashCode.
Handle used to access files (and pipes).
A 512-bit hashcode.
collection of IO descriptors
int nsds
Maximum number of any socket descriptor in the set (plus one)
fd_set sds
Bitset with the descriptors.
handle to a socket
Definition: network.c:53
struct sockaddr * addr
Address we were bound to, or NULL.
Definition: network.c:74
int type
Type of the socket.
Definition: network.c:64
socklen_t addrlen
Number of bytes in addr.
Definition: network.c:69
int af
Address family / domain.
Definition: network.c:59
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model