GNUnet  0.11.x
gnunet-communicator-tcp.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2010-2014, 2018, 2019 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 
30 #include "platform.h"
31 #include "gnunet_util_lib.h"
32 #include "gnunet_core_service.h"
34 #include "gnunet_protocols.h"
35 #include "gnunet_signatures.h"
36 #include "gnunet_constants.h"
37 #include "gnunet_nt_lib.h"
38 #include "gnunet_nat_service.h"
42 
47 #define ADDRESS_VALIDITY_PERIOD \
48  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
49 
58 #define DEFAULT_MAX_QUEUE_LENGTH 8
59 
64 #define BUF_SIZE (2 * 64 * 1024 + sizeof(struct TCPBox))
65 
69 #define DEFAULT_REKEY_INTERVAL GNUNET_TIME_UNIT_DAYS
70 
74 #define PROTO_QUEUE_TIMEOUT GNUNET_TIME_UNIT_MINUTES
75 
80 #define REKEY_MAX_BYTES (1024LLU * 1024 * 1024 * 4LLU)
81 
86 #define INITIAL_KX_SIZE \
87  (sizeof(struct GNUNET_CRYPTO_EcdhePublicKey) \
88  + sizeof(struct TCPConfirmation))
89 
93 #define INITIAL_CORE_KX_SIZE \
94  (sizeof(struct EphemeralKeyMessage) \
95  + sizeof(struct PingMessage) \
96  + sizeof(struct PongMessage))
97 
101 #define COMMUNICATOR_ADDRESS_PREFIX "tcp"
102 
106 #define COMMUNICATOR_CONFIG_SECTION "communicator-tcp"
107 
109 
110 
116 {
121 
126 
131 
136 
142 
146  struct ChallengeNonceP challenge;
147 };
148 
154 {
159 
164 
169 
175 
179  struct ChallengeNonceP challenge;
180 };
181 
186 {
191 
196 
202 
206  struct ChallengeNonceP challenge;
207 
208 };
209 
214 {
215 
216 
221 
226 
231 
237 
241  struct ChallengeNonceP challenge;
242 
243 };
244 
248 struct TCPBox
249 {
257 
266  struct GNUNET_ShortHashCode hmac;
267 
268  /* followed by as may bytes of payload as indicated in @e header,
269  excluding the TCPBox itself! */
270 };
271 
272 
277 struct TCPRekey
278 {
283 
292  struct GNUNET_ShortHashCode hmac;
293 
298 
303 
309 };
310 
316 {
321 
326 
331 
336 
342 };
343 
349 struct TCPFinish
350 {
355 
364  struct GNUNET_ShortHashCode hmac;
365 };
366 
367 
369 
374 {
379 
384 };
385 
389 struct Queue
390 {
395 
400 
405 
409  gcry_cipher_hd_t in_cipher;
410 
414  gcry_cipher_hd_t out_cipher;
415 
419  struct GNUNET_HashCode in_hmac;
420 
425  struct GNUNET_HashCode out_hmac;
426 
432 
437 
442 
446  struct sockaddr *address;
447 
453 
459 
463  socklen_t address_len;
464 
469 
474 
478  unsigned long long bytes_in_queue;
479 
484 
489 
493  char pread_buf[UINT16_MAX + 1 + sizeof(struct TCPBox)];
494 
498  char pwrite_buf[UINT16_MAX + 1 + sizeof(struct TCPBox)];
499 
504  size_t cread_off;
505 
510  size_t cwrite_off;
511 
516  size_t pread_off;
517 
522  size_t pwrite_off;
523 
528 
536  unsigned int backpressure;
537 
541  enum GNUNET_NetworkType nt;
542 
547 
552 
557 
565 
570  int rekeyed;
571 
576 
581 
586 
590  struct ChallengeNonceP challenge;
591 
596 
601 
606 
611 
616 
621 
626 };
627 
628 
634 {
638  struct ProtoQueue *next;
639 
643  struct ProtoQueue *prev;
644 
649 
654 
659 
663  struct sockaddr *address;
664 
668  socklen_t address_len;
669 
674 
680 
684  size_t ibuf_off;
685 };
686 
691 {
695  struct sockaddr *addr_ipv4;
696 
700  socklen_t addr_len_ipv4;
701 
705  struct sockaddr *addr_ipv6;
706 
710  socklen_t addr_len_ipv6;
711 
712 };
713 
717 struct Addresses
718 {
722  struct Addresses *next;
723 
727  struct Addresses *prev;
728 
732  struct sockaddr *addr;
733 
737  socklen_t addr_len;
738 
739 };
740 
741 
745 static unsigned long long max_queue_length;
746 
751 
756 
761 
766 
770 static struct GNUNET_PeerIdentity my_identity;
771 
776 
781 
785 static const struct GNUNET_CONFIGURATION_Handle *cfg;
786 
791 
795 static struct GNUNET_NAT_Handle *nat;
796 
800 static struct ProtoQueue *proto_head;
801 
805 static struct ProtoQueue *proto_tail;
806 
811 
816 
821 
826 
831 
836 
840 // TODO remove?
842 
847 
852 
856 unsigned int bind_port;
857 
865 static void
866 listen_cb (void *cls);
867 
875 static void
877 {
878  struct ListenTask *lt = NULL;
879  struct GNUNET_HashCode h_sock;
880  int sockfd;
881 
882  if (NULL != queue->listen_sock)
883  {
884  sockfd = GNUNET_NETWORK_get_fd (queue->listen_sock);
885  GNUNET_CRYPTO_hash (&sockfd,
886  sizeof(int),
887  &h_sock);
888 
890  }
891 
893  "Disconnecting queue for peer `%s'\n",
894  GNUNET_i2s (&queue->target));
895  if (NULL != queue->rekey_monotime_sc)
896  {
897  GNUNET_PEERSTORE_store_cancel (queue->rekey_monotime_sc);
898  queue->rekey_monotime_sc = NULL;
899  }
900  if (NULL != queue->handshake_monotime_sc)
901  {
902  GNUNET_PEERSTORE_store_cancel (queue->handshake_monotime_sc);
903  queue->handshake_monotime_sc = NULL;
904  }
905  if (NULL != queue->handshake_ack_monotime_sc)
906  {
907  GNUNET_PEERSTORE_store_cancel (queue->handshake_ack_monotime_sc);
908  queue->handshake_ack_monotime_sc = NULL;
909  }
910  if (NULL != queue->rekey_monotime_get)
911  {
912  GNUNET_PEERSTORE_iterate_cancel (queue->rekey_monotime_get);
913  queue->rekey_monotime_get = NULL;
914  }
915  if (NULL != queue->handshake_monotime_get)
916  {
917  GNUNET_PEERSTORE_iterate_cancel (queue->handshake_monotime_get);
918  queue->handshake_monotime_get = NULL;
919  }
920  if (NULL != queue->handshake_ack_monotime_get)
921  {
922  GNUNET_PEERSTORE_iterate_cancel (queue->handshake_ack_monotime_get);
923  queue->handshake_ack_monotime_get = NULL;
924  }
925  if (NULL != queue->qh)
926  {
928  queue->qh = NULL;
929  }
930  GNUNET_assert (
931  GNUNET_YES ==
934  "# queues active",
936  GNUNET_NO);
937  if (NULL != queue->read_task)
938  {
939  GNUNET_SCHEDULER_cancel (queue->read_task);
940  queue->read_task = NULL;
941  }
942  if (NULL != queue->write_task)
943  {
944  GNUNET_SCHEDULER_cancel (queue->write_task);
945  queue->write_task = NULL;
946  }
948  {
950  "closing socket failed\n");
951  }
952  gcry_cipher_close (queue->in_cipher);
953  gcry_cipher_close (queue->out_cipher);
954  GNUNET_free (queue->address);
955  if (0 != queue->backpressure)
956  queue->destroyed = GNUNET_YES;
957  else
958  GNUNET_free (queue);
959 
960  if (NULL == lt)
961  return;
962 
963  if ((! shutdown_running) && (NULL == lt->listen_task))
964  {
966  "add read net listen\n");
969  lt->listen_sock,
970  &listen_cb,
971  lt);
972  }
973  else
974  GNUNET_free (lt);
975 }
976 
977 
986 static void
987 calculate_hmac (struct GNUNET_HashCode *hmac_secret,
988  const void *buf,
989  size_t buf_size,
990  struct GNUNET_ShortHashCode *smac)
991 {
992  struct GNUNET_HashCode mac;
993 
994  GNUNET_CRYPTO_hmac_raw (hmac_secret,
995  sizeof(struct GNUNET_HashCode),
996  buf,
997  buf_size,
998  &mac);
999  /* truncate to `struct GNUNET_ShortHashCode` */
1000  memcpy (smac, &mac, sizeof(struct GNUNET_ShortHashCode));
1001  /* ratchet hmac key */
1002  GNUNET_CRYPTO_hash (hmac_secret,
1003  sizeof(struct GNUNET_HashCode),
1004  hmac_secret);
1005 }
1006 
1007 
1014 static void
1016 {
1017  struct TCPFinish fin;
1018 
1019  memset (&fin, 0, sizeof(fin));
1020  fin.header.size = htons (sizeof(fin));
1022  calculate_hmac (&queue->out_hmac, &fin, sizeof(fin), &fin.hmac);
1023  /* if there is any message left in pwrite_buf, we
1024  overwrite it (possibly dropping the last message
1025  from CORE hard here) */
1026  memcpy (queue->pwrite_buf, &fin, sizeof(fin));
1027  queue->pwrite_off = sizeof(fin);
1028  /* This flag will ensure that #queue_write() no longer
1029  notifies CORE about the possibility of sending
1030  more data, and that #queue_write() will call
1031  #queue_destroy() once the @c fin was fully written. */
1032  queue->finishing = GNUNET_YES;
1033 }
1034 
1035 
1043 static void
1045 {
1046  queue->timeout =
1048 }
1049 
1050 
1056 static void
1057 queue_read (void *cls);
1058 
1059 
1067 static void
1068 core_read_finished_cb (void *cls, int success)
1069 {
1070  struct Queue *queue = cls;
1071  if (GNUNET_OK != success)
1073  "# messages lost in communicator API towards CORE",
1074  1,
1075  GNUNET_NO);
1076  if (NULL == queue)
1077  return;
1078 
1080  "backpressure %u\n",
1081  queue->backpressure);
1082 
1083  queue->backpressure--;
1084  /* handle deferred queue destruction */
1085  if ((queue->destroyed) && (0 == queue->backpressure))
1086  {
1087  GNUNET_free (queue);
1088  return;
1089  }
1090  else if (GNUNET_YES != queue->destroyed)
1091  {
1093  /* possibly unchoke reading, now that CORE made progress */
1094  if (NULL == queue->read_task)
1095  queue->read_task =
1097  queue->timeout),
1098  queue->sock,
1099  &queue_read,
1100  queue);
1101  }
1102 }
1103 
1104 
1114 static void
1116  const void *plaintext,
1117  size_t plaintext_len)
1118 {
1119  const struct GNUNET_MessageHeader *hdr = plaintext;
1120  int ret;
1121 
1122  if (ntohs (hdr->size) != plaintext_len)
1123  {
1124  /* NOTE: If we ever allow multiple CORE messages in one
1125  BOX, this will have to change! */
1126  GNUNET_break (0);
1127  return;
1128  }
1130  &queue->target,
1131  hdr,
1134  queue);
1135  if (GNUNET_OK == ret)
1136  queue->backpressure++;
1137  GNUNET_break (GNUNET_NO != ret); /* backpressure not working!? */
1138  if (GNUNET_SYSERR == ret)
1140  "# bytes lost due to CORE not running",
1141  plaintext_len,
1142  GNUNET_NO);
1143 }
1144 
1145 
1155 static void
1156 setup_cipher (const struct GNUNET_HashCode *dh,
1157  const struct GNUNET_PeerIdentity *pid,
1158  gcry_cipher_hd_t *cipher,
1159  struct GNUNET_HashCode *hmac_key)
1160 {
1161  char key[256 / 8];
1162  char ctr[128 / 8];
1163 
1164  GNUNET_assert (0 == gcry_cipher_open (cipher,
1165  GCRY_CIPHER_AES256 /* low level: go for speed */,
1166  GCRY_CIPHER_MODE_CTR,
1167  0 /* flags */));
1169  sizeof(key),
1170  "TCP-key",
1171  strlen ("TCP-key"),
1172  dh,
1173  sizeof(*dh),
1174  pid,
1175  sizeof(*pid),
1176  NULL,
1177  0));
1178  GNUNET_assert (0 == gcry_cipher_setkey (*cipher, key, sizeof(key)));
1180  sizeof(ctr),
1181  "TCP-ctr",
1182  strlen ("TCP-ctr"),
1183  dh,
1184  sizeof(*dh),
1185  pid,
1186  sizeof(*pid),
1187  NULL,
1188  0));
1189  gcry_cipher_setctr (*cipher, ctr, sizeof(ctr));
1191  GNUNET_CRYPTO_kdf (hmac_key,
1192  sizeof(struct GNUNET_HashCode),
1193  "TCP-hmac",
1194  strlen ("TCP-hmac"),
1195  dh,
1196  sizeof(*dh),
1197  pid,
1198  sizeof(*pid),
1199  NULL,
1200  0));
1201 }
1202 
1203 
1209 static void
1210 rekey_monotime_store_cb (void *cls, int success)
1211 {
1212  struct Queue *queue = cls;
1213  if (GNUNET_OK != success)
1214  {
1216  "Failed to store rekey monotonic time in PEERSTORE!\n");
1217  }
1218  queue->rekey_monotime_sc = NULL;
1219 }
1220 
1221 
1229 static void
1231  const struct GNUNET_PEERSTORE_Record *record,
1232  const char *emsg)
1233 {
1234  struct Queue *queue = cls;
1235  struct GNUNET_TIME_AbsoluteNBO *mtbe;
1236  struct GNUNET_TIME_Absolute mt;
1237  const struct GNUNET_PeerIdentity *pid;
1238  struct GNUNET_TIME_AbsoluteNBO *rekey_monotonic_time;
1239 
1240  (void) emsg;
1241 
1242  rekey_monotonic_time = &queue->rekey_monotonic_time;
1243  pid = &queue->target;
1244  if (NULL == record)
1245  {
1246  queue->rekey_monotime_get = NULL;
1247  return;
1248  }
1249  if (sizeof(*mtbe) != record->value_size)
1250  {
1251  GNUNET_break (0);
1252  return;
1253  }
1254  mtbe = record->value;
1255  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
1257  queue->rekey_monotonic_time).abs_value_us)
1258  {
1260  "Queue from %s dropped, rekey monotime in the past\n",
1261  GNUNET_i2s (&queue->target));
1262  GNUNET_break (0);
1263  queue_finish (queue);
1264  return;
1265  }
1266  queue->rekey_monotime_sc = GNUNET_PEERSTORE_store (peerstore,
1267  "transport_tcp_communicator",
1268  pid,
1270  rekey_monotonic_time,
1271  sizeof(*
1272  rekey_monotonic_time),
1276  queue);
1277 }
1278 
1279 
1286 static void
1288  struct Queue *queue)
1289 {
1290  struct GNUNET_HashCode dh;
1291 
1292  GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &dh);
1293  setup_cipher (&dh, &my_identity, &queue->in_cipher, &queue->in_hmac);
1294 }
1295 
1296 
1305 static void
1306 do_rekey (struct Queue *queue, const struct TCPRekey *rekey)
1307 {
1308  struct TcpRekeySignature thp;
1309 
1311  thp.purpose.size = htonl (sizeof(thp));
1313  "do_rekey size %u\n",
1314  thp.purpose.size);
1315  thp.sender = queue->target;
1317  "sender %s\n",
1318  GNUNET_p2s (&thp.sender.public_key));
1320  "sender %s\n",
1321  GNUNET_p2s (&queue->target.public_key));
1322  thp.receiver = my_identity;
1324  "receiver %s\n",
1325  GNUNET_p2s (&thp.receiver.public_key));
1326  thp.ephemeral = rekey->ephemeral;
1328  "ephemeral %s\n",
1329  GNUNET_e2s (&thp.ephemeral));
1330  thp.monotonic_time = rekey->monotonic_time;
1332  "time %s\n",
1335  GNUNET_assert (ntohl ((&thp)->purpose.size) == sizeof (*(&thp)));
1336  if (GNUNET_OK !=
1338  &thp,
1339  &rekey->sender_sig,
1340  &queue->target.public_key))
1341  {
1342  GNUNET_break (0);
1343  queue_finish (queue);
1344  return;
1345  }
1346  queue->rekey_monotonic_time = rekey->monotonic_time;
1347  queue->rekey_monotime_get = GNUNET_PEERSTORE_iterate (peerstore,
1348  "transport_tcp_communicator",
1349  &queue->target,
1352  queue);
1353  gcry_cipher_close (queue->in_cipher);
1354  queue->rekeyed = GNUNET_YES;
1355  setup_in_cipher (&rekey->ephemeral, queue);
1356 }
1357 
1358 
1364 static void
1365 handshake_ack_monotime_store_cb (void *cls, int success)
1366 {
1367  struct Queue *queue = cls;
1368 
1369  if (GNUNET_OK != success)
1370  {
1372  "Failed to store handshake ack monotonic time in PEERSTORE!\n");
1373  }
1374  queue->handshake_ack_monotime_sc = NULL;
1375 }
1376 
1377 
1385 static void
1387  const struct GNUNET_PEERSTORE_Record *record,
1388  const char *emsg)
1389 {
1390  struct Queue *queue = cls;
1391  struct GNUNET_TIME_AbsoluteNBO *mtbe;
1392  struct GNUNET_TIME_Absolute mt;
1393  const struct GNUNET_PeerIdentity *pid;
1394  struct GNUNET_TIME_AbsoluteNBO *handshake_ack_monotonic_time;
1395 
1396  (void) emsg;
1397 
1398  handshake_ack_monotonic_time = &queue->handshake_ack_monotonic_time;
1399  pid = &queue->target;
1400  if (NULL == record)
1401  {
1402  queue->handshake_ack_monotime_get = NULL;
1403  return;
1404  }
1405  if (sizeof(*mtbe) != record->value_size)
1406  {
1407  GNUNET_break (0);
1408  return;
1409  }
1410  mtbe = record->value;
1411  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
1413  queue->handshake_ack_monotonic_time).abs_value_us)
1414  {
1416  "Queue from %s dropped, handshake ack monotime in the past\n",
1417  GNUNET_i2s (&queue->target));
1418  GNUNET_break (0);
1419  queue_finish (queue);
1420  return;
1421  }
1422  queue->handshake_ack_monotime_sc =
1424  "transport_tcp_communicator",
1425  pid,
1427  handshake_ack_monotonic_time,
1428  sizeof(*handshake_ack_monotonic_time),
1431  &
1433  queue);
1434 }
1435 
1436 
1443 static void
1444 send_challenge (struct ChallengeNonceP challenge, struct Queue *queue)
1445 {
1446  struct TCPConfirmationAck tca;
1447  struct TcpHandshakeAckSignature thas;
1448 
1450  "transport",
1451  "sending challenge\n");
1452 
1453  tca.header.type = ntohs (
1455  tca.header.size = ntohs (sizeof(tca));
1456  tca.challenge = challenge;
1457  tca.sender = my_identity;
1458  tca.monotonic_time =
1460  thas.purpose.purpose = htonl (
1462  thas.purpose.size = htonl (sizeof(thas));
1463  thas.sender = my_identity;
1464  thas.receiver = queue->target;
1465  thas.monotonic_time = tca.monotonic_time;
1466  thas.challenge = tca.challenge;
1468  &thas,
1469  &tca.sender_sig);
1470  GNUNET_assert (0 ==
1471  gcry_cipher_encrypt (queue->out_cipher,
1472  &queue->cwrite_buf[queue->cwrite_off],
1473  sizeof(tca),
1474  &tca,
1475  sizeof(tca)));
1476  queue->cwrite_off += sizeof(tca);
1478  "transport",
1479  "sending challenge done\n");
1480 }
1481 
1482 
1489 static void
1491 {
1492  struct GNUNET_HashCode dh;
1493 
1494  GNUNET_CRYPTO_ecdh_eddsa (&queue->ephemeral, &queue->target.public_key, &dh);
1495  /* we don't need the private key anymore, drop it! */
1496  memset (&queue->ephemeral, 0, sizeof(queue->ephemeral));
1497  setup_cipher (&dh, &queue->target, &queue->out_cipher, &queue->out_hmac);
1499  queue->rekey_left_bytes =
1501 }
1502 
1503 
1510 static void
1512 {
1513  struct TCPRekey rekey;
1514  struct TcpRekeySignature thp;
1515 
1516  GNUNET_assert (0 == queue->pwrite_off);
1517  memset (&rekey, 0, sizeof(rekey));
1518  GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral);
1520  rekey.header.size = ntohs (sizeof(rekey));
1521  GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &rekey.ephemeral);
1522  rekey.monotonic_time =
1525  thp.purpose.size = htonl (sizeof(thp));
1527  "inject_rekey size %u\n",
1528  thp.purpose.size);
1529  thp.sender = my_identity;
1531  "sender %s\n",
1532  GNUNET_p2s (&thp.sender.public_key));
1533  thp.receiver = queue->target;
1535  "receiver %s\n",
1536  GNUNET_p2s (&thp.receiver.public_key));
1537  thp.ephemeral = rekey.ephemeral;
1539  "ephemeral %s\n",
1540  GNUNET_e2s (&thp.ephemeral));
1541  thp.monotonic_time = rekey.monotonic_time;
1543  "time %s\n",
1547  &thp,
1548  &rekey.sender_sig);
1549  calculate_hmac (&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac);
1550  /* Encrypt rekey message with 'old' cipher */
1551  GNUNET_assert (0 ==
1552  gcry_cipher_encrypt (queue->out_cipher,
1553  &queue->cwrite_buf[queue->cwrite_off],
1554  sizeof(rekey),
1555  &rekey,
1556  sizeof(rekey)));
1557  queue->cwrite_off += sizeof(rekey);
1558  /* Setup new cipher for successive messages */
1559  gcry_cipher_close (queue->out_cipher);
1561 }
1562 
1563 
1570 static void
1571 queue_write (void *cls)
1572 {
1573  struct Queue *queue = cls;
1574  ssize_t sent;
1575  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "In queue write\n");
1576  queue->write_task = NULL;
1577  if (0 != queue->cwrite_off)
1578  {
1579  sent = GNUNET_NETWORK_socket_send (queue->sock,
1580  queue->cwrite_buf,
1581  queue->cwrite_off);
1583  "Sent %lu bytes to TCP queue\n", sent);
1584  if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno))
1585  {
1587  queue_destroy (queue);
1588  return;
1589  }
1590  if (sent > 0)
1591  {
1592  size_t usent = (size_t) sent;
1593  queue->cwrite_off -= usent;
1594  memmove (queue->cwrite_buf,
1595  &queue->cwrite_buf[usent],
1596  queue->cwrite_off);
1598  }
1599  }
1600  /* can we encrypt more? (always encrypt full messages, needed
1601  such that #mq_cancel() can work!) */
1602  if ((0 < queue->rekey_left_bytes) &&
1603  (queue->pwrite_off > 0) &&
1604  (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE))
1605  {
1607  "Encrypting %lu bytes\n", queue->pwrite_off);
1608  GNUNET_assert (0 ==
1609  gcry_cipher_encrypt (queue->out_cipher,
1610  &queue->cwrite_buf[queue->cwrite_off],
1611  queue->pwrite_off,
1612  queue->pwrite_buf,
1613  queue->pwrite_off));
1614  if (queue->rekey_left_bytes > queue->pwrite_off)
1615  queue->rekey_left_bytes -= queue->pwrite_off;
1616  else
1617  queue->rekey_left_bytes = 0;
1618  queue->cwrite_off += queue->pwrite_off;
1619  queue->pwrite_off = 0;
1620  }
1621  // if ((-1 != unverified_size)&& ((0 == queue->pwrite_off) &&
1622  if (((0 == queue->pwrite_off) &&
1623  ((0 == queue->rekey_left_bytes) ||
1624  (0 ==
1626  queue->rekey_time).rel_value_us))))
1627  {
1628  inject_rekey (queue);
1629  }
1630  if ((0 == queue->pwrite_off) && (! queue->finishing) &&
1631  (GNUNET_YES == queue->mq_awaits_continue))
1632  {
1633  queue->mq_awaits_continue = GNUNET_NO;
1635  }
1636  /* did we just finish writing 'finish'? */
1637  if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing))
1638  {
1640  "Finishing queue\n");
1641  queue_destroy (queue);
1642  return;
1643  }
1644  /* do we care to write more? */
1645  if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off))
1646  queue->write_task =
1648  queue->sock,
1649  &queue_write,
1650  queue);
1651 }
1652 
1653 
1661 static size_t
1663 {
1664  const struct GNUNET_MessageHeader *hdr =
1665  (const struct GNUNET_MessageHeader *) queue->pread_buf;
1666  const struct TCPConfirmationAck *tca = (const struct
1667  TCPConfirmationAck *) queue->pread_buf;
1668  const struct TCPBox *box = (const struct TCPBox *) queue->pread_buf;
1669  const struct TCPRekey *rekey = (const struct TCPRekey *) queue->pread_buf;
1670  const struct TCPFinish *fin = (const struct TCPFinish *) queue->pread_buf;
1671  struct TCPRekey rekeyz;
1672  struct TCPFinish finz;
1673  struct GNUNET_ShortHashCode tmac;
1674  uint16_t type;
1675  size_t size = 0; /* make compiler happy */
1676  struct TcpHandshakeAckSignature thas;
1677  const struct ChallengeNonceP challenge = queue->challenge;
1678 
1680  "try handle plaintext!\n");
1681 
1682  if ((sizeof(*hdr) > queue->pread_off))
1683  {
1685  "Handling plaintext, not even a header!\n");
1686  return 0; /* not even a header */
1687  }
1688 
1690  {
1692  "Already received data of size %lu bigger than KX size %lu!\n",
1695  GNUNET_break_op (0);
1696  queue_finish (queue);
1697  return 0;
1698  }
1699 
1700  type = ntohs (hdr->type);
1701  switch (type)
1702  {
1705  "start processing ack\n");
1706  if (sizeof(*tca) > queue->pread_off)
1707  {
1709  "Handling plaintext size of tca greater than pread offset.\n");
1710  return 0;
1711  }
1712  if (ntohs (hdr->size) != sizeof(*tca))
1713  {
1715  "Handling plaintext size does not match message type.\n");
1716  GNUNET_break_op (0);
1717  queue_finish (queue);
1718  return 0;
1719  }
1720 
1721  thas.purpose.purpose = htonl (
1723  thas.purpose.size = htonl (sizeof(thas));
1724  thas.sender = tca->sender;
1725  thas.receiver = my_identity;
1726  thas.monotonic_time = tca->monotonic_time;
1727  thas.challenge = tca->challenge;
1728 
1731  &thas,
1732  &tca->sender_sig,
1733  &tca->sender.public_key))
1734  {
1736  "Verification of signature failed!\n");
1737  GNUNET_break (0);
1738  queue_finish (queue);
1739  return 0;
1740  }
1741  if (0 != GNUNET_memcmp (&tca->challenge, &challenge))
1742  {
1744  "Challenge in TCPConfirmationAck not correct!\n");
1745  GNUNET_break (0);
1746  queue_finish (queue);
1747  return 0;
1748  }
1749 
1750  queue->handshake_ack_monotime_get = GNUNET_PEERSTORE_iterate (peerstore,
1751  "transport_tcp_communicator",
1752  &queue->target,
1754  &
1756  queue);
1757 
1759  "Handling plaintext, ack processed!\n");
1760 
1762  {
1763  send_challenge (queue->challenge_received, queue);
1764  queue->write_task =
1766  queue->sock,
1767  &queue_write,
1768  queue);
1769  }
1770 
1771  unverified_size = -1;
1772 
1773  char *foreign_addr;
1774 
1775  switch (queue->address->sa_family)
1776  {
1777  case AF_INET:
1778  GNUNET_asprintf (&foreign_addr,
1779  "%s-%s",
1781  GNUNET_a2s (queue->address, queue->address_len));
1782  break;
1783 
1784  case AF_INET6:
1785  GNUNET_asprintf (&foreign_addr,
1786  "%s-%s",
1788  GNUNET_a2s (queue->address, queue->address_len));
1789  break;
1790 
1791  default:
1792  GNUNET_assert (0);
1793  }
1794 
1796  &queue->target,
1797  foreign_addr,
1798  UINT32_MAX, /* no MTU */
1800  0, /* Priority */
1801  queue->nt,
1802  queue->cs,
1803  queue->mq);
1804 
1805  GNUNET_free (foreign_addr);
1806 
1807  size = ntohs (hdr->size);
1808  break;
1810  /* Special case: header size excludes box itself! */
1811  if (ntohs (hdr->size) + sizeof(struct TCPBox) > queue->pread_off)
1812  return 0;
1813  calculate_hmac (&queue->in_hmac, &box[1], ntohs (hdr->size), &tmac);
1814  if (0 != memcmp (&tmac, &box->hmac, sizeof(tmac)))
1815  {
1816  GNUNET_break_op (0);
1817  queue_finish (queue);
1818  return 0;
1819  }
1820  pass_plaintext_to_core (queue, (const void *) &box[1], ntohs (hdr->size));
1821  size = ntohs (hdr->size) + sizeof(*box);
1823  "Handling plaintext, box processed!\n");
1824  break;
1825 
1827  if (sizeof(*rekey) > queue->pread_off)
1828  return 0;
1829  if (ntohs (hdr->size) != sizeof(*rekey))
1830  {
1831  GNUNET_break_op (0);
1832  queue_finish (queue);
1833  return 0;
1834  }
1835  rekeyz = *rekey;
1836  memset (&rekeyz.hmac, 0, sizeof(rekeyz.hmac));
1837  calculate_hmac (&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac);
1838  if (0 != memcmp (&tmac, &rekey->hmac, sizeof(tmac)))
1839  {
1840  GNUNET_break_op (0);
1841  queue_finish (queue);
1842  return 0;
1843  }
1844  do_rekey (queue, rekey);
1845  size = ntohs (hdr->size);
1847  "Handling plaintext, rekey processed!\n");
1848  break;
1849 
1851  if (sizeof(*fin) > queue->pread_off)
1852  return 0;
1853  if (ntohs (hdr->size) != sizeof(*fin))
1854  {
1855  GNUNET_break_op (0);
1856  queue_finish (queue);
1857  return 0;
1858  }
1859  finz = *fin;
1860  memset (&finz.hmac, 0, sizeof(finz.hmac));
1861  calculate_hmac (&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac);
1862  if (0 != memcmp (&tmac, &fin->hmac, sizeof(tmac)))
1863  {
1864  GNUNET_break_op (0);
1865  queue_finish (queue);
1866  return 0;
1867  }
1868  /* handle FINISH by destroying queue */
1869  queue_destroy (queue);
1871  "Handling plaintext, finish processed!\n");
1872  break;
1873 
1874  default:
1876  "Handling plaintext, nothing processed!\n");
1877  GNUNET_break_op (0);
1878  queue_finish (queue);
1879  return 0;
1880  }
1881  GNUNET_assert (0 != size);
1882  if (-1 != unverified_size)
1883  unverified_size += size;
1884  return size;
1885 }
1886 
1887 
1893 static void
1894 queue_read (void *cls)
1895 {
1896  struct Queue *queue = cls;
1897  struct GNUNET_TIME_Relative left;
1898  ssize_t rcvd;
1899 
1900  queue->read_task = NULL;
1901  rcvd = GNUNET_NETWORK_socket_recv (queue->sock,
1902  &queue->cread_buf[queue->cread_off],
1903  BUF_SIZE - queue->cread_off);
1905  "Received %lu bytes from TCP queue\n", rcvd);
1907  "transport",
1908  "Received %lu bytes from TCP queue\n", rcvd);
1909  if (-1 == rcvd)
1910  {
1911  if ((EAGAIN != errno) && (EINTR != errno))
1912  {
1914  queue_finish (queue);
1915  return;
1916  }
1917  /* try again */
1918  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
1919  queue->read_task =
1921  return;
1922  }
1923  if (0 != rcvd)
1925  queue->cread_off += rcvd;
1926  while ((queue->pread_off < sizeof(queue->pread_buf)) &&
1927  (queue->cread_off > 0))
1928  {
1929  size_t max = GNUNET_MIN (sizeof(queue->pread_buf) - queue->pread_off,
1930  queue->cread_off);
1931  size_t done;
1932  size_t total;
1933  size_t old_pread_off = queue->pread_off;
1934 
1935  GNUNET_assert (0 ==
1936  gcry_cipher_decrypt (queue->in_cipher,
1937  &queue->pread_buf[queue->pread_off],
1938  max,
1939  queue->cread_buf,
1940  max));
1941  queue->pread_off += max;
1942  total = 0;
1943  while (0 != (done = try_handle_plaintext (queue)))
1944  {
1945  /* 'done' bytes of plaintext were used, shift buffer */
1946  GNUNET_assert (done <= queue->pread_off);
1947  /* NOTE: this memmove() could possibly sometimes be
1948  avoided if we pass 'total' into try_handle_plaintext()
1949  and use it at an offset into the buffer there! */
1950  memmove (queue->pread_buf,
1951  &queue->pread_buf[done],
1952  queue->pread_off - done);
1953  queue->pread_off -= done;
1954  total += done;
1955  /* The last plaintext was a rekey, abort for now */
1956  if (GNUNET_YES == queue->rekeyed)
1957  break;
1958  }
1959  /* when we encounter a rekey message, the decryption above uses the
1960  wrong key for everything after the rekey; in that case, we have
1961  to re-do the decryption at 'total' instead of at 'max'.
1962  However, we have to take into account that the plaintext buffer may have
1963  already contained data and not jumped too far ahead in the ciphertext.
1964  If there is no rekey and the last message is incomplete (max > total),
1965  it is safe to keep the decryption so we shift by 'max' */
1966  if (GNUNET_YES == queue->rekeyed)
1967  {
1968  max = total - old_pread_off;
1969  queue->rekeyed = GNUNET_NO;
1970  queue->pread_off = 0;
1971  }
1972  memmove (queue->cread_buf, &queue->cread_buf[max], queue->cread_off - max);
1973  queue->cread_off -= max;
1974  }
1975  if (BUF_SIZE == queue->cread_off)
1976  return; /* buffer full, suspend reading */
1977  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
1978  if (0 != left.rel_value_us)
1979  {
1980  if (max_queue_length > queue->backpressure)
1981  {
1982  /* continue reading */
1983  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
1984  queue->read_task =
1986  }
1987  return;
1988  }
1990  "Queue %p was idle for %s, disconnecting\n",
1991  queue,
1994  GNUNET_YES));
1995  queue_finish (queue);
1996 }
1997 
1998 
2006 static struct sockaddr *
2007 tcp_address_to_sockaddr_numeric_v6 (socklen_t *sock_len, struct sockaddr_in6 v6,
2008  unsigned int port)
2009 {
2010  struct sockaddr *in;
2011 
2012  v6.sin6_family = AF_INET6;
2013  v6.sin6_port = htons ((uint16_t) port);
2014 #if HAVE_SOCKADDR_IN_SIN_LEN
2015  v6.sin6_len = sizeof(sizeof(struct sockaddr_in6));
2016 #endif
2017  v6.sin6_flowinfo = 0;
2018  v6.sin6_scope_id = 0;
2019  in = GNUNET_memdup (&v6, sizeof(v6));
2020  *sock_len = sizeof(struct sockaddr_in6);
2021 
2022  return in;
2023 }
2024 
2025 
2033 static struct sockaddr *
2034 tcp_address_to_sockaddr_numeric_v4 (socklen_t *sock_len, struct sockaddr_in v4,
2035  unsigned int port)
2036 {
2037  struct sockaddr *in;
2038 
2039  v4.sin_family = AF_INET;
2040  v4.sin_port = htons ((uint16_t) port);
2041 #if HAVE_SOCKADDR_IN_SIN_LEN
2042  v4.sin_len = sizeof(struct sockaddr_in);
2043 #endif
2044  in = GNUNET_memdup (&v4, sizeof(v4));
2045  *sock_len = sizeof(struct sockaddr_in);
2046  return in;
2047 }
2048 
2049 
2056 static struct PortOnlyIpv4Ipv6 *
2057 tcp_address_to_sockaddr_port_only (const char *bindto, unsigned int *port)
2058 {
2059  struct PortOnlyIpv4Ipv6 *po;
2060  struct sockaddr_in *i4;
2061  struct sockaddr_in6 *i6;
2062  socklen_t sock_len_ipv4;
2063  socklen_t sock_len_ipv6;
2064 
2065  /* interpreting value as just a PORT number */
2066  if (*port > UINT16_MAX)
2067  {
2069  "BINDTO specification `%s' invalid: value too large for port\n",
2070  bindto);
2071  return NULL;
2072  }
2073 
2074  po = GNUNET_new (struct PortOnlyIpv4Ipv6);
2075 
2076  if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
2077  (GNUNET_YES ==
2080  "DISABLE_V6")))
2081  {
2082  i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
2083  po->addr_ipv4 = tcp_address_to_sockaddr_numeric_v4 (&sock_len_ipv4, *i4,
2084  *port);
2085  po->addr_len_ipv4 = sock_len_ipv4;
2086  }
2087  else
2088  {
2089 
2090  i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
2091  po->addr_ipv4 = tcp_address_to_sockaddr_numeric_v4 (&sock_len_ipv4, *i4,
2092  *port);
2093  po->addr_len_ipv4 = sock_len_ipv4;
2094 
2095  i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
2096  po->addr_ipv6 = tcp_address_to_sockaddr_numeric_v6 (&sock_len_ipv6, *i6,
2097  *port);
2098 
2099  po->addr_len_ipv6 = sock_len_ipv6;
2100 
2101  GNUNET_free (i6);
2102  }
2103 
2104  GNUNET_free (i4);
2105 
2106  return po;
2107 }
2108 
2109 
2116 static char *
2117 extract_address (const char *bindto)
2118 {
2119 
2120  char *start;
2121  char *token;
2122  char *cp;
2123  char *rest = NULL;
2124  char *res;
2125 
2127  "extract address with bindto %s\n",
2128  bindto);
2129 
2130  if (NULL == bindto)
2132  "bindto is NULL\n");
2133 
2134  cp = GNUNET_strdup (bindto);
2135 
2137  "extract address 2\n");
2138 
2139  start = cp;
2140  if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
2141  {
2142  start++; /* skip over '['*/
2143  cp[strlen (cp) - 1] = '\0'; /* eat ']'*/
2144  }
2145  else
2146  {
2147  token = strtok_r (cp, "]", &rest);
2148  if (strlen (bindto) == strlen (token))
2149  {
2150  token = strtok_r (cp, ":", &rest);
2151  }
2152  else
2153  {
2154  token++;
2155  res = GNUNET_strdup (token);
2156  GNUNET_free (cp);
2157  return res;
2158  }
2159  }
2160 
2162  "extract address 3\n");
2164  "extract address with start %s\n",
2165  start);
2166 
2167  return GNUNET_strdup (start);
2168 }
2169 
2170 
2177 static unsigned int
2178 extract_port (const char *addr_and_port)
2179 {
2180  unsigned int port;
2181  char dummy[2];
2182  char *token;
2183  char *addr;
2184  char *colon;
2185  char *cp;
2186  char *rest = NULL;
2187 
2188  if (NULL != addr_and_port)
2189  {
2190  cp = GNUNET_strdup (addr_and_port);
2191  token = strtok_r (cp, "]", &rest);
2192  if (strlen (addr_and_port) == strlen (token))
2193  {
2194  colon = strrchr (cp, ':');
2195  if (NULL == colon)
2196  {
2197  GNUNET_free (cp);
2198  return 0;
2199  }
2200  addr = colon;
2201  addr++;
2202  }
2203  else
2204  {
2205  token = strtok_r (NULL, "]", &rest);
2206  if (NULL == token)
2207  {
2208  GNUNET_free (cp);
2209  return 0;
2210  }
2211  else
2212  {
2213  addr = token;
2214  addr++;
2215  }
2216  }
2217 
2218 
2219  if (1 == sscanf (addr, "%u%1s", &port, dummy))
2220  {
2221  /* interpreting value as just a PORT number */
2222  if (port > UINT16_MAX)
2223  {
2225  "Port `%u' invalid: value too large for port\n",
2226  port);
2227  GNUNET_free (cp);
2228  return 0;
2229  }
2230  }
2231  else
2232  {
2234  "BINDTO specification invalid: last ':' not followed by number\n");
2235  GNUNET_free (cp);
2236  return 0;
2237  }
2238  }
2239  else
2240  {
2242  "return 0\n");
2243  /* interpret missing port as 0, aka pick any free one */
2244  port = 0;
2245  }
2246 
2247 
2248  return port;
2249 }
2250 
2251 
2259 static struct sockaddr *
2260 tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
2261 {
2262  struct sockaddr *in;
2263  unsigned int port;
2264  struct sockaddr_in v4;
2265  struct sockaddr_in6 v6;
2266  char *start;
2267 
2268  // cp = GNUNET_strdup (bindto);
2269  start = extract_address (bindto);
2270 
2272  "start %s\n",
2273  start);
2274 
2276  "!bindto %s\n",
2277  bindto);
2278 
2279 
2280  if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
2281  {
2282  // colon = strrchr (cp, ':');
2283  port = extract_port (bindto);
2284 
2286  "port %u\n",
2287  port);
2288 
2289  in = tcp_address_to_sockaddr_numeric_v4 (sock_len, v4, port);
2290  }
2291  else if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
2292  {
2293  // colon = strrchr (cp, ':');
2294  port = extract_port (bindto);
2295  in = tcp_address_to_sockaddr_numeric_v6 (sock_len, v6, port);
2296  }
2297  else
2298  {
2299  GNUNET_assert (0);
2300  }
2301 
2302  GNUNET_free (start);
2303  return in;
2304 }
2305 
2306 
2315 static void
2317  const struct GNUNET_MessageHeader *msg,
2318  void *impl_state)
2319 {
2320  struct Queue *queue = impl_state;
2321  uint16_t msize = ntohs (msg->size);
2322  struct TCPBox box;
2324  "In MQ send. Queue finishing: %s; write task running: %s\n",
2325  (GNUNET_YES == queue->finishing) ? "yes" : "no",
2326  (NULL == queue->write_task) ? "yes" : "no");
2327  GNUNET_assert (mq == queue->mq);
2328  queue->mq_awaits_continue = GNUNET_YES;
2329  if (GNUNET_YES == queue->finishing)
2330  return; /* this queue is dying, drop msg */
2331  GNUNET_assert (0 == queue->pwrite_off);
2333  box.header.size = htons (msize);
2334  calculate_hmac (&queue->out_hmac, msg, msize, &box.hmac);
2335  memcpy (&queue->pwrite_buf[queue->pwrite_off], &box, sizeof(box));
2336  queue->pwrite_off += sizeof(box);
2337  memcpy (&queue->pwrite_buf[queue->pwrite_off], msg, msize);
2338  queue->pwrite_off += msize;
2340  "%lu bytes of plaintext to send\n", queue->pwrite_off);
2341  GNUNET_assert (NULL != queue->sock);
2342  if (NULL == queue->write_task)
2343  queue->write_task =
2345  queue->sock,
2346  &queue_write,
2347  queue);
2348 }
2349 
2350 
2359 static void
2360 mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
2361 {
2362  struct Queue *queue = impl_state;
2363 
2364  if (mq == queue->mq)
2365  {
2366  queue->mq = NULL;
2367  queue_finish (queue);
2368  }
2369 }
2370 
2371 
2378 static void
2379 mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
2380 {
2381  struct Queue *queue = impl_state;
2382 
2383  GNUNET_assert (0 != queue->pwrite_off);
2384  queue->pwrite_off = 0;
2385 }
2386 
2387 
2397 static void
2398 mq_error (void *cls, enum GNUNET_MQ_Error error)
2399 {
2400  struct Queue *queue = cls;
2401 
2403  "MQ error in queue to %s: %d\n",
2404  GNUNET_i2s (&queue->target),
2405  (int) error);
2406  queue_finish (queue);
2407 }
2408 
2409 
2417 static void
2419 {
2420  queue->nt =
2421  GNUNET_NT_scanner_get_type (is, queue->address, queue->address_len);
2423  queue_map,
2424  &queue->target,
2425  queue,
2428  "# queues active",
2430  GNUNET_NO);
2431  queue->timeout =
2434  &mq_destroy,
2435  &mq_cancel,
2436  queue,
2437  NULL,
2438  &mq_error,
2439  queue);
2440 }
2441 
2442 
2453 static void
2455  const struct GNUNET_CRYPTO_EcdhePublicKey *epub)
2456 {
2457  struct TcpHandshakeSignature ths;
2458  struct TCPConfirmation tc;
2459 
2460  memcpy (queue->cwrite_buf, epub, sizeof(*epub));
2461  queue->cwrite_off = sizeof(*epub);
2462  /* compute 'tc' and append in encrypted format to cwrite_buf */
2463  tc.sender = my_identity;
2464  tc.monotonic_time =
2467  &tc.challenge,
2468  sizeof(tc.challenge));
2470  ths.purpose.size = htonl (sizeof(ths));
2471  ths.sender = my_identity;
2472  ths.receiver = queue->target;
2473  ths.ephemeral = *epub;
2474  ths.monotonic_time = tc.monotonic_time;
2475  ths.challenge = tc.challenge;
2477  &ths,
2478  &tc.sender_sig);
2479  GNUNET_assert (0 ==
2480  gcry_cipher_encrypt (queue->out_cipher,
2481  &queue->cwrite_buf[queue->cwrite_off],
2482  sizeof(tc),
2483  &tc,
2484  sizeof(tc)));
2485  queue->challenge = tc.challenge;
2486  queue->cwrite_off += sizeof(tc);
2487 
2489  "transport",
2490  "handshake written\n");
2491 }
2492 
2493 
2501 static void
2503 {
2504  struct GNUNET_CRYPTO_EcdhePublicKey epub;
2505 
2506  GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral);
2507  GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &epub);
2509  transmit_kx (queue, &epub);
2510 }
2511 
2512 
2518 static void
2519 handshake_monotime_store_cb (void *cls, int success)
2520 {
2521  struct Queue *queue = cls;
2522  if (GNUNET_OK != success)
2523  {
2525  "Failed to store handshake monotonic time in PEERSTORE!\n");
2526  }
2527  queue->handshake_monotime_sc = NULL;
2528 }
2529 
2530 
2538 static void
2540  const struct GNUNET_PEERSTORE_Record *record,
2541  const char *emsg)
2542 {
2543  struct Queue *queue = cls;
2544  struct GNUNET_TIME_AbsoluteNBO *mtbe;
2545  struct GNUNET_TIME_Absolute mt;
2546  const struct GNUNET_PeerIdentity *pid;
2547  struct GNUNET_TIME_AbsoluteNBO *handshake_monotonic_time;
2548 
2549  (void) emsg;
2550 
2551  handshake_monotonic_time = &queue->handshake_monotonic_time;
2552  pid = &queue->target;
2553  if (NULL == record)
2554  {
2555  queue->handshake_monotime_get = NULL;
2556  return;
2557  }
2558  if (sizeof(*mtbe) != record->value_size)
2559  {
2560  GNUNET_break (0);
2561  return;
2562  }
2563  mtbe = record->value;
2564  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
2566  queue->handshake_monotonic_time).abs_value_us)
2567  {
2569  "Queue from %s dropped, handshake monotime in the past\n",
2570  GNUNET_i2s (&queue->target));
2571  GNUNET_break (0);
2572  queue_finish (queue);
2573  return;
2574  }
2575  queue->handshake_monotime_sc = GNUNET_PEERSTORE_store (peerstore,
2576  "transport_tcp_communicator",
2577  pid,
2579  handshake_monotonic_time,
2580  sizeof(*
2581  handshake_monotonic_time),
2584  &
2586  queue);
2587 }
2588 
2589 
2601 static int
2603  struct TCPConfirmation *tc,
2604  char *ibuf)
2605 {
2606  struct TcpHandshakeSignature ths;
2607 
2608  GNUNET_assert (
2609  0 ==
2610  gcry_cipher_decrypt (queue->in_cipher,
2611  tc,
2612  sizeof(*tc),
2613  &ibuf[sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)],
2614  sizeof(*tc)));
2616  ths.purpose.size = htonl (sizeof(ths));
2617  ths.sender = tc->sender;
2618  ths.receiver = my_identity;
2619  memcpy (&ths.ephemeral, ibuf, sizeof(struct GNUNET_CRYPTO_EcdhePublicKey));
2620  ths.monotonic_time = tc->monotonic_time;
2621  ths.challenge = tc->challenge;
2622  queue->handshake_monotime_get =
2624  "transport_tcp_communicator",
2625  &queue->target,
2628  queue);
2631  &ths,
2632  &tc->sender_sig,
2633  &tc->sender.public_key);
2634 }
2635 
2636 
2642 static void
2644 {
2645  if (NULL != pq->listen_sock)
2646  {
2648  pq->listen_sock = NULL;
2649  }
2651  GNUNET_free (pq->address);
2653  GNUNET_free (pq);
2654 }
2655 
2656 
2663 static void
2664 proto_read_kx (void *cls)
2665 {
2666  struct ProtoQueue *pq = cls;
2667  ssize_t rcvd;
2668  struct GNUNET_TIME_Relative left;
2669  struct Queue *queue;
2670  struct TCPConfirmation tc;
2671 
2672  pq->read_task = NULL;
2674  if (0 == left.rel_value_us)
2675  {
2676  free_proto_queue (pq);
2677  return;
2678  }
2679  rcvd = GNUNET_NETWORK_socket_recv (pq->sock,
2680  &pq->ibuf[pq->ibuf_off],
2681  sizeof(pq->ibuf) - pq->ibuf_off);
2683  "Received %lu bytes for KX\n", rcvd);
2685  "transport",
2686  "Received %lu bytes for KX\n", rcvd);
2687  if (-1 == rcvd)
2688  {
2689  if ((EAGAIN != errno) && (EINTR != errno))
2690  {
2692  free_proto_queue (pq);
2693  return;
2694  }
2695  /* try again */
2696  pq->read_task =
2698  return;
2699  }
2700  pq->ibuf_off += rcvd;
2701  if (pq->ibuf_off > sizeof(pq->ibuf))
2702  {
2703  /* read more */
2704  pq->read_task =
2706  return;
2707  }
2708  /* we got all the data, let's find out who we are talking to! */
2709  queue = GNUNET_new (struct Queue);
2710  setup_in_cipher ((const struct GNUNET_CRYPTO_EcdhePublicKey *) pq->ibuf,
2711  queue);
2712  if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, pq->ibuf))
2713  {
2715  "Invalid TCP KX received from %s\n",
2716  GNUNET_a2s (pq->address, pq->address_len));
2717  gcry_cipher_close (queue->in_cipher);
2718  GNUNET_free (queue);
2719  free_proto_queue (pq);
2720  return;
2721  }
2722  queue->address = pq->address; /* steals reference */
2723  queue->address_len = pq->address_len;
2724  queue->target = tc.sender;
2725  queue->listen_sock = pq->listen_sock;
2726  queue->sock = pq->sock;
2727 
2728 
2730  "start kx proto\n");
2731 
2734  boot_queue (queue);
2735  queue->read_task =
2737  queue->sock,
2738  &queue_read,
2739  queue);
2740  queue->write_task =
2742  queue->sock,
2743  &queue_write,
2744  queue);
2745  // TODO To early! Move it somewhere else.
2746  // send_challenge (tc.challenge, queue);
2747  queue->challenge_received = tc.challenge;
2748 
2750  GNUNET_free (pq);
2751 }
2752 
2753 
2761 static void
2762 listen_cb (void *cls)
2763 {
2764  struct sockaddr_storage in;
2765  socklen_t addrlen;
2766  struct GNUNET_NETWORK_Handle *sock;
2767  struct ProtoQueue *pq;
2768  struct ListenTask *lt;
2769 
2771  "listen_cb\n");
2772 
2773  lt = cls;
2774 
2775  lt->listen_task = NULL;
2776  GNUNET_assert (NULL != lt->listen_sock);
2777  addrlen = sizeof(in);
2778  memset (&in, 0, sizeof(in));
2780  (struct sockaddr*) &in,
2781  &addrlen);
2782  if ((NULL == sock) && ((EMFILE == errno) || (ENFILE == errno)))
2783  return; /* system limit reached, wait until connection goes down */
2785  lt->listen_sock,
2786  &listen_cb,
2787  lt);
2788  if ((NULL == sock) && ((EAGAIN == errno) || (ENOBUFS == errno)))
2789  return;
2790  if (NULL == sock)
2791  {
2793  return;
2794  }
2795  pq = GNUNET_new (struct ProtoQueue);
2796  pq->address_len = addrlen;
2797  pq->address = GNUNET_memdup (&in, addrlen);
2799  pq->sock = sock;
2801  pq->sock,
2802  &proto_read_kx,
2803  pq);
2805 }
2806 
2807 
2815 static void
2816 queue_read_kx (void *cls)
2817 {
2818  struct Queue *queue = cls;
2819  ssize_t rcvd;
2820  struct GNUNET_TIME_Relative left;
2821  struct TCPConfirmation tc;
2822 
2823  queue->read_task = NULL;
2824  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
2825  if (0 == left.rel_value_us)
2826  {
2827  queue_destroy (queue);
2828  return;
2829  }
2830  rcvd = GNUNET_NETWORK_socket_recv (queue->sock,
2831  &queue->cread_buf[queue->cread_off],
2832  BUF_SIZE - queue->cread_off);
2834  "Received %lu bytes for KX\n",
2835  rcvd);
2837  "transport",
2838  "Received %lu bytes for KX\n",
2839  rcvd);
2840  if (-1 == rcvd)
2841  {
2842  if ((EAGAIN != errno) && (EINTR != errno))
2843  {
2845  queue_destroy (queue);
2846  return;
2847  }
2848  queue->read_task =
2850  return;
2851  }
2852  queue->cread_off += rcvd;
2853  if (queue->cread_off < INITIAL_KX_SIZE)
2854  {
2855  /* read more */
2856  queue->read_task =
2858  return;
2859  }
2860  /* we got all the data, let's find out who we are talking to! */
2862  queue->cread_buf,
2863  queue);
2864  if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, queue->cread_buf))
2865  {
2867  "Invalid TCP KX received from %s\n",
2868  GNUNET_a2s (queue->address, queue->address_len));
2869  queue_destroy (queue);
2870  return;
2871  }
2872  if (0 !=
2873  memcmp (&tc.sender, &queue->target, sizeof(struct GNUNET_PeerIdentity)))
2874  {
2876  "Invalid sender in TCP KX received from %s\n",
2877  GNUNET_a2s (queue->address, queue->address_len));
2878  queue_destroy (queue);
2879  return;
2880  }
2881  send_challenge (tc.challenge, queue);
2882  queue->write_task =
2884  queue->sock,
2885  &queue_write,
2886  queue);
2887 
2888  /* update queue timeout */
2890  /* prepare to continue with regular read task immediately */
2891  memmove (queue->cread_buf,
2892  &queue->cread_buf[INITIAL_KX_SIZE],
2893  queue->cread_off - (INITIAL_KX_SIZE));
2895  "cread_off is %lu bytes before adjusting\n",
2896  queue->cread_off);
2897  queue->cread_off -= INITIAL_KX_SIZE;
2899  "cread_off set to %lu bytes\n",
2900  queue->cread_off);
2902 }
2903 
2904 
2923 static int
2924 mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
2925 {
2926  struct Queue *queue;
2927  const char *path;
2928  struct sockaddr *in;
2929  socklen_t in_len = 0;
2930  struct GNUNET_NETWORK_Handle *sock;
2931 
2933  "Connecting to %s\n", address);
2935  "transport",
2936  "Connecting to %s\n", address);
2937  if (0 != strncmp (address,
2939  strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
2940  {
2941  GNUNET_break_op (0);
2942  return GNUNET_SYSERR;
2943  }
2944  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
2945  in = tcp_address_to_sockaddr (path, &in_len);
2946 
2947  if (NULL == in)
2948  {
2950  "Failed to setup TCP socket address\n");
2951  return GNUNET_SYSERR;
2952  }
2953 
2955  "in %s\n",
2956  GNUNET_a2s (in, in_len));
2957 
2958  sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP);
2959  if (NULL == sock)
2960  {
2962  "socket(%d) failed: %s",
2963  in->sa_family,
2964  strerror (errno));
2965  GNUNET_free (in);
2966  return GNUNET_SYSERR;
2967  }
2968  if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (sock, in, in_len)) &&
2969  (errno != EINPROGRESS))
2970  {
2972  "connect to `%s' failed: %s",
2973  address,
2974  strerror (errno));
2976  GNUNET_free (in);
2977  return GNUNET_SYSERR;
2978  }
2979 
2980  queue = GNUNET_new (struct Queue);
2981  queue->target = *peer;
2982  queue->address = in;
2983  queue->address_len = in_len;
2984  queue->sock = sock;
2986  boot_queue (queue);
2987  // queue->mq_awaits_continue = GNUNET_YES;
2988  queue->read_task =
2990  queue->sock,
2991  &queue_read_kx,
2992  queue);
2993 
2994 
2996  "start kx mq_init\n");
2997 
2999  queue->write_task =
3001  queue->sock,
3002  &queue_write,
3003  queue);
3004  return GNUNET_OK;
3005 }
3006 
3007 
3016 static int
3017 get_lt_delete_it (void *cls,
3018  const struct GNUNET_HashCode *key,
3019  void *value)
3020 {
3021  struct ListenTask *lt = value;
3022 
3023  (void) cls;
3024  (void) key;
3025  if (NULL != lt->listen_task)
3026  {
3028  lt->listen_task = NULL;
3029  }
3030  if (NULL != lt->listen_sock)
3031  {
3033  lt->listen_sock = NULL;
3034  }
3035  return GNUNET_OK;
3036 }
3037 
3038 
3047 static int
3049  const struct GNUNET_PeerIdentity *target,
3050  void *value)
3051 {
3052  struct Queue *queue = value;
3053 
3054  (void) cls;
3055  (void) target;
3056  queue_destroy (queue);
3057  return GNUNET_OK;
3058 }
3059 
3060 
3066 static void
3067 do_shutdown (void *cls)
3068 {
3070  "Shutdown %s!\n",
3071  shutdown_running ? "running" : "not running");
3072 
3074  return;
3075  else
3077 
3078  while (NULL != proto_head)
3080  if (NULL != nat)
3081  {
3083  nat = NULL;
3084  }
3088  if (NULL != ch)
3089  {
3092  ch = NULL;
3093  }
3094  if (NULL != stats)
3095  {
3097  stats = NULL;
3098  }
3099  if (NULL != my_private_key)
3100  {
3102  my_private_key = NULL;
3103  }
3104  if (NULL != is)
3105  {
3107  is = NULL;
3108  }
3109  if (NULL != peerstore)
3110  {
3112  peerstore = NULL;
3113  }
3114  if (NULL != resolve_request_handle)
3115  {
3117  resolve_request_handle = NULL;
3118  }
3120  "Shutdown done!\n");
3121 }
3122 
3123 
3135 static void
3136 enc_notify_cb (void *cls,
3137  const struct GNUNET_PeerIdentity *sender,
3138  const struct GNUNET_MessageHeader *msg)
3139 {
3140  (void) cls;
3141  (void) sender;
3142  (void) msg;
3143  GNUNET_break_op (0);
3144 }
3145 
3146 
3160 static void
3161 nat_address_cb (void *cls,
3162  void **app_ctx,
3163  int add_remove,
3165  const struct sockaddr *addr,
3166  socklen_t addrlen)
3167 {
3168  char *my_addr;
3170 
3172  "nat address cb %s %s\n",
3173  add_remove ? "add" : "remove",
3174  GNUNET_a2s (addr, addrlen));
3175 
3176  if (GNUNET_YES == add_remove)
3177  {
3178  enum GNUNET_NetworkType nt;
3179 
3180  GNUNET_asprintf (&my_addr,
3181  "%s-%s",
3183  GNUNET_a2s (addr, addrlen));
3184  nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
3185  ai =
3187  my_addr,
3188  nt,
3190  GNUNET_free (my_addr);
3191  *app_ctx = ai;
3192  }
3193  else
3194  {
3195  ai = *app_ctx;
3197  *app_ctx = NULL;
3198  }
3199 }
3200 
3201 
3205 static void
3206 add_addr (struct sockaddr *in, socklen_t in_len)
3207 {
3208 
3209  struct Addresses *saddrs;
3210 
3212  "add address %s\n",
3213  GNUNET_a2s (in, in_len));
3214 
3215  saddrs = GNUNET_new (struct Addresses);
3216  saddrs->addr = in;
3217  saddrs->addr_len = in_len;
3219 
3221  "after add address %s\n",
3222  GNUNET_a2s (in, in_len));
3223 
3225  "add address %s\n",
3226  GNUNET_a2s (saddrs->addr, saddrs->addr_len));
3227 
3228  addrs_lens++;
3229 }
3230 
3231 
3239 static int
3240 init_socket (struct sockaddr *addr,
3241  socklen_t in_len)
3242 {
3243  struct sockaddr_storage in_sto;
3244  socklen_t sto_len;
3245  struct GNUNET_NETWORK_Handle *listen_sock;
3246  struct ListenTask *lt;
3247  int sockfd;
3248  struct GNUNET_HashCode h_sock;
3249 
3250  if (NULL == addr)
3251  {
3253  "Address is NULL.\n");
3254  return GNUNET_SYSERR;
3255  }
3256 
3258  "address %s\n",
3259  GNUNET_a2s (addr, in_len));
3260 
3261  listen_sock =
3262  GNUNET_NETWORK_socket_create (addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
3263  if (NULL == listen_sock)
3264  {
3266  return GNUNET_SYSERR;
3267  }
3268 
3269  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (listen_sock, addr, in_len))
3270  {
3272  GNUNET_NETWORK_socket_close (listen_sock);
3273  listen_sock = NULL;
3274  return GNUNET_SYSERR;
3275  }
3276 
3277  if (GNUNET_OK !=
3278  GNUNET_NETWORK_socket_listen (listen_sock,
3279  5))
3280  {
3282  "listen");
3283  GNUNET_NETWORK_socket_close (listen_sock);
3284  listen_sock = NULL;
3285  return GNUNET_SYSERR;
3286  }
3287 
3288  /* We might have bound to port 0, allowing the OS to figure it out;
3289  thus, get the real IN-address from the socket */
3290  sto_len = sizeof(in_sto);
3291 
3292  if (0 != getsockname (GNUNET_NETWORK_get_fd (listen_sock),
3293  (struct sockaddr *) &in_sto,
3294  &sto_len))
3295  {
3296  memcpy (&in_sto, addr, in_len);
3297  sto_len = in_len;
3298  }
3299 
3300  // addr = (struct sockaddr *) &in_sto;
3301  in_len = sto_len;
3303  "Bound to `%s'\n",
3304  GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len));
3305  stats = GNUNET_STATISTICS_create ("C-TCP", cfg);
3306 
3307  if (NULL == is)
3309 
3310  if (NULL == my_private_key)
3312  if (NULL == my_private_key)
3313  {
3314  GNUNET_log (
3316  _ (
3317  "Transport service is lacking key configuration settings. Exiting.\n"));
3318  if (NULL != resolve_request_handle)
3321  return GNUNET_SYSERR;
3322  }
3324  /* start listening */
3325 
3326  lt = GNUNET_new (struct ListenTask);
3327  lt->listen_sock = listen_sock;
3328 
3330  listen_sock,
3331  &listen_cb,
3332  lt);
3333 
3335  "creating hash\n");
3336  sockfd = GNUNET_NETWORK_get_fd (lt->listen_sock);
3337  GNUNET_CRYPTO_hash (&sockfd,
3338  sizeof(int),
3339  &h_sock);
3340 
3342  "creating map\n");
3343  if (NULL == lt_map)
3345 
3347  "creating map entry\n");
3350  &h_sock,
3351  lt,
3353 
3355  "map entry created\n");
3356 
3357  if (NULL == queue_map)
3359 
3360  if (NULL == ch)
3365  &mq_init,
3366  NULL,
3367  &enc_notify_cb,
3368  NULL);
3369 
3370  if (NULL == ch)
3371  {
3372  GNUNET_break (0);
3373  if (NULL != resolve_request_handle)
3376  return GNUNET_SYSERR;
3377  }
3378 
3379  add_addr (addr, in_len);
3380  return GNUNET_OK;
3381 
3382 }
3383 
3384 
3388 static void
3390 {
3391 
3392  struct sockaddr **saddrs;
3393  socklen_t *saddr_lens;
3394  int i;
3395  struct Addresses *pos;
3396 
3397 
3399  "starting nat register!\n");
3400 
3401  i = 0;
3402  saddrs = GNUNET_malloc ((addrs_lens + 1) * sizeof(struct sockaddr *));
3403 
3404  saddr_lens = GNUNET_malloc ((addrs_lens + 1) * sizeof(socklen_t));
3405 
3406  for (pos = addrs_head; NULL != pos; pos = pos->next)
3407  {
3408 
3410  "registering address %s\n",
3412 
3413  saddr_lens[i] = addrs_head->addr_len;
3414  saddrs[i] = GNUNET_memdup (addrs_head->addr, saddr_lens[i]);
3415 
3416  i++;
3417 
3418  }
3419 
3422  IPPROTO_TCP,
3423  addrs_lens,
3424  (const struct sockaddr **) saddrs,
3425  saddr_lens,
3426  &nat_address_cb,
3427  NULL /* FIXME: support reversal: #5529 */,
3428  NULL /* closure */);
3429 
3430  i = 0;
3431 
3432  for (i = addrs_lens - 1; i >= 0; i--)
3433  GNUNET_free (saddrs[i]);
3434  GNUNET_free (saddrs);
3435  GNUNET_free (saddr_lens);
3436 
3437  if (NULL == nat)
3438  {
3439  GNUNET_break (0);
3440  if (NULL != resolve_request_handle)
3443  }
3444 }
3445 
3446 
3454 static void
3456  const struct sockaddr *addr,
3457  socklen_t in_len)
3458 {
3459  struct sockaddr_in *v4;
3460  struct sockaddr_in6 *v6;
3461  struct sockaddr *in;
3462 
3463  (void) cls;
3464  if (NULL != addr)
3465  {
3466  if (AF_INET == addr->sa_family)
3467  {
3468  v4 = (struct sockaddr_in *) addr;
3469  in = tcp_address_to_sockaddr_numeric_v4 (&in_len, *v4, bind_port);// _global);
3470  }
3471  else if (AF_INET6 == addr->sa_family)
3472  {
3473  v6 = (struct sockaddr_in6 *) addr;
3474  in = tcp_address_to_sockaddr_numeric_v6 (&in_len, *v6, bind_port);// _global);
3475  }
3476  else
3477  {
3479  "Address family %u not suitable (not AF_INET %u nor AF_INET6 %u \n",
3480  addr->sa_family,
3481  AF_INET,
3482  AF_INET6);
3483  return;
3484  }
3485  init_socket (in, in_len);
3486  }
3487  else
3488  {
3490  "Address is NULL. This might be an error or the resolver finished resolving.\n");
3491  if (NULL == addrs_head)
3492  {
3494  "Resolver finished resolving, but we do not listen to an address!.\n");
3495  return;
3496  }
3497  nat_register ();
3498 
3499  }
3500 }
3501 
3502 
3511 static void
3512 run (void *cls,
3513  char *const *args,
3514  const char *cfgfile,
3515  const struct GNUNET_CONFIGURATION_Handle *c)
3516 {
3517  char *bindto;
3518  struct sockaddr *in;
3519  socklen_t in_len;
3520  struct sockaddr_in v4;
3521  struct sockaddr_in6 v6;
3522  char *start;
3523  unsigned int port;
3524  char dummy[2];
3525  char *rest = NULL;
3526  struct PortOnlyIpv4Ipv6 *po;
3527  socklen_t addr_len_ipv4;
3528  socklen_t addr_len_ipv6;
3529 
3530  (void) cls;
3531  cfg = c;
3532  if (GNUNET_OK !=
3535  "BINDTO",
3536  &bindto))
3537  {
3540  "BINDTO");
3541  return;
3542  }
3543  if (GNUNET_OK !=
3546  "MAX_QUEUE_LENGTH",
3547  &max_queue_length))
3549  if (GNUNET_OK !=
3552  "REKEY_INTERVAL",
3553  &rekey_interval))
3555 
3557  if (NULL == peerstore)
3558  {
3559  GNUNET_free (bindto);
3560  GNUNET_break (0);
3562  return;
3563  }
3564 
3566 
3567  if (1 == sscanf (bindto, "%u%1s", &bind_port, dummy))
3568  {
3570 
3572 
3573 
3575  "address po %s\n",
3577 
3578  if (NULL != po->addr_ipv4)
3579  {
3581  }
3582 
3583  if (NULL != po->addr_ipv6)
3584  {
3587  }
3588 
3589  GNUNET_free (po);
3590  nat_register ();
3591  GNUNET_free (bindto);
3592  return;
3593  }
3594 
3595  start = extract_address (bindto);
3596 
3597  if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
3598  {
3599  bind_port = extract_port (bindto);
3600 
3601  in = tcp_address_to_sockaddr_numeric_v4 (&in_len, v4, bind_port);
3602  init_socket (in, in_len);
3603  nat_register ();
3604  GNUNET_free (start);
3605  GNUNET_free (bindto);
3606  return;
3607  }
3608 
3609  if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
3610  {
3611  bind_port = extract_port (bindto);
3612  in = tcp_address_to_sockaddr_numeric_v6 (&in_len, v6, bind_port);
3613  init_socket (in, in_len);
3614  nat_register ();
3615  GNUNET_free (start);
3616  GNUNET_free (bindto);
3617  return;
3618  }
3619 
3620 
3621  bind_port = extract_port (bindto);
3622 
3623  resolve_request_handle = GNUNET_RESOLVER_ip_get (strtok_r (bindto, ":",
3624  &rest),
3625  AF_UNSPEC,
3628  &port);
3629  GNUNET_free (bindto);
3630  GNUNET_free (start);
3631 }
3632 
3633 
3641 int
3642 main (int argc, char *const *argv)
3643 {
3644  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
3646  };
3647  int ret;
3648 
3649  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
3650  return 2;
3651 
3652  ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
3653  argv,
3654  "gnunet-communicator-tcp",
3655  _ ("GNUnet TCP communicator"),
3656  options,
3657  &run,
3658  NULL))
3659  ? 0
3660  : 1;
3661  GNUNET_free_nz ((void *) argv);
3662  return ret;
3663 }
3664 
3665 
3666 /* end of gnunet-communicator-tcp.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static int res
static void done()
static uint16_t port
Port number.
Definition: gnunet-bcd.c:83
static void calculate_hmac(struct GNUNET_HashCode *hmac_secret, const void *buf, size_t buf_size, struct GNUNET_ShortHashCode *smac)
Compute mac over buf, and ratched the hmac_secret.
static void queue_finish(struct Queue *queue)
Append a 'finish' message to the outgoing transmission.
static struct GNUNET_CONTAINER_MultiPeerMap * queue_map
Queues (map from peer identity to struct Queue)
static void boot_queue(struct Queue *queue)
Add the given queue to our internal data structure.
unsigned int bind_port
The port the communicator should be assigned to.
struct ListenTask * lts_tail
Head of DLL with ListenTask.
static size_t try_handle_plaintext(struct Queue *queue)
Test if we have received a full message in plaintext.
static void pass_plaintext_to_core(struct Queue *queue, const void *plaintext, size_t plaintext_len)
We received plaintext_len bytes of plaintext on queue.
size_t unverified_size
Size of data received without KX challenge played back.
static struct GNUNET_PeerIdentity my_identity
Our public key.
static int get_queue_delete_it(void *cls, const struct GNUNET_PeerIdentity *target, void *value)
Iterator over all message queues to clean up.
#define COMMUNICATOR_ADDRESS_PREFIX
Address prefix used by the communicator.
static void mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state)
Signature of functions implementing the destruction of a message queue.
#define ADDRESS_VALIDITY_PERIOD
How long do we believe our addresses to remain up (before the other peer should revalidate).
static void send_challenge(struct ChallengeNonceP challenge, struct Queue *queue)
Sending challenge with TcpConfirmationAck back to sender of ephemeral key.
#define INITIAL_CORE_KX_SIZE
Size of the initial core key exchange messages.
static void do_rekey(struct Queue *queue, const struct TCPRekey *rekey)
Handle rekey message on queue.
static int init_socket(struct sockaddr *addr, socklen_t in_len)
This method launch network interactions for each address we like to bind to.
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.
static void listen_cb(void *cls)
We have been notified that our listen socket has something to read.
static void rekey_monotime_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY where...
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
static void queue_destroy(struct Queue *queue)
Functions with this signature are called whenever we need to close a queue due to a disconnect or fai...
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void enc_notify_cb(void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
Function called when the transport service has received an acknowledgement for this communicator (!...
static void handshake_ack_monotime_store_cb(void *cls, int success)
Callback called when peerstore store operation for handshake ack monotime value is finished.
static struct GNUNET_PEERSTORE_Handle * peerstore
Database for peer's HELLOs.
static struct ProtoQueue * proto_tail
Protoqueues DLL tail.
static void queue_read_kx(void *cls)
Read from the socket of the queue until we have enough data to initialize the decryption logic and ca...
static int get_lt_delete_it(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over all ListenTasks to clean up.
static void inject_rekey(struct Queue *queue)
Inject a struct TCPRekey message into the queue's plaintext buffer.
static struct GNUNET_TIME_Relative rekey_interval
The rekey interval.
static struct PortOnlyIpv4Ipv6 * tcp_address_to_sockaddr_port_only(const char *bindto, unsigned int *port)
Convert TCP bind specification to a struct PortOnlyIpv4Ipv6 *
#define BUF_SIZE
Size of our IO buffers for ciphertext data.
static void reschedule_queue_timeout(struct Queue *queue)
Increment queue timeout due to activity.
static void do_shutdown(void *cls)
Shutdown the UNIX communicator.
#define COMMUNICATOR_CONFIG_SECTION
Configuration section used by the communicator.
static void proto_read_kx(void *cls)
Read from the socket of the proto queue until we have enough data to upgrade to full queue.
static char * extract_address(const char *bindto)
This Method extracts the address part of the BINDTO string.
static void nat_address_cb(void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of ...
static void init_socket_resolv(void *cls, const struct sockaddr *addr, socklen_t in_len)
This method is the callback called by the resolver API, and wraps method init_socket.
static struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Our environment.
static unsigned long long max_queue_length
Maximum queue length before we stop reading towards the transport service.
struct GNUNET_RESOLVER_RequestHandle * resolve_request_handle
Handle for DNS lookup of bindto address.
static void nat_register()
This method reads from the DLL addrs_head to register them at the NAT service.
int addrs_lens
Number of addresses in the DLL for register at NAT service.
static struct sockaddr * tcp_address_to_sockaddr(const char *bindto, socklen_t *sock_len)
Convert TCP bind specification to a struct sockaddr *
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Setup communicator and launch network interactions.
struct ListenTask * lts_head
Head of DLL with ListenTasks.
static struct GNUNET_NAT_Handle * nat
Connection to NAT service.
#define PROTO_QUEUE_TIMEOUT
How long do we wait until we must have received the initial KX?
static void queue_read(void *cls)
Queue read task.
#define REKEY_MAX_BYTES
How often do we rekey based on number of bytes transmitted? (additionally randomized).
static void mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
#define INITIAL_KX_SIZE
Size of the initial key exchange message sent first in both directions.
static void handshake_ack_monotime_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_A...
static int mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
Function called by the transport service to initialize a message queue given address information abou...
static void setup_out_cipher(struct Queue *queue)
Setup cipher for outgoing data stream based on target and our ephemeral private key.
static void setup_cipher(const struct GNUNET_HashCode *dh, const struct GNUNET_PeerIdentity *pid, gcry_cipher_hd_t *cipher, struct GNUNET_HashCode *hmac_key)
Setup cipher based on shared secret dh and decrypting peer pid.
static struct sockaddr * tcp_address_to_sockaddr_numeric_v4(socklen_t *sock_len, struct sockaddr_in v4, unsigned int port)
Convert a struct sockaddr_in4 to astruct sockaddr *`.
static void handshake_monotime_store_cb(void *cls, int success)
Callback called when peerstore store operation for handshake monotime is finished.
static void rekey_monotime_store_cb(void *cls, int success)
Callback called when peerstore store operation for rekey monotime value is finished.
static struct ProtoQueue * proto_head
Protoqueues DLL head.
static void setup_in_cipher(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, struct Queue *queue)
Setup cipher of queue for decryption.
int shutdown_running
A flag indicating we are already doing a shutdown.
static void transmit_kx(struct Queue *queue, const struct GNUNET_CRYPTO_EcdhePublicKey *epub)
Generate and transmit our ephemeral key and the signature for the initial KX with the other peer.
static int decrypt_and_check_tc(struct Queue *queue, struct TCPConfirmation *tc, char *ibuf)
We have received the first bytes from the other side on a queue.
#define DEFAULT_REKEY_INTERVAL
How often do we rekey based on time (at least)
int main(int argc, char *const *argv)
The main function for the UNIX communicator.
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
static void queue_write(void *cls)
We have been notified that our socket is ready to write.
static void add_addr(struct sockaddr *in, socklen_t in_len)
This method adds addresses to the DLL, that are later register at the NAT service.
static void handshake_monotime_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE w...
struct Addresses * addrs_head
Head of DLL with addresses we like to register at NAT servcie.
struct Addresses * addrs_tail
Head of DLL with addresses we like to register at NAT servcie.
#define DEFAULT_MAX_QUEUE_LENGTH
How many messages do we keep at most in the queue to the transport service before we start to drop (d...
static void mq_error(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
static unsigned int extract_port(const char *addr_and_port)
This Method extracts the port part of the BINDTO string.
static void mq_send(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Signature of functions implementing the sending functionality of a message queue.
static void start_initial_kx_out(struct Queue *queue)
Initialize our key material for outgoing transmissions and inform the other peer about it.
static void free_proto_queue(struct ProtoQueue *pq)
Closes socket and frees memory associated with pq.
static struct GNUNET_CONTAINER_MultiHashMap * lt_map
ListenTasks (map from socket to struct ListenTask)
static void core_read_finished_cb(void *cls, int success)
Core tells us it is done processing a message that transport received on a queue with status success.
static struct sockaddr * tcp_address_to_sockaddr_numeric_v6(socklen_t *sock_len, struct sockaddr_in6 v6, unsigned int port)
Convert a struct sockaddr_in6 to astruct sockaddr *`.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static char * address
GNS address for this phone.
struct GNUNET_HashCode key
The key used in the DHT.
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static char * value
Value of the record to add/remove.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
static struct GNUNET_MQ_Envelope * ac
Handle to current GNUNET_PEERINFO_add_peer() operation.
static char buf[2048]
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
static void queue(const char *hostname)
Add hostname to the list of requests to be made.
#define GNUNET_NETWORK_STRUCT_BEGIN
Define as empty, GNUNET_PACKED should suffice, but this won't work on W32.
#define GNUNET_log(kind,...)
#define GNUNET_NETWORK_STRUCT_END
Define as empty, GNUNET_PACKED should suffice, but this won't work on W32;.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_MIN(a, b)
void GNUNET_CRYPTO_hmac_raw(const void *key, size_t key_len, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104) TODO: Shouldn' this be the standard hmac function and the abov...
Definition: crypto_hash.c:274
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don't receive messages from the peer?
void GNUNET_CRYPTO_ecdhe_key_create(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:435
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Random on unsigned 64-bit values.
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer's key from the file specified in the configuration.
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:197
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_ecdh(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a ECDH public key and a private EdDSA key.
Definition: crypto_ecc.c:718
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdh_eddsa(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a EdDSA public key and a private ECDH key.
Definition: crypto_ecc.c:758
#define GNUNET_CRYPTO_eddsa_sign(priv, ps, sig)
EdDSA sign a given block.
#define GNUNET_CRYPTO_eddsa_verify(purp, ps, sig, pub)
Verify EdDSA signature.
void GNUNET_CRYPTO_ecdhe_key_get_public(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, struct GNUNET_CRYPTO_EcdhePublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:213
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
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
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_kdf(void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_kdf.c:90
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
const char * GNUNET_e2s(const struct GNUNET_CRYPTO_EcdhePublicKey *p)
Convert a public key value to a string (for printing debug messages).
#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.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#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...
void GNUNET_log_from_nocheck(enum GNUNET_ErrorType kind, const char *comp, const char *message,...) __attribute__((format(printf
Log function that specifies an alternative component.
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).
const char * GNUNET_p2s(const struct GNUNET_CRYPTO_EddsaPublicKey *p)
Convert a public key value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#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.
#define GNUNET_free_nz(ptr)
Wrapper around free.
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
GNUNET_MQ_Error
Error codes for the queue.
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:565
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:499
void GNUNET_NAT_unregister(struct GNUNET_NAT_Handle *nh)
Stop port redirection and public IP address detection for the given handle.
Definition: nat_api.c:692
GNUNET_NAT_AddressClass
Some addresses contain sensitive information or are not suitable for global distribution.
struct GNUNET_NAT_Handle * GNUNET_NAT_register(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section, uint8_t proto, unsigned int num_addrs, const struct sockaddr **addrs, const socklen_t *addrlens, GNUNET_NAT_AddressCallback address_callback, GNUNET_NAT_ReversalCallback reversal_callback, void *callback_cls)
Attempt to enable port redirection and detect public IP address contacting UPnP or NAT-PMP routers on...
Definition: nat_api.c:378
int GNUNET_NETWORK_get_fd(const struct GNUNET_NETWORK_Handle *desc)
Return file descriptor for this network handle.
Definition: network.c:1075
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:783
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
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:907
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:812
int GNUNET_NETWORK_socket_listen(const struct GNUNET_NETWORK_Handle *desc, int backlog)
Listen on a socket.
Definition: network.c:708
int GNUNET_NETWORK_test_pf(int pf)
Test if the given protocol family is supported by this system.
Definition: network.c:85
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_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
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:36
void GNUNET_NT_scanner_done(struct GNUNET_NT_InterfaceScanner *is)
Terminate interface scanner.
Definition: nt.c:433
struct GNUNET_NT_InterfaceScanner * GNUNET_NT_scanner_init(void)
Initialize the address characterization client handle.
Definition: nt.c:412
enum GNUNET_NetworkType GNUNET_NT_scanner_get_type(struct GNUNET_NT_InterfaceScanner *is, const struct sockaddr *addr, socklen_t addrlen)
Returns where the address is located: loopback, LAN or WAN.
Definition: nt.c:314
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
struct GNUNET_PEERSTORE_StoreContext * GNUNET_PEERSTORE_store(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
Store a new entry in the PEERSTORE.
void GNUNET_PEERSTORE_store_cancel(struct GNUNET_PEERSTORE_StoreContext *sc)
Cancel a store request.
void GNUNET_PEERSTORE_iterate_cancel(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iterate request Please do not call after the iterate request is done.
#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE
Key used to store sender's monotonic time from handshake message.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h, int sync_first)
Disconnect from the PEERSTORE service.
#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK
Key used to store sender's monotonic time from handshake ack message.
#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY
Key used to store sender's monotonic time from rekey message.
struct GNUNET_PEERSTORE_IterateContext * GNUNET_PEERSTORE_iterate(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Iterate over records matching supplied key information.
@ GNUNET_PEERSTORE_STOREOPTION_REPLACE
Delete any previous values for the given key before storing the given value.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:364
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK
TCP communicator confirmation ack.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH
TCP communicator end of stream.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX
TCP communicator payload box.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY
TCP communicator rekey message.
void GNUNET_RESOLVER_request_cancel(struct GNUNET_RESOLVER_RequestHandle *rh)
Cancel a request that is still pending with the resolver.
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_ip_get(const char *hostname, int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *callback_cls)
Convert a string to one or more IP addresses.
Definition: resolver_api.c:939
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1588
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1517
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1331
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
#define GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE
Signature used by TCP communicator handshake,.
#define GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE_ACK
Signature by a peer sending back the nonce received at initial handshake.
#define GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY
Signature used by TCP communicator rekey.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1209
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:232
#define GNUNET_TIME_UNIT_MINUTES
One minute.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:604
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:542
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:181
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_monotonic(const struct GNUNET_CONFIGURATION_Handle *cfg)
Obtain the current time and make sure it is monotonically increasing.
Definition: time.c:658
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:557
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:464
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
void GNUNET_TRANSPORT_communicator_address_remove(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Notify transport service about an address that this communicator no longer provides for this peer.
int GNUNET_TRANSPORT_communicator_receive(struct GNUNET_TRANSPORT_CommunicatorHandle *handle, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, struct GNUNET_TIME_Relative expected_addr_validity, GNUNET_TRANSPORT_MessageCompletedCallback cb, void *cb_cls)
Notify transport service that the communicator has received a message.
void GNUNET_TRANSPORT_communicator_mq_del(struct GNUNET_TRANSPORT_QueueHandle *qh)
Notify transport service that an MQ became unavailable due to a disconnect or timeout.
#define GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED
Queue length.
struct GNUNET_TRANSPORT_QueueHandle * GNUNET_TRANSPORT_communicator_mq_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *peer, const char *address, uint32_t mtu, uint64_t q_len, uint32_t priority, enum GNUNET_NetworkType nt, enum GNUNET_TRANSPORT_ConnectionStatus cs, struct GNUNET_MQ_Handle *mq)
Notify transport service that a MQ became available due to an "inbound" connection or because the com...
struct GNUNET_TRANSPORT_AddressIdentifier * GNUNET_TRANSPORT_communicator_address_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Relative expiration)
Notify transport service about an address that this communicator provides for this peer.
void GNUNET_TRANSPORT_communicator_disconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Disconnect from the transport service.
GNUNET_TRANSPORT_ConnectionStatus
Possible states of a connection.
void GNUNET_TRANSPORT_communicator_address_remove_all(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Notify transport service that this communicator no longer provides all its addresses for this peer.
struct GNUNET_TRANSPORT_CommunicatorHandle * GNUNET_TRANSPORT_communicator_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section_name, const char *addr_prefix, enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc, GNUNET_TRANSPORT_CommunicatorMqInit mq_init, void *mq_init_cls, GNUNET_TRANSPORT_CommunicatorNotify notify_cb, void *notify_cb_cls)
Connect to the transport service.
@ GNUNET_TRANSPORT_CC_RELIABLE
Transmission is reliabile (with ACKs), e.g.
@ GNUNET_TRANSPORT_CS_INBOUND
this is an inbound connection (communicator initiated)
@ GNUNET_TRANSPORT_CS_OUTBOUND
this is an outbound connection (transport initiated)
#define max(x, y)
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:423
DLL to store the addresses we like to register at NAT service.
struct Addresses * next
Kept in a DLL.
struct Addresses * prev
Kept in a DLL.
struct sockaddr * addr
Address we like to register at NAT service.
socklen_t addr_len
Length of address we like to register at NAT service.
Type of a nonce used for challenges.
Internal representation of the hash map.
Internal representation of the hash map.
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
Private ECC key encoded for transmission.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and encr...
Private ECC key encoded for transmission.
an ECC signature using EdDSA.
Definition of a command line option.
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:86
Header for all communications.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Handle for active NAT registrations.
Definition: nat_api.c:72
handle to a socket
Definition: network.c:53
Handle to the interface scanner.
Definition: nt.c:111
Handle to the PEERSTORE service.
Definition: peerstore_api.c:41
Context for a iterate request.
Single PEERSTORE record.
Context for a store request.
Definition: peerstore_api.c:97
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Handle to a request given to the resolver.
Definition: resolver_api.c:103
Entry in list of pending tasks.
Definition: scheduler.c:135
Handle for the service.
A 256-bit hashcode.
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
Internal representation of an address a communicator is currently providing for the transport service...
Opaque handle to the transport service for communicators.
Handle returned to identify the internal data structure the transport API has created to manage a mes...
Struct to use as closure.
struct GNUNET_NETWORK_Handle * listen_sock
Listen socket.
struct GNUNET_SCHEDULER_Task * listen_task
ID of listen task.
In case of port only configuration we like to bind to ipv4 and ipv6 addresses.
struct sockaddr * addr_ipv4
Ipv4 address we like to bind to.
struct sockaddr * addr_ipv6
Ipv6 address we like to bind to.
socklen_t addr_len_ipv6
Length of ipv6 address.
socklen_t addr_len_ipv4
Length of ipv4 address.
Handle for an incoming connection where we do not yet have enough information to setup a full queue.
socklen_t address_len
Length of the address.
struct GNUNET_NETWORK_Handle * listen_sock
Listen socket.
size_t ibuf_off
Current offset for reading into ibuf.
struct GNUNET_TIME_Absolute timeout
Timeout for this protoqueue.
struct GNUNET_NETWORK_Handle * sock
socket that we transmit all data with on this queue
struct sockaddr * address
Address of the other peer.
struct ProtoQueue * prev
Kept in a DLL.
char ibuf[(sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)+sizeof(struct TCPConfirmation))]
Buffer for reading all the information we need to upgrade from protoqueue to queue.
struct GNUNET_SCHEDULER_Task * read_task
ID of read task for this connection.
struct ProtoQueue * next
Kept in a DLL.
Handle for a queue.
unsigned int backpressure
How may messages did we pass from this queue to CORE for which we have yet to receive an acknoweldgem...
struct GNUNET_NETWORK_Handle * sock
socket that we transmit all data with on this queue
struct GNUNET_PEERSTORE_IterateContext * handshake_ack_monotime_get
Iteration Context for retrieving the monotonic time send with the handshake ack.
int rekeyed
GNUNET_YES if we just rekeyed and must thus possibly re-decrypt ciphertext.
struct GNUNET_TRANSPORT_QueueHandle * qh
handle for this queue with the ch.
struct GNUNET_HashCode out_hmac
Shared secret for HMAC generation on outgoing data, ratcheted after each operation.
int finishing
Did we enqueue a finish message and are closing down the queue?
socklen_t address_len
Length of the address.
struct GNUNET_MQ_Handle * mq
Message queue we are providing for the ch.
unsigned long long bytes_in_queue
Number of bytes we currently have in our write queue.
char pread_buf[UINT16_MAX+1+sizeof(struct TCPBox)]
Plaintext buffer for decrypted plaintext.
int destroyed
Did we technically destroy this queue, but kept the allocation around because of backpressure not bei...
struct GNUNET_CRYPTO_EcdhePrivateKey ephemeral
Our ephemeral key.
struct GNUNET_PEERSTORE_StoreContext * rekey_monotime_sc
Store Context for retrieving the monotonic time send with key for rekeying.
struct ChallengeNonceP challenge_received
Challenge value received.
size_t cwrite_off
At which offset in the ciphertext write buffer should we append more ciphertext from reading next?
struct GNUNET_PEERSTORE_IterateContext * rekey_monotime_get
Iteration Context for retrieving the monotonic time send with key for rekeying.
char cread_buf[(2 *64 *1024+sizeof(struct TCPBox))]
Buffer for reading ciphertext from network into.
enum GNUNET_NetworkType nt
Which network type does this queue use?
struct GNUNET_SCHEDULER_Task * read_task
ID of read task for this connection.
uint64_t rekey_left_bytes
How many more bytes may we sent with the current out_cipher before we should rekey?
int mq_awaits_continue
Is MQ awaiting a GNUNET_MQ_impl_send_continue() call?
gcry_cipher_hd_t in_cipher
cipher for decryption of incoming data.
struct GNUNET_PEERSTORE_StoreContext * handshake_ack_monotime_sc
Store Context for retrieving the monotonic time send with the handshake ack.
size_t pwrite_off
At which offset in the plaintext output buffer should we append more plaintext for encryption next?
struct GNUNET_TIME_Absolute timeout
Timeout for this queue.
struct ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct sockaddr * address
Address of the other peer.
size_t cread_off
At which offset in the ciphertext read buffer should we append more ciphertext for transmission next?
struct GNUNET_TIME_Absolute rekey_time
Until what time may we sent with the current out_cipher before we should rekey?
struct GNUNET_PeerIdentity target
To whom are we talking to.
char cwrite_buf[(2 *64 *1024+sizeof(struct TCPBox))]
buffer for writing ciphertext to network.
struct GNUNET_PEERSTORE_StoreContext * handshake_monotime_sc
Store Context for retrieving the monotonic time send with the handshake.
size_t pread_off
At which offset in the plaintext input buffer should we append more plaintext from decryption next?
enum GNUNET_TRANSPORT_ConnectionStatus cs
The connection status of this queue.
gcry_cipher_hd_t out_cipher
cipher for encryption of outgoing data.
char pwrite_buf[UINT16_MAX+1+sizeof(struct TCPBox)]
Plaintext buffer for messages to be encrypted.
struct GNUNET_HashCode in_hmac
Shared secret for HMAC verification on incoming data.
struct GNUNET_PEERSTORE_IterateContext * handshake_monotime_get
Iteration Context for retrieving the monotonic time send with the handshake.
struct GNUNET_NETWORK_Handle * listen_sock
Listen socket.
struct GNUNET_SCHEDULER_Task * write_task
ID of write task for this connection.
struct GNUNET_TIME_AbsoluteNBO handshake_ack_monotonic_time
Monotonic time value for handshake ack message.
struct GNUNET_TIME_AbsoluteNBO rekey_monotonic_time
Monotonic time value for rekey message.
struct GNUNET_TIME_AbsoluteNBO handshake_monotonic_time
Monotonic time value for handshake message.
TCP message box.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX.
struct GNUNET_ShortHashCode hmac
HMAC for the following encrypted message.
Ack for the encrypted continuation of TCP initial handshake.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Sender's signature of type GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE_ACK.
struct ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK.
struct GNUNET_PeerIdentity sender
Sender's identity.
Encrypted continuation of TCP initial handshake.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Sender's signature of type GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE.
struct GNUNET_PeerIdentity sender
Sender's identity.
struct ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH.
struct GNUNET_ShortHashCode hmac
HMAC for the following encrypted message.
TCP rekey message box.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral
New ephemeral key.
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Sender's signature of type GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY.
struct GNUNET_ShortHashCode hmac
HMAC for the following encrypted message.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY.
Signature we use to verify that the ack from the receiver of the ephemeral key was really send by the...
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE_ACK.
struct ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_PeerIdentity sender
Identity of the inititor of the TCP connection (TCP client).
struct GNUNET_PeerIdentity receiver
Presumed identity of the target of the TCP connection (TCP server)
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
Signature we use to verify that the ephemeral key was really chosen by the specified sender.
struct ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE.
struct GNUNET_PeerIdentity sender
Identity of the inititor of the TCP connection (TCP client).
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral
Ephemeral key used by the sender.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_PeerIdentity receiver
Presumed identity of the target of the TCP connection (TCP server)
Signature we use to verify that the ephemeral key was really chosen by the specified sender.
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral
Ephemeral key used by the sender.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY.
struct GNUNET_PeerIdentity sender
Identity of the inititor of the TCP connection (TCP client).
struct GNUNET_PeerIdentity receiver
Presumed identity of the target of the TCP connection (TCP server)
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.