GNUnet  0.11.x
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 
27 #include "platform.h"
28 #include "gnunet_util_lib.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 
84 int
86 {
87  static int cache_v4 = -1;
88  static int cache_v6 = -1;
89  static int cache_un = -1;
90  int s;
91  int ret;
92 
93  switch (pf)
94  {
95  case PF_INET:
96  if (-1 != cache_v4)
97  return cache_v4;
98  break;
99 
100  case PF_INET6:
101  if (-1 != cache_v6)
102  return cache_v6;
103  break;
104 
105 #ifdef PF_UNIX
106  case PF_UNIX:
107  if (-1 != cache_un)
108  return cache_un;
109  break;
110 #endif
111  }
112  s = socket (pf, SOCK_STREAM, 0);
113  if (-1 == s)
114  {
115  if (EAFNOSUPPORT != errno)
116  {
118  "socket");
119  return GNUNET_SYSERR;
120  }
121  ret = GNUNET_NO;
122  }
123  else
124  {
125  close (s);
126  ret = GNUNET_OK;
127  }
128  switch (pf)
129  {
130  case PF_INET:
131  cache_v4 = ret;
132  break;
133 
134  case PF_INET6:
135  cache_v6 = ret;
136  break;
137 
138 #ifdef PF_UNIX
139  case PF_UNIX:
140  cache_un = ret;
141  break;
142 #endif
143  }
144  return ret;
145 }
146 
147 
157 char *
159 {
160  struct sockaddr_un dummy;
161  size_t slen;
162  char *end;
163  struct GNUNET_HashCode sh;
165  size_t upm;
166 
167  upm = sizeof(dummy.sun_path);
168  slen = strlen (unixpath);
169  if (slen < upm)
170  return unixpath; /* no shortening required */
171  GNUNET_CRYPTO_hash (unixpath, slen, &sh);
172  while (16 + strlen (unixpath) >= upm)
173  {
174  if (NULL == (end = strrchr (unixpath, '/')))
175  {
177  _ (
178  "Unable to shorten unix path `%s' while keeping name unique\n"),
179  unixpath);
180  GNUNET_free (unixpath);
181  return NULL;
182  }
183  *end = '\0';
184  }
185  GNUNET_CRYPTO_hash_to_enc (&sh, &ae);
186  ae.encoding[16] = '\0';
187  strcat (unixpath, (char *) ae.encoding);
188  return unixpath;
189 }
190 
191 
201 void
202 GNUNET_NETWORK_unix_precheck (const struct sockaddr_un *un)
203 {
204  int s;
205  int eno;
206  struct stat sbuf;
207  int ret;
208 
209  s = socket (AF_UNIX, SOCK_STREAM, 0);
210  if (-1 == s)
211  {
213  "Failed to open AF_UNIX socket");
214  return;
215  }
216  ret = connect (s,
217  (struct sockaddr *) un,
218  sizeof(struct sockaddr_un));
219  eno = errno;
220  GNUNET_break (0 == close (s));
221  if (0 == ret)
222  return; /* another process is listening, do not remove! */
223  if (ECONNREFUSED != eno)
224  return; /* some other error, likely "no such file or directory" -- all well */
225  /* should unlink, but sanity checks first */
226  if (0 != stat (un->sun_path,
227  &sbuf))
228  return; /* failed to 'stat', likely does not exist after all */
229  if (S_IFSOCK != (S_IFMT & sbuf.st_mode))
230  return; /* refuse to unlink anything except sockets */
231  /* finally, really unlink */
233  "Removing left-over `%s' from previous exeuction\n",
234  un->sun_path);
235  if (0 != unlink (un->sun_path))
237  "unlink",
238  un->sun_path);
239 }
240 
241 
242 #ifndef FD_COPY
243 #define FD_COPY(s, d) do { GNUNET_memcpy ((d), (s), sizeof(fd_set)); } while (0)
244 #endif
245 
246 
254 int
256  int doBlock)
257 {
258  int flags = fcntl (fd->fd, F_GETFL);
259 
260  if (flags == -1)
261  {
263  "fcntl");
264  return GNUNET_SYSERR;
265  }
266  if (doBlock)
267  flags &= ~O_NONBLOCK;
268 
269  else
270  flags |= O_NONBLOCK;
271  if (0 != fcntl (fd->fd,
272  F_SETFL,
273  flags))
274 
275  {
277  "fcntl");
278  return GNUNET_SYSERR;
279  }
280  return GNUNET_OK;
281 }
282 
283 
291 static int
293 {
294  int i;
295  i = fcntl (h->fd, F_GETFD);
296  if (i < 0)
297  return GNUNET_SYSERR;
298  if (i == (i | FD_CLOEXEC))
299  return GNUNET_OK;
300  i |= FD_CLOEXEC;
301  if (fcntl (h->fd, F_SETFD, i) < 0)
302  return GNUNET_SYSERR;
303 
304  return GNUNET_OK;
305 }
306 
307 
308 #ifdef DARWIN
309 
314 static int
315 socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle *h)
316 {
317  int abs_value = 1;
318 
319  if (0 !=
320  setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE,
321  (const void *) &abs_value,
322  sizeof(abs_value)))
323  return GNUNET_SYSERR;
324  return GNUNET_OK;
325 }
326 
327 
328 #endif
329 
330 
338 static void
340 {
341  int value = 1;
342 
343  if (0 !=
344  setsockopt (h->fd,
345  IPPROTO_TCP,
346  TCP_NODELAY,
347  &value, sizeof(value)))
349  "setsockopt");
350 }
351 
352 
365 static int
367  int af,
368  int type)
369 {
370  int eno;
371 
372  h->af = af;
373  h->type = type;
374  if (h->fd == INVALID_SOCKET)
375  {
376  eno = errno;
377  GNUNET_free (h);
378  errno = eno;
379  return GNUNET_SYSERR;
380  }
381 
382  if (h->fd >= FD_SETSIZE)
383  {
385  errno = EMFILE;
386  return GNUNET_SYSERR;
387  }
388 
391  "socket_set_inheritable");
392 
394  {
395  eno = errno;
396  GNUNET_break (0);
398  errno = eno;
399  return GNUNET_SYSERR;
400  }
401 #ifdef DARWIN
402  if (GNUNET_SYSERR == socket_set_nosigpipe (h))
403  {
404  eno = errno;
405  GNUNET_break (0);
407  errno = eno;
408  return GNUNET_SYSERR;
409  }
410 #endif
411  if ((type == SOCK_STREAM)
412 #ifdef AF_UNIX
413  && (af != AF_UNIX)
414 #endif
415  )
416  socket_set_nodelay (h);
417  return GNUNET_OK;
418 }
419 
420 
429 struct GNUNET_NETWORK_Handle *
431  struct sockaddr *address,
432  socklen_t *address_len)
433 {
434  struct GNUNET_NETWORK_Handle *ret;
435  int eno;
436 
437  ret = GNUNET_new (struct GNUNET_NETWORK_Handle);
438 #if DEBUG_NETWORK
439  {
440  struct sockaddr_storage name;
441  socklen_t namelen = sizeof(name);
442 
443  int gsn = getsockname (desc->fd,
444  (struct sockaddr *) &name,
445  &namelen);
446 
447  if (0 == gsn)
449  "Accepting connection on `%s'\n",
450  GNUNET_a2s ((const struct sockaddr *) &name,
451  namelen));
452  }
453 #endif
454  ret->fd = accept (desc->fd,
455  address,
456  address_len);
457  if (-1 == ret->fd)
458  {
459  eno = errno;
460  GNUNET_free (ret);
461  errno = eno;
462  return NULL;
463  }
464  if (GNUNET_OK !=
466  (NULL != address) ? address->sa_family :
467  desc->af,
468  SOCK_STREAM))
469  {
470  return NULL;
471  }
472  return ret;
473 }
474 
475 
484 int
486  const struct sockaddr *address,
487  socklen_t address_len)
488 {
489  int ret;
490 
491 #ifdef IPV6_V6ONLY
492 #ifdef IPPROTO_IPV6
493  {
494  const int on = 1;
495 
496  if (AF_INET6 == desc->af)
497  if (setsockopt (desc->fd,
498  IPPROTO_IPV6,
499  IPV6_V6ONLY,
500  (const void *) &on,
501  sizeof(on)))
503  "setsockopt");
504  }
505 #endif
506 #endif
507  if (AF_UNIX == address->sa_family)
508  GNUNET_NETWORK_unix_precheck ((const struct sockaddr_un *) address);
509  {
510  const int on = 1;
511 
512  /* This is required here for TCP sockets, but only on UNIX */
513  if ((SOCK_STREAM == desc->type) &&
514  (0 != setsockopt (desc->fd,
515  SOL_SOCKET,
516  SO_REUSEADDR,
517  &on, sizeof(on))))
519  "setsockopt");
520  }
521  {
522  /* set permissions of newly created non-abstract UNIX domain socket to
523  "user-only"; applications can choose to relax this later */
524  mode_t old_mask = 0; /* assigned to make compiler happy */
525  const struct sockaddr_un *un = (const struct sockaddr_un *) address;
526  int not_abstract = 0;
527 
528  if ((AF_UNIX == address->sa_family)
529  && ('\0' != un->sun_path[0])) /* Not an abstract socket */
530  not_abstract = 1;
531  if (not_abstract)
532  old_mask = umask (S_IWGRP | S_IRGRP | S_IXGRP | S_IWOTH | S_IROTH
533  | S_IXOTH);
534 
535  ret = bind (desc->fd,
536  address,
537  address_len);
538 
539  if (not_abstract)
540  (void) umask (old_mask);
541  }
542  if (0 != ret)
543  return GNUNET_SYSERR;
544 
545  desc->addr = GNUNET_malloc (address_len);
546  GNUNET_memcpy (desc->addr, address, address_len);
547  desc->addrlen = address_len;
548 
549  return GNUNET_OK;
550 }
551 
552 
559 int
561 {
562  int ret;
563 
564  ret = close (desc->fd);
565 
566  const struct sockaddr_un *un = (const struct sockaddr_un *) desc->addr;
567 
568  /* Cleanup the UNIX domain socket and its parent directories in case of non
569  abstract sockets */
570  if ((AF_UNIX == desc->af) &&
571  (NULL != desc->addr) &&
572  ('\0' != un->sun_path[0]))
573  {
574  char *dirname = GNUNET_strndup (un->sun_path,
575  sizeof(un->sun_path));
576 
577  if (0 != unlink (dirname))
578  {
580  "unlink",
581  dirname);
582  }
583  else
584  {
585  size_t len;
586 
587  len = strlen (dirname);
588  while ((len > 0) && (dirname[len] != DIR_SEPARATOR))
589  len--;
590  dirname[len] = '\0';
591  if ((0 != len) && (0 != rmdir (dirname)))
592  {
593  switch (errno)
594  {
595  case EACCES:
596  case ENOTEMPTY:
597  case EPERM:
598  /* these are normal and can just be ignored */
599  break;
600 
601  default:
603  "rmdir",
604  dirname);
605  break;
606  }
607  }
608  }
609  GNUNET_free (dirname);
610  }
612  return (ret == 0) ? GNUNET_OK : GNUNET_SYSERR;
613 }
614 
615 
621 void
623 {
624  GNUNET_free_non_null (desc->addr);
625  GNUNET_free (desc);
626 }
627 
628 
635 struct GNUNET_NETWORK_Handle *
637 {
638  struct GNUNET_NETWORK_Handle *ret;
639 
640  if (fcntl (fd, F_GETFD) < 0)
641  return NULL; /* invalid FD */
642  ret = GNUNET_new (struct GNUNET_NETWORK_Handle);
643  ret->fd = fd;
644  ret->af = AF_UNSPEC;
645  return ret;
646 }
647 
648 
657 int
659  const struct sockaddr *address,
660  socklen_t address_len)
661 {
662  int ret;
663 
664  ret = connect (desc->fd,
665  address,
666  address_len);
667 
668  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
669 }
670 
671 
682 int
684  int level,
685  int optname,
686  void *optval,
687  socklen_t *optlen)
688 {
689  int ret;
690 
691  ret = getsockopt (desc->fd,
692  level,
693  optname,
694  optval, optlen);
695 
696  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
697 }
698 
699 
707 int
709  int backlog)
710 {
711  int ret;
712 
713  ret = listen (desc->fd,
714  backlog);
715 
716  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
717 }
718 
719 
726 ssize_t
728 {
729  int error;
730 
731  /* How much is there to be read? */
732  int pending;
733 
734  error = ioctl (desc->fd,
735  FIONREAD,
736  &pending);
737  if (0 == error)
738  return (ssize_t) pending;
739  return GNUNET_SYSERR;
740 }
741 
742 
753 ssize_t
755  void *buffer,
756  size_t length,
757  struct sockaddr *src_addr,
758  socklen_t *addrlen)
759 {
760  int ret;
761  int flags;
762 
763  flags = 0;
764 
765 #ifdef MSG_DONTWAIT
766  flags |= MSG_DONTWAIT;
767 #endif
768  ret = recvfrom (desc->fd,
769  buffer,
770  length,
771  flags,
772  src_addr,
773  addrlen);
774  return ret;
775 }
776 
777 
786 ssize_t
788  void *buffer,
789  size_t length)
790 {
791  int ret;
792  int flags;
793 
794  flags = 0;
795 
796 #ifdef MSG_DONTWAIT
797  flags |= MSG_DONTWAIT;
798 #endif
799  ret = recv (desc->fd,
800  buffer,
801  length,
802  flags);
803  return ret;
804 }
805 
806 
815 ssize_t
817  const void *buffer,
818  size_t length)
819 {
820  int ret;
821  int flags;
822 
823  flags = 0;
824 #ifdef MSG_DONTWAIT
825  flags |= MSG_DONTWAIT;
826 #endif
827 #ifdef MSG_NOSIGNAL
828  flags |= MSG_NOSIGNAL;
829 #endif
830  ret = send (desc->fd,
831  buffer,
832  length,
833  flags);
834  return ret;
835 }
836 
837 
849 ssize_t
851  const void *message,
852  size_t length,
853  const struct sockaddr *dest_addr,
854  socklen_t dest_len)
855 {
856  int ret;
857  int flags;
858 
859  flags = 0;
860 
861 #ifdef MSG_DONTWAIT
862  flags |= MSG_DONTWAIT;
863 #endif
864 #ifdef MSG_NOSIGNAL
865  flags |= MSG_NOSIGNAL;
866 #endif
867  ret = sendto (desc->fd, message, length, flags, dest_addr, dest_len);
868  return ret;
869 }
870 
871 
882 int
884  int level,
885  int option_name,
886  const void *option_value,
887  socklen_t option_len)
888 {
889  int ret;
890 
891  ret = setsockopt (fd->fd,
892  level,
893  option_name,
894  option_value,
895  option_len);
896 
897  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
898 }
899 
900 
911 struct GNUNET_NETWORK_Handle *
913  int type,
914  int protocol)
915 {
916  struct GNUNET_NETWORK_Handle *ret;
917  int fd;
918 
919  fd = socket (domain, type, protocol);
920  if (-1 == fd)
921  return NULL;
922  ret = GNUNET_new (struct GNUNET_NETWORK_Handle);
923  ret->fd = fd;
924  if (GNUNET_OK !=
926  domain,
927  type))
928  return NULL;
929  return ret;
930 }
931 
932 
939 int
941  int how)
942 {
943  int ret;
944 
945  ret = shutdown (desc->fd, how);
946 
947  return (0 == ret) ? GNUNET_OK : GNUNET_SYSERR;
948 }
949 
950 
960 int
962 {
963  int ret = 0;
964 
965 #if LINUX
966  int value = 0;
967 
968  if (0 !=
969  (ret =
970  setsockopt (desc->fd,
971  SOL_SOCKET,
972  SO_SNDBUF,
973  &value,
974  sizeof(value))))
976  "setsockopt");
977  if (0 !=
978  (ret =
979  setsockopt (desc->fd,
980  SOL_SOCKET,
981  SO_RCVBUF,
982  &value,
983  sizeof(value))))
985  "setsockopt");
986 #endif
987  return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
988 }
989 
990 
996 void
998 {
999  FD_ZERO (&fds->sds);
1000  fds->nsds = 0;
1001 }
1002 
1003 
1010 void
1012  const struct GNUNET_NETWORK_Handle *desc)
1013 {
1014  FD_SET (desc->fd,
1015  &fds->sds);
1016  fds->nsds = GNUNET_MAX (fds->nsds,
1017  desc->fd + 1);
1018 }
1019 
1020 
1028 int
1030  const struct GNUNET_NETWORK_Handle *desc)
1031 {
1032  return FD_ISSET (desc->fd,
1033  &fds->sds);
1034 }
1035 
1036 
1043 void
1045  const struct GNUNET_NETWORK_FDSet *src)
1046 {
1047  int nfds;
1048 
1049  for (nfds = src->nsds; nfds >= 0; nfds--)
1050  if (FD_ISSET (nfds, &src->sds))
1051  FD_SET (nfds, &dst->sds);
1052  dst->nsds = GNUNET_MAX (dst->nsds,
1053  src->nsds);
1054 }
1055 
1056 
1063 void
1065  const struct GNUNET_NETWORK_FDSet *from)
1066 {
1067  FD_COPY (&from->sds,
1068  &to->sds);
1069  to->nsds = from->nsds;
1070 }
1071 
1072 
1079 int
1081 {
1082  return desc->fd;
1083 }
1084 
1085 
1092 struct sockaddr*
1094 {
1095  return desc->addr;
1096 }
1097 
1098 
1105 socklen_t
1107 {
1108  return desc->addrlen;
1109 }
1110 
1111 
1119 void
1121  const fd_set *from,
1122  int nfds)
1123 {
1124  FD_COPY (from,
1125  &to->sds);
1126  to->nsds = nfds;
1127 }
1128 
1129 
1136 void
1138  int nfd)
1139 {
1140  GNUNET_assert ((nfd >= 0) && (nfd < FD_SETSIZE));
1141  FD_SET (nfd, &to->sds);
1142  to->nsds = GNUNET_MAX (nfd + 1,
1143  to->nsds);
1144 }
1145 
1146 
1154 int
1156  int nfd)
1157 {
1158  if ((-1 == nfd) ||
1159  (NULL == to))
1160  return GNUNET_NO;
1161  return FD_ISSET (nfd, &to->sds) ? GNUNET_YES : GNUNET_NO;
1162 }
1163 
1164 
1170 void
1172  const struct GNUNET_DISK_FileHandle *h)
1173 {
1174  int fd;
1175 
1178  &fd,
1179  sizeof(int)));
1180  FD_SET (fd,
1181  &fds->sds);
1182  fds->nsds = GNUNET_MAX (fd + 1,
1183  fds->nsds);
1184 }
1185 
1186 
1192 void
1194  const struct GNUNET_DISK_FileHandle *h)
1195 {
1197 }
1198 
1199 
1207 int
1209  const struct GNUNET_DISK_FileHandle *h)
1210 {
1211  return FD_ISSET (h->fd,
1212  &fds->sds);
1213 }
1214 
1215 
1223 int
1225  const struct GNUNET_NETWORK_FDSet *fds2)
1226 {
1227  int nfds;
1228 
1229  nfds = GNUNET_MIN (fds1->nsds,
1230  fds2->nsds);
1231  while (nfds > 0)
1232  {
1233  nfds--;
1234  if ((FD_ISSET (nfds,
1235  &fds1->sds)) &&
1236  (FD_ISSET (nfds,
1237  &fds2->sds)))
1238  return GNUNET_YES;
1239  }
1240  return GNUNET_NO;
1241 }
1242 
1243 
1249 struct GNUNET_NETWORK_FDSet *
1251 {
1252  struct GNUNET_NETWORK_FDSet *fds;
1253 
1254  fds = GNUNET_new (struct GNUNET_NETWORK_FDSet);
1256  return fds;
1257 }
1258 
1259 
1265 void
1267 {
1268  GNUNET_free (fds);
1269 }
1270 
1271 
1279 int
1281  uint16_t port)
1282 {
1283  struct GNUNET_NETWORK_Handle *socket;
1284  int bind_status;
1285  int socktype;
1286  char open_port_str[6];
1287  struct addrinfo hint;
1288  struct addrinfo *ret;
1289  struct addrinfo *ai;
1290 
1291  GNUNET_snprintf (open_port_str,
1292  sizeof(open_port_str),
1293  "%u",
1294  (unsigned int) port);
1295  socktype = (IPPROTO_TCP == ipproto) ? SOCK_STREAM : SOCK_DGRAM;
1296  ret = NULL;
1297  memset (&hint, 0, sizeof(hint));
1298  hint.ai_family = AF_UNSPEC; /* IPv4 and IPv6 */
1299  hint.ai_socktype = socktype;
1300  hint.ai_protocol = ipproto;
1301  hint.ai_addrlen = 0;
1302  hint.ai_addr = NULL;
1303  hint.ai_canonname = NULL;
1304  hint.ai_next = NULL;
1305  hint.ai_flags = AI_PASSIVE | AI_NUMERICSERV; /* Wild card address */
1306  GNUNET_assert (0 == getaddrinfo (NULL,
1307  open_port_str,
1308  &hint,
1309  &ret));
1310  bind_status = GNUNET_NO;
1311  for (ai = ret; NULL != ai; ai = ai->ai_next)
1312  {
1313  socket = GNUNET_NETWORK_socket_create (ai->ai_family,
1314  ai->ai_socktype,
1315  ai->ai_protocol);
1316  if (NULL == socket)
1317  continue;
1318  bind_status = GNUNET_NETWORK_socket_bind (socket,
1319  ai->ai_addr,
1320  ai->ai_addrlen);
1321  GNUNET_NETWORK_socket_close (socket);
1322  if (GNUNET_OK != bind_status)
1323  break;
1324  }
1325  freeaddrinfo (ret);
1326  return bind_status;
1327 }
1328 
1329 
1339 int
1341  struct GNUNET_NETWORK_FDSet *wfds,
1342  struct GNUNET_NETWORK_FDSet *efds,
1343  const struct GNUNET_TIME_Relative timeout)
1344 {
1345  int nfds;
1346  struct timeval tv;
1347 
1348  if (NULL != rfds)
1349  nfds = rfds->nsds;
1350  else
1351  nfds = 0;
1352  if (NULL != wfds)
1353  nfds = GNUNET_MAX (nfds,
1354  wfds->nsds);
1355  if (NULL != efds)
1356  nfds = GNUNET_MAX (nfds,
1357  efds->nsds);
1358  if ((0 == nfds) &&
1359  (timeout.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us))
1360  {
1361  GNUNET_break (0);
1363  _ (
1364  "Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),
1365  "select");
1366  }
1367  if (timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us > (unsigned
1368  long long)
1369  LONG_MAX)
1370  {
1371  tv.tv_sec = LONG_MAX;
1372  tv.tv_usec = 999999L;
1373  }
1374  else
1375  {
1376  tv.tv_sec = (long) (timeout.rel_value_us
1377  / GNUNET_TIME_UNIT_SECONDS.rel_value_us);
1378  tv.tv_usec =
1379  (timeout.rel_value_us
1380  - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value_us));
1381  }
1382  return select (nfds,
1383  (NULL != rfds) ? &rfds->sds : NULL,
1384  (NULL != wfds) ? &wfds->sds : NULL,
1385  (NULL != efds) ? &efds->sds : NULL,
1386  (timeout.rel_value_us ==
1387  GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) ? NULL : &tv);
1388 }
1389 
1390 
1391 /* end of network.c */
int GNUNET_NETWORK_socket_listen(const struct GNUNET_NETWORK_Handle *desc, int backlog)
Listen on a socket.
Definition: network.c:708
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:883
int GNUNET_NETWORK_get_fd(const struct GNUNET_NETWORK_Handle *desc)
Return file descriptor for this network handle.
Definition: network.c:1080
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:1224
int 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:255
struct sockaddr * GNUNET_NETWORK_get_addr(const struct GNUNET_NETWORK_Handle *desc)
Return sockaddr for this network handle.
Definition: network.c:1093
int nsds
Maximum number of any socket descriptor in the set (plus one)
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:366
uint64_t rel_value_us
The actual value.
#define AI_NUMERICSERV
AI_NUMERICSERV not defined in windows.
Definition: platform.h:227
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
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:816
socklen_t GNUNET_NETWORK_get_addrlen(const struct GNUNET_NETWORK_Handle *desc)
Return sockaddr length for this network handle.
Definition: network.c:1106
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
void GNUNET_NETWORK_fdset_set_native(struct GNUNET_NETWORK_FDSet *to, int nfd)
Set a native fd in a set.
Definition: network.c:1137
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:787
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_TIME_UNIT_SECONDS
One second.
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:683
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:961
int 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:485
int GNUNET_NETWORK_fdset_test_native(const struct GNUNET_NETWORK_FDSet *to, int nfd)
Test native fd in a set.
Definition: network.c:1155
#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
#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.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
int GNUNET_NETWORK_socket_shutdown(struct GNUNET_NETWORK_Handle *desc, int how)
Shut down socket operations.
Definition: network.c:940
static int socket_set_inheritable(const struct GNUNET_NETWORK_Handle *h)
Make a socket non-inheritable to child processes.
Definition: network.c:292
#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
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:1120
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static void socket_set_nodelay(const struct GNUNET_NETWORK_Handle *h)
Disable delays when sending data via the socket.
Definition: network.c:339
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:622
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:430
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1266
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create()
Creates an fd set.
Definition: network.c:1250
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:658
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
static char * value
Value of the record to add/remove.
#define INVALID_SOCKET
Definition: network.c:45
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: network.c:32
#define GNUNET_MAX(a, b)
Definition: gnunet_common.h:82
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:80
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:850
collection of IO descriptors
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
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)...
A 512-bit hashcode.
struct sockaddr * addr
Address we were bound to, or NULL.
Definition: network.c:74
#define DIR_SEPARATOR
Definition: platform.h:167
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:1340
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:73
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
int GNUNET_DISK_internal_file_handle_(const struct GNUNET_DISK_FileHandle *fh, void *dst, size_t dst_len)
Retrieve OS file handle.
Definition: disk.c:1778
void GNUNET_NETWORK_fdset_zero(struct GNUNET_NETWORK_FDSet *fds)
Reset FD set.
Definition: network.c:997
static unsigned int pending
The number of queries that are outstanding.
fd_set sds
Bitset with the descriptors.
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:1171
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:1011
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:1208
0-terminated ASCII encoding of a struct GNUNET_HashCode.
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
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:1064
socklen_t addrlen
Number of bytes in addr.
Definition: network.c:69
const char * name
#define FD_COPY(s, d)
Definition: network.c:243
int GNUNET_NETWORK_test_port_free(int ipproto, uint16_t port)
Test if the given port is available.
Definition: network.c:1280
#define LOG_STRERROR(kind, syscall)
Definition: network.c:37
#define LOG(kind,...)
Definition: network.c:31
#define GNUNET_log(kind,...)
handle to a socket
Definition: network.c:52
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:158
int af
Address family / domain.
Definition: network.c:59
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:727
#define GNUNET_YES
Definition: gnunet_common.h:77
int fd
File handle on Unix-like systems.
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:202
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:636
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:1029
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:754
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:1044
static char * address
GNS address for this phone.
Handle used to access files (and pipes).
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
int type
Type of the socket.
Definition: network.c:64
#define GNUNET_malloc(size)
Wrapper around malloc.
int GNUNET_NETWORK_test_pf(int pf)
Test if the given protocol family is supported by this system.
Definition: network.c:85
Internal DISK related helper functions.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:912
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:1193